簡介
java8也出來好久了，接口默認方法，lambda表達式，函數式接口，Date API等特性還是有必要去了解一下。比如在項目中經常用到集合，遍歷集合可以試下lambda表達式，經常還要對集合進行過濾和排序，Stream就派上用場了。用習慣了，不得不說真的很好用。
Stream作為java8的新特性，基於lambda表達式，是對集合對象功能的增強，它專注於對集合對象進行各種高效、便利的聚合操作或者大批量的數據操作，提高了編程效率和代碼可讀性。
Stream的原理：將要處理的元素看做一種流，流在管道中傳輸，並且可以在管道的節點上處理，包括過濾篩選、去重、排序、聚合等。元素流在管道中經過中間操作的處理，最後由最終操作得到前面處理的結果。
集合有兩種方式生成流：
- stream() − 為集合創建串行流
- parallelStream() - 為集合創建並行流
上圖中是Stream類的類結構圖，裡面包含了大部分的中間和終止操作。
中間操作主要有以下方法（此類型方法返回的都是Stream）：map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
終止操作主要有以下方法：forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
舉例說明
首先為了說明Stream對對象集合的操作，新建一個Student類（學生類）,覆寫了equals()和hashCode()方法
<code>public class Student {
private Long id;
private String name;
private int age;
private String address;
public Student() {}
public Student(Long id, String name, int age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\\'' +
", age=" + age +
", address='" + address + '\\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(id, student.id) &&
Objects.equals(name, student.name) &&
Objects.equals(address, student.address);
}
@Override
public int hashCode() {
return Objects.hash(id, name, age, address);
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}/<code>filter（篩選）
<code>public static void main(String [] args) {
Student s1 = new Student(1L, "肖戰", 15, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "楊紫", 17, "北京");
Student s4 = new Student(4L, "李現", 17, "浙江");
List<student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
List<student> streamStudents = testFilter(students);
streamStudents.forEach(System.out::println);
}
/**
* 集合的篩選
* @param students
* @return
*/
private static List<student> testFilter(List<student> students) {
//篩選年齡大於15歲的學生
// return students.stream().filter(s -> s.getAge()>15).collect(Collectors.toList());
//篩選住在浙江省的學生
return students.stream().filter(s ->"浙江".equals(s.getAddress())).collect(Collectors.toList());
}/<student>/<student>/<student>/<student>/<code>運行結果：
這裡我們創建了四個學生，經過filter的篩選，篩選出地址是浙江的學生集合。
map(轉換)
<code> public static void main(String [] args) {
Student s1 = new Student(1L, "肖戰", 15, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "楊紫", 17, "北京");
Student s4 = new Student(4L, "李現", 17, "浙江");
List<student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
testMap(students);
}
/**
* 集合轉換
* @param students
* @return
*/
private static void testMap(List<student> students) {
//在地址前面加上部分信息，只獲取地址輸出
List<string> addresses = students.stream().map(s ->"住址:"+s.getAddress()).collect(Collectors.toList());
addresses.forEach(a ->System.out.println(a));
}/<string>/<student>/<student>/<code>運行結果
map就是將對應的元素按照給定的方法進行轉換。
distinct(去重)
<code> public static void main(String [] args) {
testDistinct1();
}
/**
* 集合去重（基本類型）
*/
private static void testDistinct1() {
//簡單字符串的去重
List<string> list = Arrays.asList("111","222","333","111","222");
list.stream().distinct().forEach(System.out::println);
}/<string>/<code>運行結果：
<code>public static void main(String [] args) {
testDistinct2();
}
/**
* 集合去重（引用對象）
*/
private static void testDistinct2() {
//引用對象的去重，引用對象要實現hashCode和equal方法，否則去重無效
Student s1 = new Student(1L, "肖戰", 15, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "楊紫", 17, "北京");
Student s4 = new Student(4L, "李現", 17, "浙江");
Student s5 = new Student(1L, "肖戰", 15, "浙江");
List<student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
students.add(s5);
students.stream().distinct().forEach(System.out::println);
}/<student>/<code>運行結果：
可以看出，兩個重複的“肖戰”同學進行了去重，這不僅因為使用了distinct()方法，而且因為Student對象重寫了equals和hashCode()方法，否則去重是無效的。
sorted(排序)
<code> public static void main(String [] args) {
testSort1();
}
/**
* 集合排序（默認排序）
*/
private static void testSort1() {
List<string> list = Arrays.asList("333","222","111");
list.stream().sorted().forEach(System.out::println);
}/<string>/<code>運行結果：
<code> public static void main(String [] args) {
testSort2();
}
/**
* 集合排序（指定排序規則）
*/
private static void testSort2() {
Student s1 = new Student(1L, "肖戰", 15, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "楊紫", 17, "北京");
Student s4 = new Student(4L, "李現", 17, "浙江");
List<student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
students.stream()
.sorted((stu1,stu2) ->Long.compare(stu2.getId(), stu1.getId()))
.sorted((stu1,stu2) -> Integer.compare(stu2.getAge(),stu1.getAge()))
.forEach(System.out::println);
}/<student>/<code>運行結果：
上面指定排序規則，先按照學生的id進行降序排序，再按照年齡進行降序排序
limit（限制返回個數）
<code> public static void main(String [] args) {
testLimit();
}
/**
* 集合limit，返回前幾個元素
*/
private static void testLimit() {
List<string> list = Arrays.asList("333","222","111");
list.stream().limit(2).forEach(System.out::println);
}/<string>/<code>運行結果：
skip(刪除元素)
<code> public static void main(String [] args) {
testSkip();
}
/**
* 集合skip，刪除前n個元素
*/
private static void testSkip() {
List<string> list = Arrays.asList("333","222","111");
list.stream().skip(2).forEach(System.out::println);
}/<string>/<code>運行結果：
reduce(聚合)
<code> public static void main(String [] args) {
testReduce();
}
/**
* 集合reduce,將集合中每個元素聚合成一條數據
*/
private static void testReduce() {
List<string> list = Arrays.asList("歡","迎","你");
String appendStr = list.stream().reduce("北京",(a,b) -> a+b);
System.out.println(appendStr);
}/<string>/<code>運行結果：
min(求最小值)
<code> public static void main(String [] args) {
testMin();
}
/**
* 求集合中元素的最小值
*/
private static void testMin() {
Student s1 = new Student(1L, "肖戰", 14, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "楊紫", 17, "北京");
Student s4 = new Student(4L, "李現", 17, "浙江");
List<student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
Student minS = students.stream().min((stu1,stu2) ->Integer.compare(stu1.getAge(),stu2.getAge())).get();
System.out.println(minS.toString());
}/<student>/<code>運行結果：
上面是求所有學生中年齡最小的一個，max同理，求最大值。
anyMatch/allMatch/noneMatch（匹配）
<code> public static void main(String [] args) {
testMatch();
}
private static void testMatch() {
Student s1 = new Student(1L, "肖戰", 15, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "楊紫", 17, "北京");
Student s4 = new Student(4L, "李現", 17, "浙江");
List<student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
Boolean anyMatch = students.stream().anyMatch(s ->"湖北".equals(s.getAddress()));
if (anyMatch) {
System.out.println("有湖北人");
}
Boolean allMatch = students.stream().allMatch(s -> s.getAge()>=15);
if (allMatch) {
System.out.println("所有學生都滿15週歲");
}
Boolean noneMatch = students.stream().noneMatch(s -> "楊洋".equals(s.getName()));
if (noneMatch) {
System.out.println("沒有叫楊洋的同學");
}
}/<student>/<code>運行結果：
anyMatch：Stream 中任意一個元素符合傳入的 predicate，返回 true
allMatch：Stream 中全部元素符合傳入的 predicate，返回 true
noneMatch：Stream 中沒有一個元素符合傳入的 predicate，返回 true
總結
上面介紹了Stream常用的一些方法，雖然對集合的遍歷和操作可以用以前常規的方式，但是當業務邏輯複雜的時候，你會發現代碼量很多，可讀性很差，明明一行代碼解決的事情，你卻寫了好幾行。試試lambda表達式，試試Stream，你會有不一樣的體驗。
看完覺得不錯可以關注一下小編，後續還會持續更新幹貨文章！！
分享到:
閱讀更多 Java高級架構師 的文章
