主頁 > 軟體設計 > Java8 Stream：2萬字20個實體，玩轉集合的篩選、歸約、分組、聚合

Java8 Stream：2萬字20個實體，玩轉集合的篩選、歸約、分組、聚合

2020-11-15 00:38:40 軟體設計

Java8 Stream

  • 1 Stream概述
  • 2 Stream的創建
  • 3 Stream的使用
    • 案例使用的員工類
    • 3.1 遍歷/匹配（foreach/find/match）
    • 3.2 篩選（filter）
    • 3.3 聚合（max/min/count)
    • 3.4 映射(map/flatMap)
    • 3.5 歸約(reduce)
    • 3.6 收集(collect)
      • 3.6.1 歸集(toList/toSet/toMap)
      • 3.6.2 統計(count/averaging)
      • 3.6.3 分組(partitioningBy/groupingBy)
      • 3.6.4 接合(joining)
      • 3.6.5 歸約(reducing)
    • 3.7 排序(sorted)
    • 3.8 提取/組合
    • 4 Stream原始碼解讀

點波關注不迷路，一鍵三連好運連連！
在這里插入圖片描述
先貼上幾個案例，水平高超的同學可以挑戰一下：

  1. 從員工集合中篩選出salary大于8000的員工，并放置到新的集合里，
  2. 統計員工的最高薪資、平均薪資、薪資之和，
  3. 將員工按薪資從高到低排序，同樣薪資者年齡小者在前，
  4. 將員工按性別分類，將員工按性別和地區分類，將員工按薪資是否高于8000分為兩部分，

用傳統的迭代處理也不是很難，但代碼就顯得冗余了，跟Stream相比高下立判，

1 Stream概述

Java 8 是一個非常成功的版本，這個版本新增的Stream，配合同版本出現的 Lambda ，給我們操作集合（Collection）提供了極大的便利，

那么什么是Stream？

Stream將要處理的元素集合看作一種流，在流的程序中，借助Stream API對流中的元素進行操作，比如：篩選、排序、聚合等，

Stream可以由陣列或集合創建，對流的操作分為兩種：

  1. 中間操作，每次回傳一個新的流，可以有多個，
  2. 終端操作，每個流只能進行一次終端操作，終端操作結束后流無法再次使用，終端操作會產生一個新的集合或值，

另外，Stream有幾個特性：

  1. stream不存盤資料，而是按照特定的規則對資料進行計算，一般會輸出結果，
  2. stream不會改變資料源，通常情況下會產生一個新的集合或一個值，
  3. stream具有延遲執行特性，只有呼叫終端操作時，中間操作才會執行，

2 Stream的創建

Stream可以通過集合陣列創建，

1、通過 java.util.Collection.stream() 方法用集合創建流

List<String> list = Arrays.asList("a", "b", "c");
// 創建一個順序流
Stream<String> stream = list.stream();
// 創建一個并行流
Stream<String> parallelStream = list.parallelStream();

2、使用java.util.Arrays.stream(T[] array)方法用陣列創建流

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

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

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println); // 0 2 4 6 8 10

Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

輸出結果：

0 3 6 9
0.6796156909271994
0.1914314208854283
0.8116932592396652

stream和parallelStream的簡單區分： stream是順序流，由主執行緒按順序對流執行操作，而parallelStream是并行流，內部以多執行緒并行執行的方式對流進行操作，但前提是流中的資料處理沒有順序要求，例如篩選集合中的奇數，兩者的處理不同之處：
在這里插入圖片描述
如果流中的資料量足夠大，并行流可以加快處速度，

除了直接創建并行流，還可以通過parallel()把順序流轉換成并行流：

Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();

3 Stream的使用

在使用stream之前，先理解一個概念：Optional ，

Optional類是一個可以為null的容器物件，如果值存在則isPresent()方法會回傳true，呼叫get()方法會回傳該物件，
更詳細說明請見：菜鳥教程Java 8 Optional類

接下來，大批代碼向你襲來！我將用20個案例將Stream的使用整得明明白白，只要跟著敲一遍代碼，就能很好地掌握，
在這里插入圖片描述

案例使用的員工類

