likes
comments
collection
share

Java基础——Stream流

作者站长头像
站长
· 阅读数 25

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])));

}
}
转载自:https://juejin.cn/post/7297090176878329865
评论
请登录