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

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

1.遍历逐一处理（forEach）

public class JavaStreamTest01 {
    public static void main(String[] args) {
//        逐一遍历处理（forEach）
        String[] arr=new String[]{"苹果","香蕉","草莓"};
        Stream<String> stream=Stream.of(arr);
        stream.forEach(s-> System.out.println(s));

    }
}

结果：

 2.过滤处理（filter）

public class JavaStreamTest02 {
    public static void main(String[] args) {
//        过滤处理(filter)
        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 JavaStreamTest03 {
    public static void main(String[] args) {
//        映射(map)
        String[] arr=new String[]{"11","22","33"};
        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 JavaStreamTest04 {
    public static void main(String[] args) {
//        统计流中元素的个数(count)
        String[] arr=new String[]{"11","22","33"};
        Stream<String> stream=Stream.of(arr);
        long count=stream.count();
        System.out.println("stream中的元素个数为:"+count);
    }
}

结果：

5. 截取特定元素的前几个元素(limit)

public class JavaStreamTest05 {
    public static void main(String[] args) {
//        截取特定元素的前几个元素(limit)
        String[] arr=new String[]{"11","22","33"};
        Stream<String> stream=Stream.of(arr);
        Stream<String> stream2=stream.limit(2);
        stream2.forEach(s-> System.out.println(s));
    }
}

结果：

6.跳过前几个，获取后面的流(skip)

public class JavaStreamTest06 {
    public static void main(String[] args) {
//        跳过前几个，获取后面的流(skip)
        String[] arr=new String[]{"11","22","33"};
        Stream<String> stream=Stream.of(arr);
        Stream<String> stream2=stream.skip(2);
        stream2.forEach(s -> System.out.println(s));
    }
}

结果： 

7.组合流(concat)，当有两个流，并希望它们能组合的时候可以使用

public class JavaStreamTest07 {
    public static void main(String[] args) {
//      组合流(concat)，当有两个流，并希望它们能组合的时候可以使用
        String[] arr1=new String[]{"11","22","33"};
        String[] arr2=new String[]{"苹果","香蕉","草莓"};
        Stream<String> stream1=Stream.of(arr1);
        Stream<String> stream2=Stream.of(arr2);
        Stream<String> stream=Stream.concat(stream1,stream2);
        stream.forEach(s -> System.out.println(s));
    }
}

结果：

8.排序(sort)

public class JavaStreamTest08 {
    public static void main(String[] args) {
//        排序(sort)
        String[] arr=new String[]{"11","33","44","22"};
        Stream<String> stream=Stream.of(arr);
        stream.sorted().forEach(s -> System.out.println(s));
    }
}

结果 ：

9. 去重(distinct)

public class JavaStreamTest09 {
    public static void main(String[] args) {
//        去重(distinct)
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(2);
        list.add(5);
        list.add(1);
        Stream<Integer> stream=list.stream();
        stream.distinct().forEach(s-> System.out.println(s));
    }
}

结果：

 这篇到这里也就结束，其实对流的操作还有很多，我只是将常见的流的操作写入这篇文章中，接下来一篇我将为大家讲Java中常用的对Stream流的终结操作，下期再见了！！