Java?Stream流的常見生成和操作方法總結(jié)

更新時(shí)間：2022年09月18日 09:45:14 作者：夏志121

從Java1.8開始提出了Stream流的概念，本文將通過示例為大家詳細(xì)講解一下Stream流的常見生成和操作方法，感興趣的小伙伴可以了解一下

一、Stream流簡單示例

需求：

按照要求集合創(chuàng)建和遍歷

創(chuàng)建一個結(jié)合，存儲多個字符串元素

把集合中所有以"張"開頭的元素存儲到一個新的集合

把"張"開頭的集合中的長度為3的元素存儲到一個新的集合

遍歷上一步得到集合

原始方式示例代碼：

public class StreamDemo {
    public static void main(String[] args) {
        //創(chuàng)建一個集合，存儲多個字符串元素 
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李爾");
        list.add("張新敏");
        list.add("張?zhí)炖?);
 
        //把集合中所有以"張"開頭的元素存儲到一個新的集合 
        ArrayList<String> zhangList = new ArrayList<String>();
 
        for(String s : list) {
            if(s.startsWith("張")) {
                zhangList.add(s);
            }
        }
 
        // System.out.println(zhangList); 
 
        //把"張"開頭的集合中的長度為3的元素存儲到一個新的集合 
        ArrayList<String> threeList = new ArrayList<String>();
 
        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流來改進(jìn) 
        // 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) {
        //創(chuàng)建一個集合，存儲多個字符串元素 
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李爾");
        list.add("張新敏");
        list.add("張?zhí)炖?);
 
        //Stream流來改進(jìn)
        list.stream().filter(s -> s.startsWith("張")).filter(s -> s.length() ==
                3).forEach(System.out::println);
    }
}

二、Stream流常見生成方式

生成Stream流的方式：

Collection體系集合

使用默認(rèn)方法stream()生成流，default Stream stream()

Map體系集合

把Map轉(zhuǎn)成Set集合，間接生成流

數(shù)組

通過Stream接口的靜態(tài)方法of(T...values)生成流

代碼演示：

public class StreamDemo {
    public static void main(String[] args) {
        //Collection體系的集合可以使用默認(rèn)方法stream()生成流 
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();
 
        Set<String> set = new HashSet<String>();
        Stream<String> setStream = set.stream();
 
        //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();
 
        //數(shù)組可以通過Stream接口的靜態(tài)方法of(T... values)生成流 
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);
    }
}

三、Stream流中間操作方法

概念：

中間操作的意思是，執(zhí)行完成此方法之后，Stream流依然可以繼續(xù)執(zhí)行其他操作

常見方法：

方法名	說明
Stream fifilter(Predicate predicate)	用于對流中的數(shù)據(jù)進(jìn)行過濾
Stream limit(long maxSize)	返回此流中的元素組成的流，截取前指定參數(shù)個數(shù)的數(shù)據(jù)
Stream skip(long n)	跳過指定參數(shù)個數(shù)的數(shù)據(jù)，返回由該流的剩余元素組成的流
static Stream concat(Stream a, Stream b)	合并a和b兩個流為一個流
Stream distinct()	返回由該流的不同元素（根據(jù)Object.equals(Object) ）組成的流
Stream sorted()	返回由此流的元素組成的流，根據(jù)自然順序排序
Stream sorted(Comparator comparator)	返回由該流的元素組成的流，根據(jù)提供的Comparator進(jìn)行排序
Stream map(Function mapper)	返回由給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的流
IntStream mapToInt(ToIntFunction mapper)	返回一個IntStream其中包含將給定函數(shù)應(yīng)用于此流的元素的結(jié)果

filter代碼示例

public class StreamDemo01 {
    public static void main(String[] args) {
        //創(chuàng)建一個集合，存儲多個字符串元素 
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李爾");
        list.add("張新敏");
        list.add("張?zhí)炖?);
 
        //需求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) {
        //創(chuàng)建一個集合，存儲多個字符串元素 
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李爾");
        list.add("張新敏");
        list.add("張?zhí)炖?);
 
        //需求1：取前3個數(shù)據(jù)在控制臺輸出 
        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) {
        //創(chuàng)建一個集合，存儲多個字符串元素 
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("心如音");
        list.add("流老蛋");
        list.add("王值");
        list.add("李爾");
        list.add("張新敏");
        list.add("張?zhí)炖?);
 
        //需求1：取前4個數(shù)據(jù)組成一個流 
        Stream<String> s1 = list.stream().limit(4);
 
        //需求2：跳過2個數(shù)據(jù)組成一個流 
        Stream<String> s2 = list.stream().skip(2);
 
        //需求3：合并需求1和需求2得到的流，并把結(jié)果在控制臺輸出 
        Stream.concat(s1,s2).forEach(System.out::println); 
 
        //需求4：合并需求1和需求2得到的流，并把結(jié)果在控制臺輸出，要求字符串元素不能重復(fù) 
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

sorted代碼示例

public class StreamDemo04 {
    public static void main(String[] args) {
        //創(chuàng)建一個集合，存儲多個字符串元素 
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("linqingxia");
        list.add("zhangmanyu");
        list.add("wangzuxian");
        list.add("liuyan");
        list.add("zhangmin");
        list.add("zhangwuji");
 
        //需求1：按照字母順序把數(shù)據(jù)在控制臺輸出 
        list.stream().sorted().forEach(System.out::println); 
 
        //需求2：按照字符串長度把數(shù)據(jù)在控制臺輸出 
        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) {
        //創(chuàng)建一個集合，存儲多個字符串元素 
        ArrayList<String> list = new ArrayList<String>();
 
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");
 
        //需求：將集合中的字符串?dāng)?shù)據(jù)轉(zhuǎn)換為整數(shù)之后在控制臺輸出 
        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);
    }
}

到此這篇關(guān)于Java Stream流的常見生成和操作方法總結(jié)的文章就介紹到這了,更多相關(guān)Java Stream流內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: