Stream流

体验Stream

import java.util.ArrayList;

public class MyDemo {
    public static void main(String[] args) {
        //1.创建一个集合，存储多个字符串元素
        //2.把集合中所有以张开头的元素存储到一个新集合
        //3.把张开头的集合中长度为3的存储到新的集合中
        //4.遍历上一步得到的集合
        ArrayList<String> member = new ArrayList<>();
        member.add("张曼玉");
        member.add("张无忌");
        member.add("张三");
        member.add("离死ａｓｄｆ亡");
        member.add("东北人");
        //2.
        ArrayList<String> zhangSt = new ArrayList<>();
        for (String s:member
             ) {
            if(s.startsWith("张")){
                zhangSt.add(s);
            }
        }
        System.out.println(zhangSt);
        //3.n

        ArrayList<String> lenth3 = new ArrayList<>();
        for (String s:zhangSt
             ) {
            if(s.length()>=3){
                lenth3.add(s);
            }
        }
        for (String d:lenth3
             ) {
            System.out.println(d);
        }
        //上述步骤太复杂可以使用Stream流来代替
        member.stream().filter(s->s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);
    //filter传入条件的lambda
        //最后使用forEach函数进行消费
    }
}

Stream流生产方式
生成流
list.stream()
中间操作
filter()
终结操作
forEach()

集合中的Stream流使用
1.collection体系的集合可以使用系统默认方法stream()生成流
default Stream<E> stream()
2.map体系的集合间接的生成流
3.数组可以通过Stream接口的静态方法of(T..value)生成流

import java.util.*;
import java.util.stream.Stream;

public class MyDemo {
    public static void main(String[] args) {
//        1.collection体系的集合可以使用系统默认方法stream()生成流
//        default Stream<E> stream()
//        2.map体系的集合间接的生成流
//        3.数组可以通过Stream接口的静态方法of(T..value)生成流
        //1.
        List<String> member = new ArrayList<>();
        member.add("张曼玉");
        member.add("张无忌");
        member.add("张三");
        member.add("离死ａｓｄｆ亡");
        member.add("东北人");
        Stream<String> stream = member.stream();
        Set<String> set = new HashSet<>();
        Stream<String> stream1 = set.stream();
        //2.
        HashMap<String, Integer> stringIntegerHashMap = new HashMap<>();
        Stream<String> stream2 = stringIntegerHashMap.keySet().stream();//得到键的stream流
        Stream<Integer> stream3 = stringIntegerHashMap.values().stream();//得到值的流
        Set<Map.Entry<String, Integer>> entries = stringIntegerHashMap.entrySet();//得到键值对象的流

        //3.
        String [] stray={"hello","java"};
        Stream<String> stray1 = Stream.of(stray);
        Stream<String> hello = Stream.of("hello", "java");

    }
}

filter方法

import java.util.*;
import java.util.stream.Stream;

public class MyDemo {
    public static void main(String[] args) {
//        1.collection体系的集合可以使用系统默认方法stream()生成流
//        default Stream<E> stream()
//        2.map体系的集合间接的生成流
//        3.数组可以通过Stream接口的静态方法of(T..value)生成流
        //1.
        List<String> member = new ArrayList<>();
        member.add("张曼玉");
        member.add("张无忌");
        member.add("张三");
        member.add("离死ａｓｄｆ亡");
        member.add("东北人");
     member.stream().filter((String s)->{return s.startsWith("张");}).forEach(System.out::println);
        member.stream().filter((String s)->{return s.length()==3;}).forEach(System.out::println);
        member.stream().filter((String s)->{return s.length()==3;}).filter((String s)->{return s.startsWith("张");}).forEach(System.out::println);

    }
}

limit方法:返回此流中的元素组成的流,截取前指定参数个数的数据
skip方法:跳过指定参数个数的数据,返回有盖流的剩余元素组成的流

import java.util.*;
import java.util.stream.Stream;

