Java中Stream流的使用方法

为什么要使用Stream流？

Stream流是JDK1.8更新后带来的新特性，通过将要处理的元素视作为在管道中的流，并进行诸如筛选，排序，分组等等的处理，通过Stream流进行数据处理可以极大的提高程序员的代码编写效率，还能提高代码的简洁度。

如何获取Stream流

获取Stream流的方式主要有以下三种。

1. 通过Collection获取流:
   Java在Collection接口中提供了default方法，Collection接口的所有实现类都可以通过下面的方式获取Stream流

public class JavaStreamTest01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();
        Vector<String> vector = new Vector<>();
        Stream<String> stream3 = vector.stream();
    }
}

2. 通过Map获取流
   Map是以Key-Value的形式来保存数据的，因此也要分3种情况来获取Stream流，分别是Key，Value以及Entry，具体的获取方式如下

public class JavaStreamTest02 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        Set<String> key = map.keySet();
        Set<String> value = (Set<String>) map.values();
        
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<String> keyStream = key.stream();
        Stream<String> valueStream = value.stream();
        Stream<Map.Entry<String, String>> entryStream = entries.stream();
    }
}

3. 根据数组来获取流
   Java中给输注获取流提供了非常简洁的方式，具体的获取方式如下

public class JavaStreamTest03 {
    public static void main(String[] args) {
        String[] arr=new String[]{"苹果","香蕉","草莓"};
        Stream<String> stream = Stream.of(arr);
    }
}

常用的对流进行的中间操作

1. 遍历逐一处理（forEach）

public class JavaStreamTest04 {
    public static void main(String[] args) {
        String[] arr=new String[]{"苹果","香蕉","草莓"};
        Stream<String> stream=Stream.of(arr);
        stream.forEach(s-> System.out.println(s));
    }
}

结果:

2. 过滤处理（filter）

public class JavaStreamTest05 {
    public static void main(String[] args) {
        String[] arr=new String[]{"苹果","香蕉","草莓"};
        Stream<String> stream=Stream.of(arr);
        Stream<String> stream2 = stream.filter(s -> s.startsWith("苹"));
        stream2.forEach(s -> System.out.println(s));
    }
}

结果:

3. 映射（map）
   将当前流的数据类型映射成另一种数据类型

public class JavaStreamTest06 {
    public static void main(String[] args) {
        String[] arr=new String[]{"12","33","44"};
        Stream<String> stream=Stream.of(arr);
        Stream<Integer> stream2 = stream.map(s -> Integer.parseInt(s));
        stream2.forEach(s -> System.out.println(s));
    }
}

结果：

4. 统计流中元素的个数（count）

public class JavaStreamTest07 {
    public static void main(String[] args) {
        String[] arr=new String[]{"12","33","44"};
        Stream<String> stream=Stream.of(arr);
        long count = stream.count();
        System.out.println(count);
    }
}

结果：

5. 截取特定数量的前几个流元素（limit）

public class JavaStreamTest08 {
    public static void main(String[] args) {
        String[] arr=new String[]{"12","33","44"};
        Stream<String> stream=Stream.of(arr);
        Stream<String> limit = stream.limit(2);
        limit.forEach(s -> System.out.println(s));
    }
}

结果：

6. 跳过前几个，获取之后的流（skip）

public class JavaStreamTest09 {
    public static void main(String[] args) {
        String[] arr=new String[]{"12","33","44"};
        Stream<String> stream=Stream.of(arr);
        Stream<String> skip = stream.skip(2);
        skip.forEach(s -> System.out.println(s));
    }
}

结果：

7. 组合流（concat）
   当有两个流并希望将他们组合起来时可以使用这个方法

public class JavaStreamTest10 {
    public static void main(String[] args) {
        String[] arr=new String[]{"12","33","44"};
        String[] arr2=new String[]{"苹果","香蕉","草莓"};
        Stream<String> stream1=Stream.of(arr);
        Stream<String> stream2 = Stream.of(arr2);
        Stream<String> concat = Stream.concat(stream1, stream2);
        concat.forEach(s -> System.out.println(s));
    }
}

结果：

8. 排序（sorted）

public class JavaStreamTest11 {
    public static void main(String[] args) {
        String[] arr=new String[]{"张无忌","张三丰","张翠山","张一元"};
        Stream<String> stream = Stream.of(arr);
        stream.sorted().forEach(s -> System.out.println(s));
    }
}

结果：

9. 去重（distinct）
   顾名思义用来去除流中重复的元素

public class JavaStreamTest {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add(1);
        list.add(2);
        list.add(1);
        list.add(4);
        list.add(2);
        list.add(6);
        Stream stream = list.stream();
        stream.distinct().forEach(s-> System.out.println(s));
    }
}

结果：

常用的对Stream流的终结操作

1. 元素收集操作

String[] arr=new String[]{"张无忌","张三丰","张翠山","张一元"};

Stream<String> stream = Stream.of(arr);
//收集到set集合
Set<String> collect = stream.collect(Collectors.toSet());
//收集到list集合
List<String> collect1 = stream.collect(Collectors.toList());
//收集到数组
String[] strings = (String[]) stream.toArray();

2. 查找

public class JavaStreamTest12 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Stream stream = list.stream();
        Stream stream2 = list.stream();
        Stream<Integer> stream3 = list.stream();
        Stream<Integer> stream4 = list.stream();
        //返回流中的第一个元素
        int f1 = (int) stream.findFirst().get();
        System.out.println(f1);
        //返回流中的任意一个元素
        int f2 = (int) stream2.findAny().get();
        System.out.println(f2);
        //返回流中最大的元素
        int max = stream3.max((o1, o2) ->o1>o2?1:-1).get();
        System.out.println(max);
        //返回流中最小元素
        int min = stream4.min((o1, o2) -> o1>o2?1:-1).get();
        System.out.println(min);
    }
}

3. 字符串拼接（joining）
   可以将Stream流中的元素通过自定义的规则拼接起来

public class JavaStreamTest13 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        System.out.println(list.stream().collect(Collectors.joining(",")));
    }
}

结果：