這是后面案例中使用的員工類：

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, "male", "New York"));
personList.add(new Person("Jack", 7000, "male", "Washington"));
personList.add(new Person("Lily", 7800, "female", "Washington"));
personList.add(new Person("Anni", 8200, "female", "New York"));
personList.add(new Person("Owen", 9500, "male", "New York"));
personList.add(new Person("Alisa", 7900, "female", "New York"));

class Person {
	private String name;  // 姓名
	private int salary; // 薪資
	private int age; // 年齡
	private String sex; //性別
	private String area;  // 地區

	// 構造方法
	public Person(String name, int salary, int age,String sex,String area) {
		this.name = name;
		this.salary = salary;
		this.age = age;
		this.sex = sex;
		this.area = area;
	}
	// 省略了get和set，請自行添加

}

3.1 遍歷/匹配（foreach/find/match）

Stream也是支持類似集合的遍歷和匹配元素的，只是Stream中的元素是以Optional型別存在的，Stream的遍歷、匹配非常簡單，
在這里插入圖片描述

// import已省略，請自行添加，后面代碼亦是

public class StreamTest {
	public static void main(String[] args) {
        List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

        // 遍歷輸出符合條件的元素
        list.stream().filter(x -> x > 6).forEach(System.out::println);
        // 匹配第一個
        Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
        // 匹配任意（適用于并行流）
        Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
        // 是否包含符合特定條件的元素
        boolean anyMatch = list.stream().anyMatch(x -> x < 6);
        System.out.println("匹配第一個值：" + findFirst.get());
        System.out.println("匹配任意一個值：" + findAny.get());
        System.out.println("是否存在大于6的值：" + anyMatch);
    }
}

3.2 篩選（filter）

篩選，是按照一定的規則校驗流中的元素，將符合條件的元素提取到新的流中的操作，
在這里插入圖片描述

案例一：篩選出Integer集合中大于7的元素，并列印出來

public class StreamTest {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
		Stream<Integer> stream = list.stream();
		stream.filter(x -> x > 7).forEach(System.out::println);
	}
}

預期結果：

8 9

案例二： 篩選員工中工資高于8000的人，并形成新的集合， 形成新集合依賴collect（收集），后文有詳細介紹，

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
		personList.add(new Person("Owen", 9500, 25, "male", "New York"));
		personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

		List<String> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName)
				.collect(Collectors.toList());
		System.out.print("高于8000的員工姓名：" + fiterList);
	}
}

運行結果：

高于8000的員工姓名：[Tom, Anni, Owen]

3.3 聚合（max/min/count)

max、min、count這些字眼你一定不陌生，沒錯，在mysql中我們常用它們進行資料統計，Java stream中也引入了這些概念和用法，極大地方便了我們對集合、陣列的資料統計作業，
在這里插入圖片描述

案例一：獲取String集合中最長的元素，

public class StreamTest {
	public static void main(String[] args) {
		List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");

		Optional<String> max = list.stream().max(Comparator.comparing(String::length));
		System.out.println("最長的字串：" + max.get());
	}
}

輸出結果：

最長的字串：weoujgsd

案例二：獲取Integer集合中的最大值，

public class StreamTest {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);

		// 自然排序
		Optional<Integer> max = list.stream().max(Integer::compareTo);
		// 自定義排序
		Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return o1.compareTo(o2);
			}
		});
		System.out.println("自然排序的最大值：" + max.get());
		System.out.println("自定義排序的最大值：" + max2.get());
	}
}

輸出結果：

自然排序的最大值：11
自定義排序的最大值：11

案例三：獲取員工工資最高的人，

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
		personList.add(new Person("Owen", 9500, 25, "male", "New York"));
		personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

		Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
		System.out.println("員工工資最大值：" + max.get().getSalary());
	}
}

輸出結果：

員工工資最大值：9500

案例四：計算Integer集合中大于6的元素的個數，

import java.util.Arrays;
import java.util.List;

public class StreamTest {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);

		long count = list.stream().filter(x -> x > 6).count();
		System.out.println("list中大于6的元素個數：" + count);
	}
}

輸出結果：

list中大于6的元素個數：4

3.4 映射(map/flatMap)

映射，可以將一個流的元素按照一定的映射規則映射到另一個流中，分為map和flatMap：

  • map：接收一個函式作為引數，該函式會被應用到每個元素上，并將其映射成一個新的元素，
  • flatMap：接收一個函式作為引數，將流中的每個值都換成另一個流，然后把所有流連接成一個流，

