Java Stream流的常见生成和操作方法总结

目录

• 一、Stream流简单示例
• 二、Stream流常见生成方式
• 三、Stream流中间操作方法
• filter代码示例
• limit&skip代码示例
• concat&distinct代码示例
• sorted代码示例
• map&mapToInt代码示例

一、Stream流简单示例

需求：

按照要求集合创建和遍历

创建一个结合，存储多个字符串元素

把集合中所有以"张"开头的元素存储到一个新的集合

把"张"开头的集合中的长度为3的元素存储到一个新的集合

遍历上一步得到集合

原始方式示例代码：

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素 
        ArrayList list = new ArrayList();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李尔");
        list.add("张新敏");
        list.add("张天坤");
 
        //把集合中所有以"张"开头的元素存储到一个新的集合 
        ArrayList zhangList = new ArrayList();
 
        for(String s : list) {
            if(s.startsWith("张")) {
                zhangList.add(s);
            }
        }
 
        // System.out.println(zhangList); 
 
        //把"张"开头的集合中的长度为3的元素存储到一个新的集合 
        ArrayList threeList = new ArrayList();
 
        for(String s : zhangList) {
            if(s.length() == 3) {
                threeList.add(s);
            }
        }
 
        // System.out.println(threeList); 
 
        //遍历上一步得到的集合 
        for(String s : threeList) {
            System.out.println(s);
        }
 
        System.out.println("--------");
        //Stream流来改进 
        // list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

使用Stream流示例代码：

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素 
        ArrayList list = new ArrayList();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李尔");
        list.add("张新敏");
        list.add("张天坤");
 
        //Stream流来改进
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() ==
                3).forEach(System.out::println);
    }
}

二、Stream流常见生成方式

生成Stream流的方式：

Collection体系集合

使用默认方法stream()生成流，default Stream stream()

Map体系集合

把Map转成Set集合，间接生成流

数组

通过Stream接口的静态方法of(T...values)生成流

代码演示：

public class StreamDemo {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream()生成流 
        List list = new ArrayList();
        Stream listStream = list.stream();
 
        Set set = new HashSet();
        Stream setStream = set.stream();
 
        //Map体系的集合间接的生成流 
        Map map = new HashMap();
        Stream keyStream = map.keySet().stream();
        Stream valueStream = map.values().stream();
        Stream> entryStream = map.entrySet().stream();
 
        //数组可以通过Stream接口的静态方法of(T... values)生成流 
        String[] strArray = {"hello","world","java"};
        Stream strArrayStream = Stream.of(strArray);
        Stream strArrayStream2 = Stream.of("hello", "world", "java");
        Stream intStream = Stream.of(10, 20, 30);
    }
}

三、Stream流中间操作方法

概念：

中间操作的意思是，执行完成此方法之后，Stream流依然可以继续执行其他操作

常见方法：

方法名	说明
Stream fifilter(Predicate predicate)	用于对流中的数据进行过滤
Stream limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
Stream skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static Stream concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream distinct()	返回由该流的不同元素（根据Object.equals(Object) ）组成的流
Stream sorted()	返回由此流的元素组成的流，根据自然顺序排序
Stream sorted(Comparator comparator)	返回由该流的元素组成的流，根据提供的Comparator进行排序
Stream map(Function mapper)	返回由给定函数应用于此流的元素的结果组成的流
IntStream mapToInt(ToIntFunction mapper)	返回一个IntStream其中包含将给定函数应用于此流的元素的结果

filter代码示例

public class StreamDemo01 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素 
        ArrayList list = new ArrayList();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李尔");
        list.add("张新敏");
        list.add("张天坤");
 
        //需求1：把list集合中以张开头的元素在控制台输出 
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("--------");
 
        //需求2：把list集合中长度为3的元素在控制台输出 
        list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("--------");
 
        //需求3：把list集合中以张开头的，长度为3的元素在控制台输出 
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() ==
                3).forEach(System.out::println);
    }
}

limit&skip代码示例

public class StreamDemo02 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素 
        ArrayList list = new ArrayList();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李尔");
        list.add("张新敏");
        list.add("张天坤");
 
        //需求1：取前3个数据在控制台输出 
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");
 
        //需求2：跳过3个元素，把剩下的元素在控制台输出 
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------");
 
        //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出 
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

concat&distinct代码示例

public class StreamDemo03 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素 
        ArrayList list = new ArrayList();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李尔");
        list.add("张新敏");
        list.add("张天坤");
 
        //需求1：取前4个数据组成一个流 
        Stream s1 = list.stream().limit(4);
 
        //需求2：跳过2个数据组成一个流 
        Stream s2 = list.stream().skip(2);
 
        //需求3：合并需求1和需求2得到的流，并把结果在控制台输出 
        Stream.concat(s1,s2).forEach(System.out::println); 
 
        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复 
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

sorted代码示例

public class StreamDemo04 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素 
        ArrayList list = new ArrayList();
 
        list.add("linqingxia");
        list.add("zhangmanyu");
        list.add("wangzuxian");
        list.add("liuyan");
        list.add("zhangmin");
        list.add("zhangwuji");
 
        //需求1：按照字母顺序把数据在控制台输出 
        list.stream().sorted().forEach(System.out::println); 
 
        //需求2：按照字符串长度把数据在控制台输出 
        list.stream().sorted((s1,s2) -> {
            int num = s1.length()-s2.length();
            int num2 = num==0?s1.compareTo(s2):num;
            return num2;
        }).forEach(System.out::println);
    }
}

map&mapToInt代码示例

public class StreamDemo05 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素 
        ArrayList list = new ArrayList();
 
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");
 
        //需求：将集合中的字符串数据转换为整数之后在控制台输出 
        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println); 
        list.stream().map(Integer::parseInt).forEach(System.out::println); 
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println); 
 
        //int sum() 返回此流中元素的总和 
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

到此这篇关于Java Stream流的常见生成和操作方法总结的文章就介绍到这了,更多相关Java Stream流内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！