Java中Steam流怎么使用

本篇內容介紹了“Java中Steam流怎么使用”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

一. 流的常用創建方法

1-1 使用Collection下的 stream() 和 parallelStream() 方法

List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //獲取一個順序流
Stream<String> parallelStream = list.parallelStream(); //獲取一個并行流

1-2 使用Arrays 中的 stream() 方法，將數組轉成流

Integer[] nums = new Integer[10];
Stream<Integer> stream = Arrays.stream(nums);

1-3 使用Stream中的靜態方法：of()、iterate()、generate()

// 1. of()
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
// 2. iterate()
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);
stream2.forEach(System.out::println); // 0 2 4 6 8 10
// 3. generate()
Stream<Double> stream3 = Stream.generate(Math::random).limit(2);
stream3.forEach(System.out::println);

1-4 使用 BufferedReader.lines() 方法，將每行內容轉成流

BufferedReader reader = new BufferedReader(new FileReader("F:\\test_stream.txt"));
Stream<String> lineStream = reader.lines();
lineStream.forEach(System.out::println);

1-5 使用 Pattern.splitAsStream() 方法，將字符串分隔成流

Pattern pattern = Pattern.compile(",");
Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");
stringStream.forEach(System.out::println);

二、流的中間操作

// 1. 篩選與切片
filter：過濾流中的某些元素
limit skip distinct sorted 都是有狀態操作，這些操作只有拿到前面處理后的所有元素之后才能繼續下去。
limit(n)：獲取前n個元素
skip(n)：跳過前n元素，配合limit(n)可實現分頁
distinct：通過流中元素的 hashCode() 和 equals() 去除重復元素
// 2. 映射
map：接收一個函數作為參數，該函數會被應用到每個元素上，并將其映射成一個新的元素。
flatMap：接收一個函數作為參數，將流中的每個值都換成另一個流，然后把所有流連接成一個流。
// 3. 消費 peek , 類似map，    
//        map接收的是一個Function表達式，有返回值；
//        而peek接收的是Consumer表達式，沒有返回值。
// 4. 排序
sorted()：自然排序，流中元素需實現Comparable接口
sorted(Comparator com)：定制排序，自定義Comparator排序器
// 5.

2-1 篩選、去重與切片：filter、distinct、skip、limit

// 實例：集合內元素>5,去重，跳過前兩位，取剩下元素的兩個返回為新集合
Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);
Stream<Integer> newStream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14
 .distinct() //6 7 9 8 10 12 14
 .skip(2) //9 8 10 12 14
 .limit(2); //9 8
newStream.forEach(System.out::println);

2-2 映射：map、flatMap

// 1. Map可以看成一個轉換器，傳入一個對象，返回新的對象
// map的使用實例   stream.map(x->x.getId());
List<String> list = Arrays.asList("a,b,c", "1,2,3");
// 去掉字符串中所有的,
List<String> collect = list.stream().map(s -> s.replaceAll(",", "")).collect(Collectors.toList());
// collect集合內容為：{abc,123}
System.out.println(collect);

// 2. flatMap   效果：結果展平 ，即把嵌套集合，按照子集合的形式，統一放入到新的一個集合中    
//                接收一個函數作為參數，將流中的每個值都換成另一個流，
//                然后把所有流連接成一個流。
Stream<String> stringStream = list.stream().flatMap(s -> {
    // 將字符串以,分割后得到一個字符串數組
    String[] split = s.split(",");
    // 然后將每個字符串數組對應流返回，flatMap會自動把返回的所有流連接成一個流
    Stream<String> stream = Arrays.stream(split);
    return stream;
});
// stringStream.collect(Collectors.toList())的集合內容為：{a,b,c,1,2,3}
System.out.println(stringStream.collect(Collectors.toList()));

2-3 歸約：統計-計算-邏輯處理：reduce