在這里插入圖片描述
在這里插入圖片描述
案例一：英文字串陣列的元素全部改為大寫，整數陣列每個元素+3，

public class StreamTest {
	public static void main(String[] args) {
		String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
		List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());

		List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
		List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());

		System.out.println("每個元素大寫：" + strList);
		System.out.println("每個元素+3：" + intListNew);
	}
}

輸出結果：

每個元素大寫：[ABCD, BCDD, DEFDE, FTR]
每個元素+3：[4, 6, 8, 10, 12, 14]

案例二：將員工的薪資全部增加1000，

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
		personList.add(new Person("Owen", 9500, 25, "male", "New York"));
		personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

		// 不改變原來員工集合的方式
		List<Person> personListNew = personList.stream().map(person -> {
			Person personNew = new Person(person.getName(), 0, 0, null, null);
			personNew.setSalary(person.getSalary() + 10000);
			return personNew;
		}).collect(Collectors.toList());
		System.out.println("一次改動前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());
		System.out.println("一次改動后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());

		// 改變原來員工集合的方式
		List<Person> personListNew2 = personList.stream().map(person -> {
			person.setSalary(person.getSalary() + 10000);
			return person;
		}).collect(Collectors.toList());
		System.out.println("二次改動前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());
		System.out.println("二次改動后：" + personListNew2.get(0).getName() + "-->" + personListNew.get(0).getSalary());
	}
}

輸出結果：

一次改動前：Tom–>8900
一次改動后：Tom–>18900
二次改動前：Tom–>18900
二次改動后：Tom–>18900

案例三：將兩個字符陣列合并成一個新的字符陣列，

public class StreamTest {
	public static void main(String[] args) {
		List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
		List<String> listNew = list.stream().flatMap(s -> {
			// 將每個元素轉換成一個stream
			String[] split = s.split(",");
			Stream<String> s2 = Arrays.stream(split);
			return s2;
		}).collect(Collectors.toList());

		System.out.println("處理前的集合：" + list);
		System.out.println("處理后的集合：" + listNew);
	}
}

輸出結果：

處理前的集合：[m-k-l-a, 1-3-5]
處理后的集合：[m, k, l, a, 1, 3, 5]

3.5 歸約(reduce)

歸約，也稱縮減，顧名思義，是把一個流縮減成一個值，能實作對集合求和、求乘積和求最值操作，
在這里插入圖片描述

案例一：求Integer集合的元素之和、乘積和最大值，

public class StreamTest {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
		// 求和方式1
		Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
		// 求和方式2
		Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
		// 求和方式3
		Integer sum3 = list.stream().reduce(0, Integer::sum);
		
		// 求乘積
		Optional<Integer> product = list.stream().reduce((x, y) -> x * y);

		// 求最大值方式1
		Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
		// 求最大值寫法2
		Integer max2 = list.stream().reduce(1, Integer::max);

		System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
		System.out.println("list求積：" + product.get());
		System.out.println("list求和：" + max.get() + "," + max2);
	}
}

輸出結果：

list求和：29,29,29
list求積：2112
list求和：11,11

案例二：求所有員工的工資之和和最高工資，

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
		personList.add(new Person("Owen", 9500, 25, "male", "New York"));
		personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

		// 求工資之和方式1：
		Optional<Integer> sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum);
		// 求工資之和方式2：
		Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(),
				(sum1, sum2) -> sum1 + sum2);
		// 求工資之和方式3：
		Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);

		// 求最高工資方式1：
		Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
				Integer::max);
		// 求最高工資方式2：
		Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
				(max1, max2) -> max1 > max2 ? max1 : max2);

		System.out.println("工資之和：" + sumSalary.get() + "," + sumSalary2 + "," + sumSalary3);
		System.out.println("最高工資：" + maxSalary + "," + maxSalary2);
	}
}

輸出結果：

工資之和：49300,49300,49300
最高工資：9500,9500

3.6 收集(collect)

collect，收集，可以說是內容最繁多、功能最豐富的部分了，從字面上去理解，就是把一個流收集起來，最終可以是收集成一個值也可以收集成一個新的集合，

collect主要依賴java.util.stream.Collectors類內置的靜態方法，

