溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇文章為大家展示了Java8中Stream API如何使用，內容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。
首先創建一個對象
public class Employee {
private int id;
private String name;
private int age;
private double salary;
private Status status;
public enum Status {
FREE, BUSY, VOCATION;
}
public Employee() {
}
public Employee(String name) {
this.name = name;
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public Employee(int id, String name, int age, double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public Employee(int id, String name, int age, double salary, Status status) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
this.status = status;
}
//省略get，set等。。。
}
隨便初始化一些數據
List<Employee> empList = Arrays.asList(new Employee(102, "李四", 59, 6666.66, Status.BUSY),
new Employee(101, "張三", 18, 9999.99, Status.FREE), new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
new Employee(104, "趙六", 8, 7777.77, Status.BUSY), new Employee(104, "趙六", 8, 7777.77, Status.FREE),
new Employee(104, "趙六", 8, 7777.77, Status.FREE), new Employee(105, "田七", 38, 5555.55, Status.BUSY));
中間操作
根據條件篩選 filter
/**
* 接收Lambda, 從流中排除某些元素。
*/
@Test
void testFilter() {
empList.stream().filter((e) -> {
return e.getSalary() >= 5000;
}).forEach(System.out::println);
}
跳過流的前n個元素 skip
/**
* 跳過元素，返回一個扔掉了前n個元素的流。
*/
@Test
void testSkip() {
empList.stream().filter((e) -> e.getSalary() >= 5000).skip(2).forEach(System.out::println);
}
去除重復元素 distinct
/**
* 篩選，通過流所生成元素的 hashCode() 和 equals() 去除重復元素
*/
@Test
void testDistinct() {
empList.stream().distinct().forEach(System.out::println);
}
截取流的前n個元素 limit
/**
* 截斷流，使其元素不超過給定數量。
*/
@Test
void testLimit() {
empList.stream().filter((e) -> {
return e.getSalary() >= 5000;
}).limit(3).forEach(System.out::println);
}
映射 map
/**
* 接收一個函數作為參數，該函數會被應用到每個元素上，并將其映射成一個新的元素
*/
@Test
void testMap() {
empList.stream().map(e -> e.getName()).forEach(System.out::println);
empList.stream().map(e -> {
empList.forEach(i -> {
i.setName(i.getName() + "111");
});
return e;
}).collect(Collectors.toList());
}
自然排序 sorted
/**
* 產生一個新流，其中按自然順序排序
*/
@Test
void testSorted() {
empList.stream().map(Employee::getName).sorted().forEach(System.out::println);
}
自定義排序 sorted(Comparator comp)
/**
* 產生一個新流，其中按自然順序排序
*/
@Test
void testSortedComparator() {
empList.stream().sorted((x, y) -> {
if (x.getAge() == y.getAge()) {
return x.getName().compareTo(y.getName());
} else {
return Integer.compare(x.getAge(), y.getAge());
}
}).forEach(System.out::println);
}
是否匹配任一元素 anyMatch
/**
* 檢查是否至少匹配一個元素
*/
@Test
void testAnyMatch() {
boolean b = empList.stream().anyMatch((e) -> e.getStatus().equals(Status.BUSY));
System.out.println("boolean is : " + b);
}
是否匹配所有元素 allMatch
/**
* 檢查是否匹配所有元素
*/
@Test
void testAllMatch() {
boolean b = empList.stream().allMatch((e) -> e.getStatus().equals(Status.BUSY));
System.out.println("boolean is : " + b);
}
/**
* 檢查是否沒有匹配的元素
*/
@Test
void testNoneMatch() {
boolean b = empList.stream().noneMatch((e) -> e.getStatus().equals(Status.BUSY));
System.out.println("boolean is : " + b);
}
返回第一個元素 findFirst
/**
* 返回第一個元素
*/
@Test
void testFindFirst() {
Optional<Employee> op = empList.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
.findFirst();
if (op.isPresent()) {
System.out.println("first employee name is : " + op.get().getName().toString());
}
}
/**
* 返回當前流中的任意元素
*/
@Test
void testFindAny() {
Optional<Employee> op = empList.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
.findAny();
if (op.isPresent()) {
System.out.println("any employee name is : " + op.get().getName().toString());
}
}
返回流的總數 count
/**
* 返回流中元素的總個數
*/
@Test
void testCount() {
long count = empList.stream().filter((e) -> e.getStatus().equals(Status.FREE)).count();
System.out.println("Count is : " + count);
}
返回流中的最大值 max
/**
* 返回流中最大值
*/
@Test
void testMax() {
Optional<Double> op = empList.stream().map(Employee::getSalary).max(Double::compare);
System.out.println(op.get());
}
返回流中的最小值 min
/**
* 返回流中最小值
*/
@Test
void testMin() {
Optional<Employee> op2 = empList.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println(op2.get());
}
歸約 reduce
歸約是將集合中的所有元素經過指定運算，折疊成一個元素輸出
/**
* 可以將流中元素反復結合起來，得到一個值。返回T
*/
@Test
void testReduce() {
Optional<Double> op = empList.stream().map(Employee::getSalary).reduce(Double::sum);
System.out.println(op.get());
}
/**
* 可以將流中元素反復結合起來，得到一個值，返回Optional< T>
*/
@Test
void testReduce1() {
Optional<Integer> sum = empList.stream().map(Employee::getName).flatMap(Java8Stream::filterCharacter)
.map((ch) -> {
if (ch.equals('六'))
return 1;
else
return 0;
}).reduce(Integer::sum);
System.out.println(sum.get());
}
將元素收集到 list 里 Collectors.toList()
/**
* 把流中的元素收集到list里。
*/
@Test
void testCollectorsToList() {
List<String> list = empList.stream().map(Employee::getName).collect(Collectors.toList());
list.forEach(System.out::println);
}
將元素收集到 set 里 Collectors.toSet()
/**
* 把流中的元素收集到set里。
*/
@Test
void testCollectorsToSet() {
Set<String> list = empList.stream().map(Employee::getName).collect(Collectors.toSet());
list.forEach(System.out::println);
}
把流中的元素收集到新創建的集合里 Collectors.toCollection(HashSet::new)
/**
* 把流中的元素收集到新創建的集合里。
*/
@Test
void testCollectorsToCollection() {
HashSet<String> hs = empList.stream().map(Employee::getName).collect(Collectors.toCollection(HashSet::new));
hs.forEach(System.out::println);
}
根據比較器選擇最大值 Collectors.maxBy()
/**
* 根據比較器選擇最大值。
*/
@Test
void testCollectorsMaxBy() {
Optional<Double> max = empList.stream().map(Employee::getSalary).collect(Collectors.maxBy(Double::compare));
System.out.println(max.get());
}
根據比較器選擇最小值 Collectors.minBy()
/**
* 根據比較器選擇最小值。
*/
@Test
void testCollectorsMinBy() {
Optional<Double> max = empList.stream().map(Employee::getSalary).collect(Collectors.minBy(Double::compare));
System.out.println(max.get());
}
對流中元素的某個字段求和 Collectors.summingDouble()
/**
* 對流中元素的整數屬性求和。
*/
@Test
void testCollectorsSummingDouble() {
Double sum = empList.stream().collect(Collectors.summingDouble(Employee::getSalary));
System.out.println(sum);
}
對流中元素的某個字段求平均值 Collectors.averagingDouble()
/**
* 計算流中元素Integer屬性的平均值。
*/
@Test
void testCollectorsAveragingDouble() {
Double avg = empList.stream().collect(Collectors.averagingDouble(Employee::getSalary));
System.out.println(avg);
}
分組，類似sql的 group by Collectors.groupingBy
/**
* 分組
*/
@Test
void testCollectorsGroupingBy() {
Map<Status, List<Employee>> map = empList.stream().collect(Collectors.groupingBy(Employee::getStatus));
System.out.println(map);
}
/**
* 多級分組
*/
@Test
void testCollectorsGroupingBy1() {
Map<Status, Map<String, List<Employee>>> map = empList.stream()
.collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
if (e.getAge() >= 60)
return "老年";
else if (e.getAge() >= 35)
return "中年";
else
return "成年";
})));
System.out.println(map);
}
字符串拼接 Collectors.joining()
/**
* 字符串拼接
*/
@Test
void testCollectorsJoining() {
String str = empList.stream().map(Employee::getName).collect(Collectors.joining(",", "----", "----"));
System.out.println(str);
}
public static Stream<Character> filterCharacter(String str) {
List<Character> list = new ArrayList<>();
for (Character ch : str.toCharArray()) {
list.add(ch);
}
return list.stream();
}
上述內容就是Java8中Stream API如何使用，你們學到知識或技能了嗎？如果還想學到更多技能或者豐富自己的知識儲備，歡迎關注億速云行業資訊頻道。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