public class MyDemo {
    public static void main(String[] args) {
//        1.collection体系的集合可以使用系统默认方法stream()生成流
//        default Stream<E> stream()
//        2.map体系的集合间接的生成流
//        3.数组可以通过Stream接口的静态方法of(T..value)生成流
        //1.
        List<String> member = new ArrayList<>();
        member.add("张曼玉");
        member.add("张无忌");
        member.add("张三");
        member.add("离死ａｓｄｆ亡");
        member.add("东北人");
    //需求1取前三个显示
        member.stream().limit(3).forEach(System.out::println);
        System.out.println("--------------");
        //跳过三个元素把剩下的在控制台暑促
        member.stream().skip(3).forEach(System.out::println);
        System.out.println("---------------");
        //需求三跳过前两个把剩下的前两个输出
        member.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

//concat 合并a和B两个流为一个流
//disinct 返回由该流的不同元素，组成的流

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

public class Testjava {
    //concat 合并a和B两个流为一个流
    //disinct 返回由该流的不同元素，组成的流，里面运用了equse进行了判断，将重复的只取一个
    public static void main(String[] args) {
        //创建一个集合存储多个字符串
        ArrayList<String> mamber = new ArrayList<String>();
        mamber.add("林檎下");
        mamber.add("San Zhang");
        mamber.add("tangbohu");
        mamber.add("shenlongshi");
        mamber.add("ChengLong Yan");
        mamber.add("San Zhang");
        mamber.add("San Zhang");
        //去前四个数组组成一个流
        Stream<String> s1 = mamber.stream().limit(4);
        //跳过两个数据组成一个流
        Stream<String> s2 = mamber.stream().skip(2);
        //合并1和2得到的流，并把结果输出控制台
//        Stream.concat(s1,s2).forEach(System.out::println);  //concat处理后在使用时会报错
        //合并1和2得到的流，并把结果输出，要求不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
     
    }
}

/*
sored返回由此流的元素组成的流，根据自然顺序排序
sored返回该流的元素组成的流，根据提供的comparator进行排序
*/

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

public class Testjava {
  /*
  sored返回由此流的元素组成的流，根据自然顺序排序
  sored返回该流的元素组成的流，根据提供的comparator进行排序
   */
    public static void main(String[] args) {
        //创建一个集合存储多个字符串
        ArrayList<String> mamber = new ArrayList<String>();
        mamber.add("林檎下");
        mamber.add("San Zhang");
        mamber.add("tangbohu");
        mamber.add("shenlongshi");
        mamber.add("ChengLong Yan");
        mamber.add("San Zhang");
        mamber.add("San Ahang");
       //按照字母顺序进行排序输出
//        mamber.stream().sorted().forEach(System.out::println);
        //按照字符串长度进行排序输出
//        mamber.stream().sorted((s1,s2)->s2.length()-s1.length()).forEach(System.out::println);
        mamber.stream().sorted((s1,s2)->{
            int num=s1.length()-s2.length();
            int num2=num==0?s1.compareTo(s2):num;//compareTo字符串排完序后再使用compareTo进行排序
            return num2;
        }).forEach(System.out::println);

    }
}

/*
map返回由给定函数应用于此流的元素结果组成的流
mapToint返回一个intStream其中包含将给定函数应用于此流的元素的结果,然后就可以使用intStream的方法啦
*/

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

public class Testjava {
  /*
  map返回由给定函数应用于此流的元素结果组成的流
  mapToint返回一个intStream其中包含将给定函数应用于此流的元素的结果,然后就可以使用intStream的方法啦
   */
    public static void main(String[] args) {
        //创建一个集合存储多个字符串
        ArrayList<String> mamber = new ArrayList<String>();
        mamber.add("10");
        mamber.add("20");
        mamber.add("35");
        mamber.add("2");

       //将集合中的字符串数据转换为整数之后在控制台输出
//        mamber.stream().map(Integer::parseInt).forEach(System.out::println);
        //
        mamber.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        int sum = mamber.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
        //sum 是IntStream中的


    }
}

/*
ForEach对此流的每个元素执行操作
count()返回此流中的元素数
*/

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

public class Testjava {
  /*
  ForEach对此流的每个元素执行操作
  count()返回此流中的元素数
   */
    public static void main(String[] args) {
        //创建一个集合存储多个字符串
        ArrayList<String> mamber = new ArrayList<String>();
        mamber.add("林檎下");
        mamber.add("San Zhang");
        mamber.add("tangbohu");
        mamber.add("shenlongshi");
        mamber.add("ChengLong Yan");
        mamber.add("San Zhang");
        mamber.add("San Ahang");
//把集合中的元素在控制台输出
    mamber.stream().forEach(System.out::println);
    //统计集合由几个以张开头的元素，并把统计结果在控制台输出
        long san = mamber.stream().filter(s -> s.startsWith("San")).count();
        System.out.println(san);


    }
}

text

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

public class Testjava {
  /*

   */
    public static void main(String[] args) {
        //创建一个集合存储多个字符串
        ArrayList<String> mamber = new ArrayList<String>();
        mamber.add("周润发");
        mamber.add("成龙");
        mamber.add("吴京");
        mamber.add("刘德华");
        mamber.add("李连杰");
        mamber.add("周星驰");
        mamber.add("飞虎队");


        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林青霞");
        womanList.add("张曼玉");
        womanList.add("刘岩");
        womanList.add("林心如");
        womanList.add("贾玲");
        womanList.add("王祖贤");
        //男演员只要名字为3的前三人
        Stream<String> manStream = mamber.stream().filter(s -> s.length() == 3).limit(3);
        //女演员只要姓林的并且不要第一个
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
        //把过滤后的两个流合并在一起
        Stream<String> concat = Stream.concat(manStream, womanStream);
//        concat.map(Actor::new).forEach(System.out::println);
        concat.map(s->new Actor(s)).forEach(s-> System.out.println(s.getName()));
    }
}

Stream收集方法

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Testjava {
    public static void main(String[] args) {
        //创建一个集合存储多个字符串
        ArrayList<String> mamber = new ArrayList<String>();
        mamber.add("周润发");
        mamber.add("成龙");
        mamber.add("吴京");
        mamber.add("刘德华");
        mamber.add("李连杰");
        mamber.add("周星驰");
        mamber.add("飞虎队");
        //的带名字为3个字的流
        Stream<String> stringStream = mamber.stream().filter(s -> s.length() == 3);
        List<String> collect = stringStream.collect(Collectors.toList());
        for (String ss:collect){
            System.out.println(ss);
        }
        Set<Integer> integers = new HashSet<>();
        integers.add(10);
        integers.add(20);
        integers.add(30);
        integers.add(40);
        integers.add(50);


        //得到年龄大于25的流
        Stream<Integer> integerStream = integers.stream().filter(age -> age > 25);
        //得到stream流操作完毕的数据收集到set集合中并遍历
        Set<Integer> collect1 = integerStream.collect(Collectors.toSet());
        for(Integer ss:collect1){
            System.out.println(ss);
        }
    String star[]={"林檎下，20","张曼玉，50","柳岩，25"};
        //得到字符串年龄数据大于28的流
        Stream<String> stringStream1 = Stream.of(star).filter(s -> Integer.parseInt(s.split("，")[1]) > 28);
        Map<String, Integer> collect2 = stringStream1.collect(Collectors.toMap(s -> s.split("，")[0], s -> Integer.parseInt(s.split("，")[1])));
        Set<String> strings = collect2.keySet();
        for (String key:strings
             ) {
            Integer value=collect2.get(key);
            System.out.println(key+","+value);
        }
    }
}