java学习--day24（stream流）

文章目录

1.基于接口和抽象类的匿名内部类的写法
abstract class Person {
	public abstract void eat();
}
public static void main (String[] args) {
	Person person = new Person () {
		public void eat () {
			sout();
		}
	};
	person.eat();
}
1
2
3
4
5
6
7
8
9
10
11
2.接口和抽象类的区别

3.throw和throws区别
4.final和finally的区别
5.书写单例模式
6.序列化和反序列化的概念

今天的内容

1.Stream流

2.水果管理系统

1.Stream【难点】

Stream解决集合类库现有的弊端

先在有一个需求：

将list集合中姓张的名字元素过滤到新的集合中

package com.qfedu.a_stream;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class Demo1 {
    public static void main(String[] args) {
        //将list集合中姓张的名字元素过滤到新的集合中
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张小三");
        list.add("李四");
        list.add("王五");
        list.add("张大山");
        //新建一个新的集合用来存姓张的元素
        List<String> list1 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
                list1.add(s);
            }
        }
        System.out.println(list1);
        System.out.println("=======");
        //如果使用sytream流操作
        //将集合对象转换成流对象
        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));

        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张");
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

1.1获取流的对象

根据集合获取流，将集合中的数据变成流的形式

Collection接口下面的方法 streram();

1.根据List获取流对象

package com.qfedu.a_stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Demo2 {
 public static void main(String[] args) {
    List<String> strings = new ArrayList<>();
    strings.add("老邢");
    strings.add("老邢xiao");
    strings.add("xiao邢");
    strings.add("xiao老邢");
    //获取流对象
     Stream<String> stream = strings.stream();
     System.out.println(stream);
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.set也可以获取stream对象

package com.qfedu.a_stream;

import java.util.HashSet;
import java.util.Set;
import java.util.stream.Stream;

public class Demo3 {
 public static void main(String[] args) {
     Set<String> set = new HashSet<>();
     set.add("嘻嘻");
     set.add("哈哈");
     Stream<String> stream = set.stream();
     System.out.println(stream);
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.根据map集合获取流对象

package com.qfedu.a_stream;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Stream;

public class Demo4 {
 public static void main(String[] args) {
     Map<String, String> map = new HashMap<>();
     map.put("1", "李四");
     map.put("2", "张三");
     //先获取键
     Set<String> strings = map.keySet();
     Stream<String> stream = strings.stream();
     //获取值
     Collection<String> values = map.values();
     Stream<String> stream1 = values.stream();
     //
     Set<Map.Entry<String, String>> entries = map.entrySet();

     Stream<Map.Entry<String, String>> stream2 = entries.stream();

 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1.2Stream流对象下面

流就是集合中的数据，方法对集合中进行操作的

方法的名称	方法的作用	方法种类	是否支持链式操作
count	统计个数	终结方法	否
forEach	逐个处理数据	终结方法	否
filter	过滤数据	函数的拼接	是
limit	取前几个	函数的拼接	是
skip	跳过前几个	函数的拼接	是
map	映射	函数的拼接	是
concat	拼接	函数的拼接	是

方法种类：

终结方法:对流操作的时候，链式操作的时候一定是写在最后的

函数拼接:方法还可以接着写方法

工厂的流水线:先造手机电池-》再造手机的主板-》造手机端额外壳-》一个成品

1.2.1count和forEach

count：统计流中的元素的个数

forEach:遍历数据的

package com.qfedu.a_stream;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Demo5 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        strings.add("张三");
        strings.add("张三三");
        strings.add("李四");
        strings.add("lisi李四");

        long count = strings.stream().count();
        System.out.println(count);//4
        strings.stream().forEach(s->System.out.println(s));

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1.2.2filter方法

Stream filter(Predicate predicate)返回由与此给定谓词匹配的此流的元素组成的流。
Predicate 是一个判断接口，咱们可以写一写返回值是boolean类型

`Stream`	`filter(Predicate predicate)`返回由与此给定谓词匹配的此流的元素组成的流。
Predicate	是一个判断接口，咱们可以写一写返回值是boolean类型

package com.qfedu.a_stream;

import java.util.ArrayList;
import java.util.List;

public class Demo6 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        strings.add("张三");
        strings.add("张三三");
        strings.add("李四");
        strings.add("lisi李四");
        //filter 看数据流，如果返回的是一个true 就把它留到流中。如果是一个false就把从流中踢出去
        strings.stream().filter(s->s.endsWith("三")).forEach(s-> System.out.println(s));

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.2.3limit

限制，取集合中前几个值

package com.qfedu.a_stream;

import java.util.ArrayList;
import java.util.List;

public class Demo7 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        strings.add("张三");
        strings.add("张三三");
        strings.add("李四");
        strings.add("lisi李四");
        strings.add("老王");
        strings.add("老王八");
        strings.add("小王八");
        //找出前4个元素带有老的元素
        //strings.stream().limit(4).forEach(s-> System.out.println(s));
        strings.stream().limit(4).filter(s->s.contains("老")).forEach(s-> System.out.println(s));

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

1.2.4map方法

用来映射关系

package com.qfedu.a_stream;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;

public class Demo8 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("12");
        list.add("13");
        list.add("14");
        //将集合中集合中字符串转为int类型的数据打印
//        for (String s : list) {
//            System.out.println(Integer.parseInt(s));
//        }
        list.stream().map(s -> Integer.parseInt(s)).forEach(s-> System.out.println(s));
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        }).forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer s) {
                System.out.println(s);
            }
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

1.2.5skip

跳过前几个，取m面的数据

package com.qfedu.a_stream;

import java.util.ArrayList;
import java.util.List;

public class Demo9 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        strings.add("张三");
        strings.add("张三三");
        strings.add("李四");
        strings.add("lisi李四");
        strings.add("老王");
        strings.add("老王八");
        strings.add("小王八");
        strings.stream().skip(3).forEach(s-> System.out.println(s));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.2.6concat

合并两个流

package com.qfedu.a_stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Demo10 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        strings.add("张三");
        strings.add("张三三");
        strings.add("李四");
    
        List<String> strings1 = new ArrayList<>();
        strings1.add("香蕉");
        strings1.add("菠萝");
        strings1.add("西瓜");
        strings1.add("葡萄");
        //先变成流，然后再合并
        Stream<String> stream = strings.stream();
        Stream<String> stream1 = strings1.stream();
        Stream<String> concat = Stream.concat(stream, stream1);
        concat.forEach(s-> System.out.println(s));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1.3收集流

将流转为集合

toList();将流转为list集合

toSet();将流转为set集合

package com.qfedu.a_stream;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo11 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        strings.add("张三");
        strings.add("张三三");
        strings.add("李四");
        strings.add("lisi李四");
        strings.add("老王");
        strings.add("老王八");
        strings.add("小王八");
        Stream<String> stream = strings.stream();
       List<String> collect = stream.collect(Collectors.toList());
        //Set collect1 = stream.collect(Collectors.toSet());
        System.out.println(collect);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

相关阅读:
测试左移和测试右移，我们为何要“上下求索”？
线程池源码解析 1.前导_FutureTask源码解析
 Tuxera NTFS软件安装包2024最新中文版（.dmg）
Redis是如何做缓存的
 灵性图书馆：好书推荐-《零极限》
Centos SFTP搭建
 走访喜开路 | 共建全民大健康元宇宙服务体系预立项
 关于账号安全的一些思考
 网络安全这玩意儿真不建议一般人学...
高级时钟项目（2）Json文件解析学习---C语言版本
原文地址：https://blog.csdn.net/m0_46202060/article/details/133757805