2020/12/08
目錄
Lambda表達式
函數式編程
- 函數當成基本運算單元
- 函數可以當參數
- 函數可以接收參數
- 函數可以返回參數
Lambda表達式
- 簡化語法
- JDK >= 1.8
- 只使用於函數式接口
函數式接口
-
接口只有一個抽象方法
-
不包括object那些public方法
interface並沒有繼承Object類，它只是隱式的聲明了Object類里的所有的public方法。並且在接口的實現中可以不用override這些方法，因為調用這些隱式方法的時候默認會直接調用到Object類里的方法。Object類里的protected方法（finalize）不會被隱式聲明。
所以下面2個接口都是函數式接口：
將匿名類簡化成Lambda表達式
String[] words = "Improving code with lambda expressions in java".split(" ");
Arrays.sort(words, new Comparator<String>() {
@Override
public int compare(String str1, String str2) {
// 全部小寫后再比較
return str1.toLowerCase().compareTo(str2.toLowerCase());
}
});
簡化：
Arrays.sort(words, (s1, s2) -> {
return s1.toLowerCase().compareTo(s2.toLowerCase());
});
再簡化：
Arrays.sort(words, (s1, s2) -> s1.toLowerCase().compareTo(s2.toLowerCase()));
System.out.println(Arrays.toString(words));
s1，s2的類型編譯器會自動判斷
方法引用
非構造方法的引用
定義一個Student類用於測試
public class Student {
private String name;
private int score;
public Student() {
}
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public static int compareStudentByScore(Student student1, Student student2) {
return student1.getScore() - student2.getScore();
}
public static int compareStudentByName(Student student1, Student student2) {
return student1.getName().compareToIgnoreCase(student2.getName());
}
使用之前提到的Lambda表達式進行排序
Student student1 = new Student("zhangsan", 60);
Student student2 = new Student("lisi", 70);
Student student3 = new Student("wangwu", 80);
Student student4 = new Student("zhaoliu", 90);
List<Student> students = Arrays.asList(student1, student2, student3, student4);
students.sort((o1, o2) -> o1.getScore() - o2.getScore());
students.forEach(student -> System.out.println(student.getScore()));
使用類名::靜態方法進行排序
先理解方法簽名的概念
如果兩個方法參數類型和返回值類型相同，那么這兩個方法簽名相同
例如上圖的ignoreCase和compare方法簽名相同
所以之前傳入的Lambda表達式，或者說是函數式接口，可以使用與該接口中那個抽象方法簽名相同的方法替換，程序會自動將傳入的方法轉換成對應的函數式接口
public static int compareStudentByScore(Student student1, Student student2) {
return student1.getScore() - student2.getScore();
}
students.sort(Student::compareStudentByScore);
使用實例::實例方法進行排序
由於簽名相同的判斷條件不包括static，因此也可以使用類名::實例方法來替換原來的函數式接口（前提也是簽名相同）
創建一個Student的排序器
public class StudentComparator {
public int compareStudentByScore(Student student1, Student student2) {
return student2.getScore() - student1.getScore();
}
}
將方法傳入
StudentComparator comparator = new StudentComparator();
students.sort(comparator::compareStudentByScore);
使用類名::實例方法進行排序
先看一下之前的靜態方法
public static int compareStudentByScore(Student student1, Student student2) {
return student1.getScore() - student2.getScore();
}
雖然這個方法在語法上沒有任何問題，可以作為一個工具正常使用，但是有沒有覺得其在設計上是不合適的或者是錯誤的。這樣的方法定義放在任何一個類中都可以正常使用，而不只是從屬於Student這個類，那如果要定義一個只能從屬於Student類的比較方法下面這個實例方法更合適一些
public int compareByScore(Student student) {
return this.getScore() - student.getScore();
}
students.sort(Student::compareByScore);
那么該方法的簽名和Comparator接口中的compare方法不同，為何可以替換？
因為類中每個方法都會隱式傳入this參數，所以實際調用的是
public int compareByScore(Student this, Student student) {
return this.getScore() - student.getScore();
}
這樣簽名就相同了
構造方法的引用
使用下方接口進行測試
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
使用Lambda表達式
Supplier<Student> supplier = () -> new Student();
Student student = supplier.get();
是用構造方法的引用（前提要有無參構造）
Supplier<Student> supplier = Student::new;
Student student = supplier.get();
stream
- 可以“存儲”有限個或無限個元素
- 一個stream可以轉換成另一個stream
- 參數都是Lambda表達式
- 不會存儲元素
- 惰性計算：在需要獲取結果時才進行計算
創建stream
// 1. 通過Collections系列集合提供的stream() 或 parallelStream()
List<String> list = new ArrayList<>();
Stream<String> stream01 = list.stream();
// 2. 通過Arrays中的靜態方法stream()獲取數組流
String[] strList = new String[10];
Stream<String> stream02 = Arrays.stream(strList);
// 3. 通過Stream類中的靜態方法
Stream<String> stream03 = Stream.of(strList);
// 4. 迭代
Stream<Integer> stream04 = Stream.iterate(0, (x) -> (x + 1));
stream04.limit(10).forEach(System.out::println);
// 5. 生成
Stream<Double> stream05 = Stream.generate(() -> Math.random());
stream05.limit(10).forEach(System.out::println);
map
-
將一個stream映射成另一個stream
-
map的參數是Function接口
<R> Stream<R> map(Function<? super T, ? extends R> mapper);Function接口
@FunctionalInterface public interface Function<T, R> { // 將T類型轉換為R類型 R apply(T t); }
示例一
String[] words = "Stream API supports functional-style operations".split(" ");
Stream<String> stream = Arrays.stream(words);
stream.map(String::toUpperCase).forEach(System.out::println);
示例二（將String轉為Student）
String[] students = {"小明, 1", "張三, 2", "李四, 3", "王五, 4", "小劉, 5", "小王, 6"};
Stream<String> stream = Arrays.stream(students);
Stream<Student> studentStream = stream.map(s -> {
int index = s.indexOf(',');
String name = s.substring(0, index);
int id = Integer.parseInt(s.substring(index + 2));
return new Student(id, name);
});
studentStream.forEach(System.out::println);
filter
-
用來過濾stream
-
傳入參數為Predicate接口
Stream<T> filter(Predicate<? super T> predicate);Predicate接口
@FunctionalInterface public interface Predicate<T> { // 傳入參數T，判斷是否滿足條件 boolean test(T t); }
示例一
class NaturalSupplier implements Supplier<Long> {
private long x;
@Override
public Long get() {
x = x + 1;
return x;
}
}
Stream<Long> natural = Stream.generate(new NaturalSupplier());
// 奇數
Stream<Long> odd = natural.filter(n -> n % 2 == 1);
odd.limit(15).forEach(System.out::println);
示例二
String[] words = {"Java", " Python ", null, "\n\n", " Ruby "};
// Java中的trim()函數去除了字符串前后兩端的所有包括空格、換行、回車
Arrays.stream(words).
filter(s -> s != null && !s.trim().isEmpty()).
map(String::trim).
forEach(System.out::println);
reduce
-
用來聚合stream
-
傳入參數為BinaryOperator接口
Optional<T> reduce(BinaryOperator<T> accumulator);BinaryOperator接口
@FunctionalInterface public interface BinaryOperator<T> extends BiFunction<T,T,T> { // 兩個輸入，一個輸出，並且類型相同 T apply(T t, T u); }
示例一
Optional<Integer> reduce = Stream.of(1, 2, 6, 8, 9).reduce((acc, n) -> acc + n);
System.out.println(reduce.get());
示例二
Integer reduce = Stream.of(1, 2, 6, 8, 9).reduce(1000, (acc, n) -> acc * n);
System.out.println(reduce);
示例三
String[] students = {"小明, 1", "張三, 2", "李四, 3", "王五, 4", "小劉, 5", "小王, 6"};
Stream<String> stream = Arrays.stream(students);
Optional<String> reduce = stream.reduce((acc, s) -> acc + "~" + s);
System.out.println(reduce.get());
其它方法
排序
Stream<T> sorted() //按元素默認大小排序（必須實現comparable接口)
Stream<T> sorted(Comparator<? super T> cp) //按指定comparator比較的結果排序
去重
stream<T> distinct() // 返回去除重復元素的新Stream
// [1, 2, 5, 2, 6, 5, 7] => [ 1, 2, 5, 6, 7]
截取
Stream<T> limit(long) // 截取當前Stream的最多前N個元素
stream<T> skip(long) // 跳過當前stream的前N個元素
合並
合並stream
stream<Integer> s = Stream.concat (
stream.of(1, 2, 3),
stream.of (4, 5, 6)
};
// 1, 2, 3, 4, 5, 6
合並集合成一個stream
Stream<List<Integer>> s = Stream.of(
Arrays. asList (1, 2, 3),
Arrays.asList(4, 5, 6),
Arrays.asList (7, 8, 9));
// 轉換為stream<Integer>
stream<Integer> i = s.flatMap(list -> list.stream()) ;
flatMap把元素映射成stream，然后合並成一個stream
stream並行處理
stream的操作是單線程的，可以手動設置成可多線程處理
stream<String> s = ...
string[] result = s.parallel() // 變成一個可以並行處理的stream
.sorted() // 可以進行並行排序
.toArray(String[]::new);
聚合方法
Optional<T> reduce(BinaryOperator<T> bo)
long count() // 元素個數
T max(Comparator<? super T> cp) // 找最大元素
T min(Comparator<? super T> cp) // 找最小元素
// 針對IntStream / LongStream / DoubleStream
sum() // 求和
average() // 求平均數
sum和average只適用於3個基本數據類型
任意與存在
boolean allMatch(Predicate<? super T>) // 所有元素均滿足測試條件?
boolean anyMatch(Predicate<? super T>) // 至少有一個元素滿足測試條件?
循環處理每個元素
可以傳入side-effects（副作用）
void forEach(Consumer<? super T> action)
// 示例
Stream<String> s = ...
s.forEach(str -> {
System.out.println("Hello, " + str);
});
把stream轉換為其它類型
object[] toArray() // 轉換為object數組
A[] toArray(IntFunction<A[]>) // 轉換為A[]數組
<R, A> R collect(Collector<? super T，A，R> collector) // 轉換為List/Set等集合類型
示例
Stream<String> s = ...
String[] arr = s.toArray(string[]::new); // 轉換為string數組
List<String> list = s.collect(Collectors.toList()); // 轉換為List