//    說明：reduce看似效果和map相似，
//            但reduce返回的是函數經過執行運算后的結果,
//            而map返回的是處理后新的集合
List<String> memberNames = new ArrayList<>();
memberNames.add("Amitabh");
memberNames.add("Shekhar");
memberNames.add("Aman");
memberNames.add("Rahul");
memberNames.add("Shahrukh");
memberNames.add("Salman");
memberNames.add("Yana");
memberNames.add("Lokesh");

// 將集合中的元素按照#連接成字符串，并返回放置在Optional<String>中
Optional<String> reduced = memberNames.stream()
        .reduce((s1,s2) -> s1 + "#" + s2);
// 有值則取出打印顯示        
reduced.ifPresent(System.out::println);  
// 輸出內容：   Amitabh#Shekhar#Aman#Rahul#Shahrukh#Salman#Yana#Lokesh

// 計算統計實例：
    /**
     * T reduce(T identity, BinaryOperator<T> accumulator);
     * identity：它允許用戶提供一個循環計算的初始值。
     * accumulator：計算的累加器，
     */
    private static void testReduce() {
        //T reduce(T identity, BinaryOperator<T> accumulator);
        System.out.println("給定個初始值，求和");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (sum, item) -> sum + item));
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::sum));
        // 輸出：110

        System.out.println("給定個初始值，求min");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (min, item) -> Math.min(min, item)));
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::min));
        // 輸出：1

        System.out.println("給定個初始值，求max");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (max, item) -> Math.max(max, item)));
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::max));
        // 輸出：100
 
        //Optional<T> reduce(BinaryOperator<T> accumulator);
        // 注意返回值，上面的返回是T,泛型，傳進去啥類型，返回就是啥類型。
        // 下面的返回的則是Optional類型
        System.out.println("無初始值，求和");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::sum).orElse(0)); 
        // 輸出：10
        Integer sum=Stream.of(1, 2, 3, 4).reduce((x,y)->x+y).get();
        System.out.println(sum);  // 輸出：10
        
        System.out.println("無初始值，求max");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::max).orElse(0));
        // 輸出：4 
        
        System.out.println("無初始值，求min");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::min).orElse(0));
        // 輸出：1
 
    }

2-4 排序：sorted

// 按照默認字典順序排序
stream.sorted(); 
// 按照sortNo排序
stream.sorted((x,y)->Integer.compare(x.getSortNo(),y.getSortNo()));
 
2-4-1 函數式接口排序
// 正向排序（默認）
pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId));
// 逆向排序
pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId).reversed());
 
2-4-2 LocalDate 和 LocalDateTime 排序
// 準備測試數據
Stream<DateModel> stream = Stream.of(new DateModel(LocalDate.of(2020, 1, 1))
, new DateModel(LocalDate.of(2021, 1, 1)), new DateModel(LocalDate.of(2022, 1, 1)));

// 正向排序（默認）
stream.sorted(Comparator.comparing(DateModel::getLocalDate))
.forEach(System.out::println);
// 逆向排序
stream.sorted(Comparator.comparing(DateModel::getLocalDate).reversed())
.forEach(System.out::println);

三. 流的終止操作 allMatch,noneMatch,anyMatch,findFirst,findAny,count,max,min

// 匹配和聚合
allmatch，noneMatch，anyMatch用于對集合中對象的某一個屬性值是否存在判斷。
    allMatch全部符合該條件返回true，
    noneMatch全部不符合該斷言返回true
    anyMatch 任意一個元素符合該斷言返回true
// 實例：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
boolean allMatch = list.stream().allMatch(e -> e > 10); //false
boolean noneMatch = list.stream().noneMatch(e -> e > 10); //true
boolean anyMatch = list.stream().anyMatch(e -> e > 4); //true

// 其他一些方法
findFirst：返回流中第一個元素
        String firstMatchedName = memberNames.stream()
                .filter((s) -> s.startsWith("L"))
                .findFirst().get();
findAny：返回流中的任意元素
count：返回流中元素的總個數
    long totalMatched = memberNames.stream()
        .filter((s) -> s.startsWith("A"))
        .count();
max：返回流中元素最大值
min：返回流中元素最小值

3-1 普通收集 – 收集為List

