10.14 Stream 流

 数组转集合

Arrays.asList(1,2,3);

目录

 Stream 创建方式    

中间算子

终止算子

---

 Stream 创建方式    

1.数组方式生成Stream流 
2.集合方式生成Stream流 

1.数组方式生成
String[]s1={"asdasd","sadasdas","sadasd"};
VAV
Stream<String>s11 Stream.of(s1);
2.集合方式
List<Integer>list=new ArrayList<>();
List<Integer>list=Arrays.asList(1,2,3);
List.add(3);
list.add(1);
list.add(2);
Stream<Integer>stream list.stream();

3.无限流

3.generate是一个无限流，你放什么，里面就都是什么
配合Limit一起使用，限制个数
Stream<Integer>generate stream.generate(()->2);
generate.limit(3).forEach(x->System.out.println(x));

4.也是无限流

4,iterate也是无限流
第一个传参初始值
第三个传参，Lambda,步长值x+3
Stream<Integer>iterate =Stream.iterate(seed:6,x->x+3);
iterate.limit(3).forEach(x->System.out.println(x));

中间算子

常用方法

1.filter:对元素进行过滤筛选，不符合的就不要了

filter为true留下，为false过滤掉
stream.filter(x->x!=3).forEach(x->System.out.println(x));
stream list.stream();  想二次使用在创建一个新的
stream.filter(x->x!=1).forEach(x->System.out.println(x))

2.distinct(） 去重

distinct,去重
List<Integer>list1=new ArrayList<>();
stream.distinct().forEach(x->List1.add(x));
System.out.println(list);
System.out.println(list1);

3.skip 跳过

skip跳过n个
stream.skip(3).forEach(x->System.out.println(x))

4.limit     取一个集合的前几条数据

stream.limit(3).forEach(x->System.out.println(x));

5. map处理每一项的值，将返回值覆盖掉每一项

stream.map(x->x+2).filter(x->x!=5).fgrEach(x->System.out.println(x）

6.sorted排序

终止算子

1.forEach循环遍历

stream.map(x->x*2).forEach(x->System.out.println(x));

2.min 取最左边  值

Opiional<Integer>min stream.map(x -x 2).min((o1,02)->01-02);
System.out.println(min);

3.max 取最右边的值

stream list.stream();
Optional<Integer>max stream.map(x -x 2).max((o1,02)->02 -01);
System.out.println(max)

4.count()   计数 一般和过滤filter使用

stream list.stream();
long count stream.filter(x->x!=3).cout();
System.out.println(count);
}

5.collect()collect收集器，一般传Collectors.toList(),返回一个新的集合，集合中数据就是处理好的数据

stream list.stream();
List<Integer>collect stream.map(x -x 2).collect(Collectors.toList());
System.out.println(collect);

6.anyMatch是否包含

anyMatch是否包含，contains有局限性，用anyMatch可以完成自定义类的判断
stream list.stream();
boolean b stream.map(x -x 2).anyMatch(x -x =4);
System.out.println(b);
String a="sadasd";
System.out.println(a.contains("z"));
Student name1 new student(
name:"张三"，
age:18):
Student name2 new student(
name:"张三ad",
age:19):
Student name3=new Student(name:"张三dd",
age:28)
Student name4=new Student(name:"张三rr"
age:20);
Student name5=new-Student(name:"张三ew",
age:6);
List<Student>list1=Arrays.asList(name1,name2,name3,name4,name5);
boolean b1 list1.stream().anyMatch(x -x.age =28);
System.out.println(b1);boolean b stream.map(x -x 2).anyMatch(x -x =4);
System.out.println(b);

public static void main(String[] args) {
        List<Integer>list=new ArrayList<>();
        list.add(12);
        list.add(32);
        list.add(14);
        list.add(12);
        list.add(112);
        list.add(112);
        Stream<Integer> stream = list.stream();
        //过滤
      stream.filter(i->i==112).forEach(i -> System.out.println(i));
        System.out.println("===============================去重===================================");
       //每次使用都创建Stream流
        stream=list.stream();
        //去重
        stream.distinct().forEach(i-> System.out.println(i));
        System.out.println("==================================================================");
        //map 操作每一项
        stream=list.stream();
        stream.map(x->x*2).forEach(x-> System.out.println(x));
        System.out.println("==================================================================");
        stream=list.stream();
        //skip 跳过
        stream.skip(2).forEach(x -> System.out.println(x));
        System.out.println("==================================================================");
        stream = list.stream();
        //limit 取数组中前几个数据
        stream.limit(2).forEach(x -> System.out.println(x));
        System.out.println("==================================================================");
        stream = list.stream();
        Optional<Integer> min = stream.limit(3).min((o1, o2) -> o2 - o1);
        System.out.println(min);
        System.out.println("==================================================================");
        stream = list.stream();
        Optional<Integer> max = stream.limit(1).max((o1, o2) -> o1 - o2);
        System.out.println(max);
        System.out.println("==================================================================");
        stream = list.stream();
        List<Integer> collect = stream.map(i -> i + i).filter(i->i!=24).sorted((o1, o2) -> o2-o1).distinct().collect(Collectors.toList());
        System.out.println(collect);
        System.out.println("==================================================================");

    }
}