Java基础——Stream流

1. Stream流概述

1.1 Stream流

Java Stream流是Java 8新特性。

Java Stream流结合了Lambda表达式，简化集合、数组操作。

注：允许使用更加函数式的方式操作数据，不必编写传统的循环迭代代码，提供更高的抽象级别，提高代码的可读性和可维护性。

1.2 Stream流的使用步骤

1. 生成一条Stream流（流水线），并把数据放上去。生成方法
2. 利用Stream流中的Api进行各种操作。

中间方法： 过滤、转换

终结方法： 统计、打印

2. Stream流的生成方法

1. Collection体系的集合可以使用默认方法stream()生成流。List、Set，list.stream()

2. Map体系的集合间接的生成流。Map，map.keySet()，map.values()，map.entrySet()

3. 数组可以通过Arrays中的静态方法stream生成流。Arrays.stream(strArray)

4. 同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流。Stream.of(10, 20, 30)

1.Collection体系的集合可以使用默认方法stream()生成流：

List<String> list = new ArrayList<String>();
Stream<String> listStream = list.stream();

Set<String> set = new HashSet<String>();
Stream<String> setStream = set.stream();

2.Map体系的集合间接的生成流：

Map<String,Integer> map = new HashMap<String, Integer>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> valueStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

3.数组可以通过Arrays中的静态方法stream生成流：

String[] strArray = {"hello","world","java"};
Stream<String> strArrayStream = Arrays.stream(strArray);

4.同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流：

Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
Stream<Integer> intStream = Stream.of(10, 20, 30);

  public static<T> Stream<T> of(T... values) {
     return Arrays.stream(values);
    }

注：该方法的形参是一个可变参数，可以传递零散的数据，也可以传递数组。但数组必须是引用数据类型的，传递基本数据类型，会把整个数组当作一个元素，放到Stream当中。

3. Stream流的中间方法

方法名	说明
Stream<T> filter(Predicate predicate)	过滤
Stream<T> limit(long maxSize)	获取前几个元素
Stream<T> skip(long n)	跳过前几个元素
static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream<T> distinct()	元素去重（依赖hashcode和equals方法）
Stream<R> map(Function<T, R> mapper)	转换流中的数据类型

以ArrayList为例，使用中间方法，首先创建一个ArrayList：

    //创建一个集合，存储多个字符串元素
    ArrayList<String> list = new ArrayList<String>();
    list.add("张三");
    list.add("李四");
    list.add("王五");
    list.add("王二麻子");

1.filter

//filter
list.stream().filter(s -> s.startsWith("张")).forEach(s-> System.out.println(s));

2.limit

获取前三个元素输出：

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

3.skip

跳过3个元素，把剩下的元素在控制台输出

list.stream().skip(3).forEach(s-> System.out.println(s));

跳过2个元素，把剩下的元素中前2个在控制台输出，skip和limit：

list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));

4.contat

合并两个流输出：

//首先获取两个流
Stream<String> s1 = list.stream().limit(4);
Stream<String> s2 = list.stream().skip(2);
//合并两个流输出
Stream.concat(s1,s2).forEach(s-> System.out.println(s));

5.distinct

合并两个流，输出，要求字符串元素不能重复：

//合并两个流，输出，要求字符串元素不能重复
Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));

6.map

转换流中的数据类型：

//map 张无忌-15
list.stream().map(new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        String[] arr = s.split("-");
        String ageString = arr[1];
        int age = Integer.parseInt(ageString);
        return age;
    }
}).forEach(s -> System.out.println(s));

list.stream()
    .map(s -> Integer.parseInt(s.split("-")[1]))
    .forEach(s -> System.out.println(s));
}
}

4. Stream流的终结方法

方法名	说明
void forEach(Consumer action)	对此流的每个元素执行操作
long count()	返回此流中的元素数
toArray()	收集流中数据，放到数组中
collect(Collector collector)	收集流中数据，放到集合中

1.forEach

对此流的每个元素执行操作。

Consumer接口中的方法void accept(T t)：对给定的参数执行此操作，在forEach方法的底层,会循环获取到流中的每一个数据.并循环调用accept方法,并把每一个数据传递给accept方法s就依次表示了流中的每一个数据。所以,我们只要在accept方法中,写上处理的业务逻辑就可以了。

list.stream().forEach(
                new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );
        
list.stream().forEach(
        (String s)->{
            System.out.println(s);
        }
);
        
list.stream().forEach(s->System.out.println(s));

2.count

long count = list.stream().count();

3.toArray

//参数只是负责创建一个指定类型的数组。
String[] array = list.stream().toArray(new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
});

 String[] array = list.stream().toArray(value -> new String[value]);

4.collect

//"张三---男-99"  将所有男性收集起来
List<String> newList = list.stream()
    .filter(s -> "男".equals(s.split("-")[1]))
    .collect(Collectors.toList());

List<String> newList = list.stream()
    .filter(s -> "男".equals(s.split("-")[1]))
    .collect(Collectors.toSet());//去重
//键不能重复    
Map<String, Integer> collect = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(new Function<String, String>() {
    @Override
    public String apply(String s) {
        return s.split("-")[0];
    }
}, new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        return Integer.parseInt(s.split("-")[2]);
    }
}));

Map<String, Integer> collect = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(
           s -> s.split("-")[0],
           s -> Integer.parseInt(s.split("-")[2])));

}
}