// 默認返回的類型為ArrayList，可通過Collectors.toCollection(LinkedList::new)
//        顯示指明使用其它數據結構作為返回值容器。
List<String> collect = stream.collect(Collectors.toList());

// 由集合創建流的收集需注意：僅僅修改流字段中的內容，沒有返回新類型，
//        如下操作直接修改原始集合，無需處理返回值。
userVos.stream().map(e -> e.setDeptName(hashMap.get(e.getDeptId())))
.collect(Collectors.toList());

// 收集偶數集合的實例：
List<Integer> list = new ArrayList<Integer>();
for(int i = 1; i< 10; i++){
    list.add(i);
}
Stream<Integer> stream = list.stream();
List<Integer> evenNumbersList = stream.filter(i -> i%2 == 0)
                                       .collect(Collectors.toList());
System.out.print(evenNumbersList);

3-2 普通收集 – 收集流為數組(Array)

// list 為 {1,2,3,.....100}
Stream<Integer> stream = list.stream();
Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);

3-3 普通收集 – 收集為Set

// 默認返回類型為HashSet，可通過Collectors.toCollection(TreeSet::new)
//        顯示指明使用其它數據結構作為返回值容器。
Set<String> collect = stream.collect(Collectors.toSet());

3-4 高級收集 – 收集為Map

//    默認返回類型為HashMap，可通過Collectors.toCollection(LinkedHashMap::new)
//        顯示指明使用其它數據結構作為返回值容器

// 測試實體類
@Data
public class Entity {
    private Integer id;
    private String name;
}

// 模擬從數據庫中查詢批量的數據
List<Entity> entityList = Stream.of(new Entity(1,"A"), 
new Entity(2,"B"), new Entity(3,"C")).collect(Collectors.toList());

// 將集合數據轉化成id與name的Map
Map<Integer, String> hashMap = entityList.stream()
.collect(Collectors.toMap(Entity::getId, Entity::getName));

3-5 高級收集 – 分組收集

// 默認使用List作為分組后承載容器
Map<Integer, List<XUser>> hashMap = 
xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId));
 
// 顯示指明使用List作為分組后承載容器
Map<Integer, List<XUser>> hashMap = 
xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId, Collectors.toList()));

// 映射后再分組
Map<Integer, List<String>> hashMap = xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId,Collectors.mapping(XUser::getUserName,Collectors.toList())));

四. Steam拓展

4-1 集合與對象互轉

/**
 * 將單個對象轉化為集合
 *
 * @param t   對象實例
 * @param <T> 對象類型
 * @param <C> 集合類型
 * @return 包含對象的集合實例
 */
public static <T, C extends Collection<T>> Collection<T> toCollection(T t) {
    return toCollection(t, ArrayList::new);
}

/**
 * 用戶自定義返回的集合實例類型:  將單個對象轉化為集合
 *
 * @param t        對象實例
 * @param supplier 集合工廠
 * @param <T>      對象類型
 * @param <C>      集合類型
 * @return 包含對象的集合實例
 */
public static <T, C extends Collection<T>> Collection<T> toCollection(T t, Supplier<C> supplier) {
    return Stream.of(t).collect(Collectors.toCollection(supplier));
}

4-2 集合轉對象

/**
 * 取出集合中第一個元素
 *
 * @param collection 集合實例
 * @param <E>        集合中元素類型
 * @return 泛型類型
 */
public static <E> E toObject(Collection<E> collection) {
    // 處理集合空指針異常
    Collection<E> coll = Optional.ofNullable(collection).orElseGet(ArrayList::new);
    // 此處可以對流進行排序，然后取出第一個元素
    return coll.stream().findFirst().orElse(null);
}

4-3 Java Steam中的并發操作實例

List<Integer> list = new ArrayList<Integer>();
for(int i = 1; i< 10; i++){
    list.add(i);
}
Stream<Integer> stream = list.parallelStream();    // 創建并發流

Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);
System.out.print(evenNumbersArr);   // 打印出的偶數為無規則排序的

“Java中Steam流怎么使用”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！