Java中的stream流

Java中的stream流

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

• Stream<T> filter(Predicate predicate):用于对流中的数据进行过滤Predicate接口中的方法
• boolean test(T t):对给定的参数进行判断,返回一个布尔值
• Stream<T> limit(long maxSize):返回此流中的元素组成的流，截取前指定参数个数的数据
• Stream<T> skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流static <T> Stream<T> concat(Stream a, Stream b):合并a和b两个流为一个流
• Stream<T> distinct():返回由该流的不同元素(根据Objectequals(Object)）组成的流Stream<T> sorted():返回由此流的元素组成的流，根据自然顺序排序
• Stream<T> sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序<R> Stream<R> map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流Function接口中的方法IntStreammapToInt(ToIntFunction mapper):返回一个ntStream其中包含将给定函数应用于此流的元素的结果IntStream: 表示原始int流TolntFunction接口中的方法  int applyAsInt(Tvalue)

下面给出几个案例

1.filter and limit and skip

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

public class StreamDemo2 {
    public static void main(String[] args) {
        //筛选操作
        String [] str={"ljy","wq","znx","wyl"};
        Arrays.stream(str).filter(s->s.length()==3).filter(s->s.startsWith("l")).forEach(System.out::println);

        ArrayList<String>array=new ArrayList<String>();
        for(int i=0;i<6;i++){
            array.add(String.valueOf(i*10));
        }
        //取集合中的前三个元素输出到控制台
        array.stream().limit(3).forEach(System.out::println);

        System.out.println("---------------------------");

        //跳过三个元素，把其他元素输出到控制台
        array.stream().skip(3).forEach(System.out::println);
        System.out.println("---------------------------");

        //跳过三个元素把前两个输出
        array.stream().skip(3).limit(2).forEach(System.out::println);
    }
}

2.concat

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

//    static <T> Stream<T> concat(Stream a, Stream b):合并a和b两个流为一个流
//    Stream<T> distinct():返回由该流的不同元素(根据Objectequals(Object)）组成的流
public class StreamDemo3 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        for(int i=0;i<6;i++){
            array.add(String.valueOf(i*10));
        }

        //取前四个元素拿到一个流
        Stream<String> stream1 = array.stream().limit(4);//0,10,20,30
        //跳过前两个元素拿到另一个流
        Stream<String> stream2 = array.stream().skip(2);//20,30,40,50
        //把两个流合并为一个流并在控制台输出
       // Stream.concat(stream1,stream2).forEach(System.out::println);
        System.out.println("---------------------------------");
        //把连个流合并为一个并且没有重复元素
       Stream.concat(stream1,stream2).distinct().forEach(System.out::println);
    }
}

 3.sorted

import java.util.ArrayList;
//Stream<T> sorted():返回由此流的元素组成的流，根据自然顺序排序
//Stream<T> sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序
public class StreamDemo4 {
    public static void main(String[] args) {
        ArrayList<String>array = new ArrayList<String>();
        array.add("wzt");
        array.add("yzf");
        array.add("ljy");
        array.add("ly");
        array.add("zlx");
        array.add("yt");

        //按照字母顺序在控制台输出
        array.stream().sorted().forEach(System.out::println);
        System.out.println("---------------------------------");
        //按照字符串长度在控制台输出，如果字符串长度相同，按照字母顺序输出
        array.stream().sorted((s1,s2)->{
            int num = s1.length()-s2.length();
            return num==0?s1.compareTo(s2):num;
        }).forEach(System.out::println);
    }
}

4.map and mapToInt

//    <R> Stream<R> map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流Function接口中的方法
//    R apply(Tt)
//    IntStream mapTolntJoIntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流的元素的结果
//    IntStream:表示原始int流
//    ToIntFunction接口中的方法
//    int applyAsInt(T value)

import java.util.ArrayList;

public class StreamDemo5 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        array.add("10");
        array.add("20");
        array.add("30");
        array.add("40");
        array.add("50");
        array.add("60");

        //将集合中的字符串转换为整数输出
        array.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
        //array.stream().map(Integer::parseInt).forEach(System.out::println);  方法引用

        //int sum()返回mapToInt流中的元素总和
        int sum = array.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
    }
}

2.Stream流中的常用终结操作方法

• void forEach(Consumer action):对此流的每个元素执行操作Consumer接口中的方法
• void accept(T t):对给定的参数执行此操作
• long count():返回此流中的元素数

下面给出这些方法的案例

//    Stream流的常见终结操作方法
//    void forEach(Consumer action):对此流的每个元素执行操作
//    Consumer接口中的方法
//    void accept(T t):对给定的参数执行此操作
//    long count():返回此流中的元素

import java.util.ArrayList;

public class StreanDemo6 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        array.add("ljy");
        array.add("zst");
        array.add("gx");
        array.add("znx");
        array.add("atq");
        array.add("zsy");

        //把集合中的元素在控制台输出
        array.stream().forEach(System.out::println);

        //统计以z开头的元素个数
        long count = array.stream().filter(s -> s.charAt(0) == 'z').count();
        //也可以调用startsWith方法
        //array.stream().filter(s->s.startsWith("z")).count();
        System.out.println(count);
    }
}

3.Stream流的收集操作

• Stream流的收集方法
• R collect(Collector collector)但是这个收集方法的参数是一个Collector接口
• 工具类Collectors提供了具体的收集方式
• public static <T> Collector toList():把元素收集到List集合中
• public static <T> Collector toSet():把元素收集到Set集合中
• publicstatic Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中

下面给出分别将元素收集在这三种容器的操作

//    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 StreamDemo7 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("ljy");
        list.add("znx");
        list.add("zsy");
        list.add("ly");

        Stream<String> stream1 = list.stream().filter(s -> s.length() == 3);
        List<String> collect = stream1.collect(Collectors.toList());
        for(String str:collect){
            System.out.println(str);
        }

        System.out.println("---------------");

        Set<Integer> s =  new HashSet<Integer>();
        s.add(10);
        s.add(20);
        s.add(30);
        s.add(50);
        //得到大于25的流
        Stream<Integer> integerStream = s.stream().filter(i -> i > 25);
        Set<Integer> collect1 = integerStream.collect(Collectors.toSet());
        for(Integer i : collect1){
            System.out.println(i);
        }
        System.out.println("----------------");

        String[] strarray={"ljy,18","znx,19","ly,20"};
        //得到年龄数据大于十八的流
        Stream<String> arrayStream = Stream.of(strarray).filter(ss -> Integer.parseInt(ss.split(",")[1]) > 18);

        //姓名做键年龄值
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap(ss -> ss.split(",")[0], ss -> Integer.parseInt(ss.split(",")[1])));

        //map集合遍历
        Set<String> Keyset = map.keySet();
        for(String key :Keyset){
            Integer value = map.get(key);
            System.out.println(key+","+value);
        }

    }
}