3.6.1 歸集(toList/toSet/toMap)

因為流不存盤資料，那么在流中的資料完成處理后，需要將流中的資料重新歸集到新的集合里，toList、toSet和toMap比較常用，另外還有toCollection、toConcurrentMap等復雜一些的用法，

下面用一個案例演示toList、toSet和toMap：

public class StreamTest {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
		List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
		Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());

		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
		
		Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
				.collect(Collectors.toMap(Person::getName, p -> p));
		System.out.println("toList:" + listNew);
		System.out.println("toSet:" + set);
		System.out.println("toMap:" + map);
	}
}

運行結果：

toList：[6, 4, 6, 6, 20]
toSet：[4, 20, 6]
toMap：{Tom=mutest.Person@5fd0d5ae, Anni=mutest.Person@2d98a335}

3.6.2 統計(count/averaging)

Collectors提供了一系列用于資料統計的靜態方法：

  • 計數：count
  • 平均值：averagingInt、averagingLong、averagingDouble
  • 最值：maxBy、minBy
  • 求和：summingInt、summingLong、summingDouble
  • 統計以上所有：summarizingInt、summarizingLong、summarizingDouble

案例：統計員工人數、平均工資、工資總額、最高工資，

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

		// 求總數
		Long count = personList.stream().collect(Collectors.counting());
		// 求平均工資
		Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
		// 求最高工資
		Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
		// 求工資之和
		Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
		// 一次性統計所有資訊
		DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

		System.out.println("員工總數：" + count);
		System.out.println("員工平均工資：" + average);
		System.out.println("員工工資總和：" + sum);
		System.out.println("員工工資所有統計：" + collect);
	}
}

運行結果：

員工總數：3
員工平均工資：7900.0
員工工資總和：23700
員工工資所有統計：DoubleSummaryStatistics{count=3, sum=23700.000000,min=7000.000000, average=7900.000000, max=8900.000000}

3.6.3 分組(partitioningBy/groupingBy)

  • 磁區：將stream按條件分為兩個Map，比如員工按薪資是否高于8000分為兩部分，
  • 分組：將集合分為多個Map，比如員工按性別分組，有單級分組和多級分組，

在這里插入圖片描述

案例：將員工按薪資是否高于8000分為兩部分；將員工按性別和地區分組

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, "male", "New York"));
		personList.add(new Person("Jack", 7000, "male", "Washington"));
		personList.add(new Person("Lily", 7800, "female", "Washington"));
		personList.add(new Person("Anni", 8200, "female", "New York"));
		personList.add(new Person("Owen", 9500, "male", "New York"));
		personList.add(new Person("Alisa", 7900, "female", "New York"));

		// 將員工按薪資是否高于8000分組
        Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
        // 將員工按性別分組
        Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        // 將員工先按性別分組，再按地區分組
        Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        System.out.println("員工按薪資是否大于8000分組情況：" + part);
        System.out.println("員工按性別分組情況：" + group);
        System.out.println("員工按性別、地區：" + group2);
	}
}

輸出結果：

員工按薪資是否大于8000分組情況：{false=[mutest.Person@2d98a335, mutest.Person@16b98e56, mutest.Person@7ef20235], true=[mutest.Person@27d6c5e0, mutest.Person@4f3f5b24, mutest.Person@15aeb7ab]}
員工按性別分組情況：{female=[mutest.Person@16b98e56, mutest.Person@4f3f5b24, mutest.Person@7ef20235], male=[mutest.Person@27d6c5e0, mutest.Person@2d98a335, mutest.Person@15aeb7ab]}
員工按性別、地區：{female={New York=[mutest.Person@4f3f5b24, mutest.Person@7ef20235], Washington=[mutest.Person@16b98e56]}, male={New York=[mutest.Person@27d6c5e0, mutest.Person@15aeb7ab], Washington=[mutest.Person@2d98a335]}}

3.6.4 接合(joining)

joining可以將stream中的元素用特定的連接符（沒有的話，則直接連接）連接成一個字串，

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

		String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
		System.out.println("所有員工的姓名：" + names);
		List<String> list = Arrays.asList("A", "B", "C");
		String string = list.stream().collect(Collectors.joining("-"));
		System.out.println("拼接后的字串：" + string);
	}
}

運行結果：

