java---Stream流

Stream流的生成方式

package Stream流;
/*
    Stream流的生成方式
        Stream流的常见生成方式
            1，Collection体系的集合可以使用默认方法stream()生成流
                default Stream<E> stream()
            2，Map体系的集合间接的生成流
            3，数组可以通过Stream接口的静态方法 of(T…values)生成流
 */
 
import java.util.*;
import java.util.stream.Stream;
 
public class Stream流的生成方式 {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream()生成流
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();
 
        Set<String> set = new HashSet<String>();
        Stream<String> setStream = set.stream();
 
        //Map体系的集合间接的生成流
        Map<String, String> map = new HashMap<String, String>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<String> valueStrean = map.values().stream();
 
        Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
 
 
        //数组可以通过Stream接口的静态方法 of(T…values)生成流
        String[] strArray={"hello", "world", "java"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);
    }
}

Stream流中常见的中间操作方法

package Stream流;
/*
    1,Stream <T> filter(Predicate predicate):用于对流中的数据进行过滤
        Predicate接口中的方法 boolean test(T t):对给定的参数进行判断，返回一个布尔值
    2,Stream <T> limit(long maxSize):返回此流中的元素组成的流，截取前指定参数个数的数据
    3,Stream <T> skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流
    4,static <T> Stream <T> concat(Stream a,Stream b):合并a和b两个流为一个流
    5,Stream <T> distinct):返回由该流的不同元素(根据Object.equals(Object))组成的流 Stream<T>sorted0:返回由此流的元素组成的流，根据自然顺序排序
 */
import java.util.ArrayList;
import java.util.stream.Stream;
 
public class Stream流中常见的中间操作方法 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("萧炎");
        list.add("药老");
        list.add("海波东");
        list.add("萧熏儿");
        list.add("萧战");
        list.add("云韵");
        //需求1：把list集合中以张开头的元素输出在控制台
        list.stream().filter(s -> s.startsWith("萧")).forEach(System.out::println);
        System.out.println("--------");
 
        //需求2：把list集合中长度为3的元素在控制台输出
        list.stream().filter(s->s.length()==3).forEach(System.out::println);
        System.out.println("--------");
 
        //需求3：把list集合中的以萧开头的，长度为3的元素输出在控制台
        list.stream().filter(s->s.length()==3).filter(s->s.startsWith("萧")).forEach(System.out::println);
        System.out.println("--------");
 
        //需求4，取前3个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");
 
        //需求5：跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------");
 
        //需求6：跳过2个元素，把剩下的元素中的前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
        System.out.println("--------");
 
        //需求7：取前4个组成一个流
        Stream<String> s1 = list.stream().limit(4);
 
        //跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
 
        //合并s1和s2，把结果输出在控制台
/*        Stream.concat(s1, s2).forEach(System.out::println);
        System.out.println("--------");*/
 
        //合并s1和s2，把结果输出在控制台,要求字符串不能重复
        Stream.concat(s1, s2).distinct().forEach(System.out::println);
 
 
    }
}

package Stream流;
/*
     1,Stream <T> sorted():返回由此流的元素组成的流，根据自然顺序排序
     2,Stream <T> sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序
     3,<R> Stream <R> map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流
         Function接口中的方法  R apply(T t)
     4,IntStream map ToInt(ToIntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流的元素的结果
 */
 
import java.util.ArrayList;
 
public class Stream流中常见的中间操作方法2 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("xiaoyan");
        list.add("yaolao");
        list.add("haibodong");
        list.add("xiaoxuner");
        list.add("xiaozhan");
        list.add("yunyun");
 
        //需求1：按照字母顺序把数据输出在控制台
        list.stream().sorted().forEach(System.out::println);
        System.out.println("--------");
 
        //需求2：按照字符串长度顺序把数据输出在控制台
        list.stream().sorted((s1, s2) ->{
            int num = s1.length()-s2.length();
            int num2=num==0 ? s1.compareTo(s2) : num;
            return num2;
        }).forEach(System.out::println);
 
 
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list2 = new ArrayList<String>();
 
        list2.add("10");
        list2.add("20");
        list2.add("30");
        list2.add("40");
        list2.add("50");
 
        //需求：将集合的字符串数据转换为整数之后在控制台输出
        list2.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
        list2.stream().map(Integer::parseInt).forEach(System.out::println);
 
        list2.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
 
        //int sum() 返回此流中元素的总和
        int result = list2.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
 
    }
}

Stream流的常见的终结操作方法

package Stream流;
/*
    Stream流的常见终结操作方法
        void forEach(Consumer action):对此流的每个元素执行操作
        Consumer接口中的方法 void accept(T t):对给定的参数执行此操作
        long count()返回此流中的元素数
 */
 
import java.util.ArrayList;
 
public class Stream流的常见的终结操作方法 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("萧炎");
        list.add("药老");
        list.add("海波东");
        list.add("萧熏儿");
        list.add("萧战");
        list.add("云韵");
 
        //需求1：把集合中的元素在控制台输出
        list.stream().forEach(System.out::println);
 
        //需求2：统计集合中有几个以萧开头的元素，把统计结果在控制台输出
        long count = list.stream().filter(s -> s.startsWith("萧")).count();
        System.out.println(count);
 
    }
}

Stream流的收集操作

package Stream流;
/*
    Stream流的收集操作
        对数据使用Stream流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办呢?
    Stream流的收集方法
            R collect(Collector collector)
            但是这个收集方法的参数是一个Collector接口
    工具类Collectors提供了具体的收集方式
        public static<T>Collector toList):把元素收集到List集合中
        public static<T>Collector toSet):把元素收集到Set集合中
        public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中
 */
 
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class Stream流的收集操作 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        List<String> list = new ArrayList<String>();
 
        list.add("萧炎");
        list.add("药老");
        list.add("海波东");
        list.add("萧熏儿");
 
        //需求1：得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
 
        //需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for(String name:names){
            System.out.println(name);
        }
 
        //创建set集合
        Set<Integer> set = new HashSet<Integer>();
 
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);
        set.add(50);
 
        //需求3：得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(s -> s > 25);
 
        //需求4：把使用Stream流操作完毕的数据收集到set集合中并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for(Integer age : ages) {
            System.out.println(age);
        }
 
        //定义一个字符串数组，每一个字符串数组由姓名和年龄数据组合而成
        String[] strArray={"萧炎,19","药老,50","海波东,40","萧熏儿,18"};
 
        //需求5：得到年龄大于28的流
        Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);
 
        //需求6：把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
        Map<String, Integer> map = new HashMap<String, Integer>();arrayStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1]) > 28));
 
        Set<String> keySet=map.keySet();
        for(String key : keySet) {
            Integer value = map.get(key);
            System.out.println(key+","+value);
        }
 
    }
}