所有員工的姓名：Tom,Jack,Lily
拼接后的字串：A-B-C

3.6.5 歸約(reducing)

Collectors類提供的reducing方法，相比于stream本身的reduce方法，增加了對自定義歸約的支持，

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

		// 每個員工減去起征點后的薪資之和（這個例子并不嚴謹，但一時沒想到好的例子）
		Integer sum = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
		System.out.println("員工扣稅薪資總和：" + sum);

		// stream的reduce
		Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
		System.out.println("員工薪資總和：" + sum2.get());
	}
}

運行結果：

員工扣稅薪資總和：8700
員工薪資總和：23700

3.7 排序(sorted)

sorted，中間操作，有兩種排序：

  • sorted()：自然排序，流中元素需實作Comparable介面
  • sorted(Comparator com)：Comparator排序器自定義排序

案例：將員工按工資由高到低（工資一樣則按年齡由大到小）排序

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();

		personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
		personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
		personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 8800, 26, "male", "New York"));
		personList.add(new Person("Alisa", 9000, 26, "female", "New York"));

		// 按工資升序排序（自然排序）
		List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
				.collect(Collectors.toList());
		// 按工資倒序排序
		List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
				.map(Person::getName).collect(Collectors.toList());
		// 先按工資再按年齡升序排序
		List<String> newList3 = personList.stream()
				.sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName)
				.collect(Collectors.toList());
		// 先按工資再按年齡自定義排序（降序）
		List<String> newList4 = personList.stream().sorted((p1, p2) -> {
			if (p1.getSalary() == p2.getSalary()) {
				return p2.getAge() - p1.getAge();
			} else {
				return p2.getSalary() - p1.getSalary();
			}
		}).map(Person::getName).collect(Collectors.toList());

		System.out.println("按工資升序排序：" + newList);
		System.out.println("按工資降序排序：" + newList2);
		System.out.println("先按工資再按年齡升序排序：" + newList3);
		System.out.println("先按工資再按年齡自定義降序排序：" + newList4);
	}
}

運行結果：

按工資自然排序：[Lily, Tom, Sherry, Jack, Alisa]
按工資降序排序：[Sherry, Jack, Alisa,Tom, Lily]
先按工資再按年齡自然排序：[Sherry, Jack, Alisa, Tom, Lily]
先按工資再按年齡自定義降序排序：[Alisa, Jack, Sherry, Tom, Lily]

3.8 提取/組合

流也可以進行合并、去重、限制、跳過等操作，
在這里插入圖片描述

在這里插入圖片描述

在這里插入圖片描述

public class StreamTest {
	public static void main(String[] args) {
		String[] arr1 = { "a", "b", "c", "d" };
		String[] arr2 = { "d", "e", "f", "g" };

		Stream<String> stream1 = Stream.of(arr1);
		Stream<String> stream2 = Stream.of(arr2);
		// concat:合并兩個流 distinct：去重
		List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
		// limit：限制從流中獲得前n個資料
		List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
		// skip：跳過前n個資料
		List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());

		System.out.println("流合并：" + newList);
		System.out.println("limit：" + collect);
		System.out.println("skip：" + collect2);
	}
}

運行結果：

流合并：[a, b, c, d, e, f, g]
limit：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
skip：[3, 5, 7, 9, 11]

4 Stream原始碼解讀

這部分等有時間慢慢分解吧，

好，以上就是全部內容，能堅持看到這里，你一定很有識訓，那么動一動拿offer的小手，點個贊再走吧，

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/216244.html

標籤：其他

上一篇：漫畫：你們這些奇葩的代碼！

下一篇：python經典練習題之九九乘法表、列印菱形、列印對頂三角形、斐波拉契數列、素數...

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 面試突擊第一季，第二季，第三季

    第一季必考 https://www.bilibili.com/video/BV1FE411y79Y?from=search&seid=15921726601957489746 第二季分布式 https://www.bilibili.com/video/BV13f4y127ee/?spm_id_fro ......

    uj5u.com 2020-09-10 05:35:24 more
  • 第三單元作業總結

    1.前言 這應該是本學期最后一次寫作業總結了吧。總體來說，對作業的節奏也差不多掌握了，作業做起來的效率也更高了。雖然和之前的作業一樣，作業中都要用到新的知識，但是相比之前，更加懂得了如何利用工具以及資料。雖然之間卡過殼，但總體而言，這幾次作業還算完成的比較好。 2.作業程序總結 相比前兩個單元，此單 ......

    uj5u.com 2020-09-10 05:35:41 more
  • 北航OO（2020）第四單元博客作業暨課程總結博客

    北航OO（2020）第四單元博客作業暨課程總結博客 本單元作業的架構設計 在本單元中，由于UML圖具有比較清晰的樹形結構，因此我對其中需要進行查詢操作的元素進行了包裝，在樹的父節點中存盤所有孩子的參考。考慮到性能問題，我采用了快取機制，一次查詢后盡可能快取已經遍歷過的資訊，以減少遍歷次數。 本單元我 ......

    uj5u.com 2020-09-10 05:35:48 more
  • BUAA_OO_第四單元

    一、UML決議器設計 ? 先看下題目：第四單元實作一個基于JDK 8帶有效性檢查的UML(Unified Modeling Language)類圖，順序圖，狀態圖分析器 MyUmlInteraction，實際上我們要建立一個有向圖模型，UML中的物件（元素）可能與同級元素連接，也可與低級元素相連形成 ......

    uj5u.com 2020-09-10 05:35:54 more
  • 6.1邏輯運算子

    邏輯運算子 1. && 短路與 運算式1 && 運算式2 01.運算式1為true并且運算式2也為true 整體回傳為true 02.運算式1為false，將不會執行運算式2 整體回傳為false 03.只要有一個運算式為false 整體回傳為false 2. || 短路或 運算式1 || 運算式2 ......

    uj5u.com 2020-09-10 05:35:56 more
  • BUAAOO 第四單元 & 課程總結

    1. 第四單元：StarUml檔案決議 本單元采用了圖模型決議UML。 UML檔案可以抽象為圖、子圖、邊的邏輯結構。 在實作中，圖的節點包括類、介面、屬性，子圖包括狀態圖、順序圖等。 采用了三次遍歷UML元素的方法建圖，第一遍遍歷建點，第二、三次遍歷設定屬性、連邊，實作圖物件的初始化。這里借鑒了一些 ......

    uj5u.com 2020-09-10 05:36:06 more
  • 談談我對C# 多型的理解

    面向物件三要素：封裝、繼承、多型。 封裝和繼承，這兩個比較好理解，但要理解多型的話，可就稍微有點難度了。今天，我們就來講講多型的理解。 我們應該經常會看到面試題目：請談談對多型的理解。 其實呢，多型非常簡單，就一句話：呼叫同一種方法產生了不同的結果。 具體實作方式有三種。 一、多載 多載很簡單。 p ......

    uj5u.com 2020-09-10 05:36:09 more
  • Python 資料驅動工具：DDT

    背景 python 的unittest 沒有自帶資料驅動功能。 所以如果使用unittest，同時又想使用資料驅動，那么就可以使用DDT來完成。 DDT是 “Data-Driven Tests”的縮寫。 資料：http://ddt.readthedocs.io/en/latest/ 使用方法 dd. ......

    uj5u.com 2020-09-10 05:36:13 more
  • Python里面的xlrd模塊詳解

    那我就一下面積個問題對xlrd模塊進行學習一下： 1.什么是xlrd模塊？ 2.為什么使用xlrd模塊？ 3.怎樣使用xlrd模塊？ 1.什么是xlrd模塊？ ?python操作excel主要用到xlrd和xlwt這兩個庫，即xlrd是讀excel，xlwt是寫excel的庫。 今天就先來說一下xl ......

    uj5u.com 2020-09-10 05:36:28 more
  • 當我們創建HashMap時，底層到底做了什么？

    jdk1.7中的底層實作程序（底層基于陣列+鏈表） 在我們new HashMap()時，底層創建了默認長度為16的一維陣列Entry[ ] table。當我們呼叫map.put(key1,value1)方法向HashMap里添加資料的時候： 首先，呼叫key1所在類的hashCode()計算key1 ......

    uj5u.com 2020-09-10 05:36:38 more
最新发布
  • 【中介者設計模式詳解】C/Java/JS/Go/Python/TS不同語言實作

    * 中介者模式是一種行為型設計模式，它可以用來減少類之間的直接依賴關系，
    * 將物件之間的通信封裝到一個中介者物件中，從而使得各個物件之間的關系更加松散。
    * 在中介者模式中，物件之間不再直接相互互動，而是通過中介者來中轉訊息。 ......

    uj5u.com 2023-04-20 08:20:47 more
  • 露天煤礦現場調研和交流案例分享

    他們集團的資訊化公司及研究院在一個礦區正在做智能礦山的統一平臺的 試點，專案投資大概1億，包括了礦山的各方面的內容，顯示得我們這次交流有點多余。他們2年前開始做智能礦山的規劃，有很多煤礦行業專家的加持，他們的描述是非常完美，但是去年底應該上線的平臺，現在還沒有看到影子。他們確實有很多場景需求，但是被... ......

    uj5u.com 2023-04-20 08:20:25 more
  • 《社區人員管理》實戰案例設計&個人案例分享

    設計是一個讓人夢想成真程序，開始編碼、測驗、除錯之前進行需求分析和架構設計，才能保證關鍵方面都做正確 ......

    uj5u.com 2023-04-20 08:20:17 more
  • 軟體架構生態化-多角色交付的探索實踐

    作為一個技術架構師，不僅僅要緊跟行業技術趨勢，還要結合研發團隊現狀及痛點，探索新的交付方案。在日常中，你是否遇到如下問題 “ 業務需求排期長研發是瓶頸；非研發角色感受不到研發技改提效的變化；引入ISV 團隊又擔心質量和安全，培訓周期長“等等，基于此我們探索了一種新的技術體系及交付方案來解決如上問題。 ......

    uj5u.com 2023-04-20 08:20:10 more
  • 【中介者設計模式詳解】C/Java/JS/Go/Python/TS不同語言實作

    * 中介者模式是一種行為型設計模式，它可以用來減少類之間的直接依賴關系，
    * 將物件之間的通信封裝到一個中介者物件中，從而使得各個物件之間的關系更加松散。
    * 在中介者模式中，物件之間不再直接相互互動，而是通過中介者來中轉訊息。 ......

    uj5u.com 2023-04-20 08:19:44 more
  • 露天煤礦現場調研和交流案例分享

    他們集團的資訊化公司及研究院在一個礦區正在做智能礦山的統一平臺的 試點，專案投資大概1億，包括了礦山的各方面的內容，顯示得我們這次交流有點多余。他們2年前開始做智能礦山的規劃，有很多煤礦行業專家的加持，他們的描述是非常完美，但是去年底應該上線的平臺，現在還沒有看到影子。他們確實有很多場景需求，但是被... ......

    uj5u.com 2023-04-20 08:19:07 more
  • 《社區人員管理》實戰案例設計&個人案例分享

    設計是一個讓人夢想成真程序，開始編碼、測驗、除錯之前進行需求分析和架構設計，才能保證關鍵方面都做正確 ......

    uj5u.com 2023-04-20 08:18:57 more
  • 軟體架構生態化-多角色交付的探索實踐

    作為一個技術架構師，不僅僅要緊跟行業技術趨勢，還要結合研發團隊現狀及痛點，探索新的交付方案。在日常中，你是否遇到如下問題 “ 業務需求排期長研發是瓶頸；非研發角色感受不到研發技改提效的變化；引入ISV 團隊又擔心質量和安全，培訓周期長“等等，基于此我們探索了一種新的技術體系及交付方案來解決如上問題。 ......

    uj5u.com 2023-04-20 08:18:49 more
  • 05單件模式

    #經典的單件模式 public class Singleton { private static Singleton uniqueInstance; //一個靜態變數持有Singleton類的唯一實體。 // 其他有用的實體變數寫在這里 //構造器宣告為私有，只有Singleton可以實體化這個類! ......

    uj5u.com 2023-04-19 08:42:51 more
  • 【架構與設計】常見微服務分層架構的區別和落地實踐

    軟體工程的方方面面都遵循一個最基本的道理：沒有銀彈，架構分層模型更是如此，每一種都有各自優缺點，所以請根據不同的業務場景，并遵循簡單、可演進這兩個重要的架構原則選擇合適的架構分層模型即可。 ......

    uj5u.com 2023-04-19 08:42:41 more

Copyright © 2010-2020 有解無憂