Java8-Lambda(1)

匿名內部類實現

匿名內部類仍然是一個類，只是不需要程序員顯示指定類名，編譯器會自動爲該類取名。因此如果有如下形式的代碼，編譯之後將會產生兩個class文件

public class Main {
    public static void main(String[] args) {
        new Thread(new Runnable(){
            @Override
            public void run(){
                System.out.println("hello");
            }
        }).start();
    }
}

Lambda表達式實現

Lambda表達式通過invokedynamic指令實現，書寫Lambda表達式不會產生新的類。如果有如下代碼，編譯之後只有一個class文件

既然Lambda表達式不是內部類的簡寫，那麼Lambda內部的this引用也就跟內部類對象沒什麼關係了。在Lambda表達式中this的意義跟在表達式外部完全一樣

public class Main {
    public static void main(String[] args) {
        new Thread(
                () -> System.out.println("hello")
            ).start();
    }
}

集合常用方法

// 刪除長度大於3的元素
list.removeIf(str -> str.length()>3); 

//所有長度大於3的元素轉換成大寫，其餘元素不變
list.replaceAll(str -> {        
    if(str.length()>3)
        return str.toUpperCase();
    return str;
});

//排序
list.sort((str1, str2) -> str1.length()-str2.length());

//Map循環
map.forEach((k, v) -> System.out.println(k + "=" + v));

//有則返回，無則返回默認"NoValue"
map.getOrDefault(4, "NoValue");

//如果"key"不存在，則put "value"
map.putIfAbsent("key","value")

//替換所有的value大寫
map.replaceAll((k, v) -> v.toUpperCase());

//循環
Stream.of("I", "love", "you", "too").forEach(str -> System.out.println(str));

//過濾
Stream.of("I", "love", "you", "too").filter(str -> str.length()==3).forEach(str -> System.out.println(str));

//去重
 Stream.of("I", "love", "you", "too", "too").distinct()
    .forEach(str -> System.out.println(str));

//排序   
Stream.of("I", "love", "you", "too").sorted((str1, str2) -> str1.length()-str2.length()).forEach(str -> System.out.println(str));

//對每個元素按照某種操作進行轉換，轉換前後Stream中元素的個數不會改變，但元素的類型取決於轉換之後的類型。
Stream.of("I", "love", "you", "too").map(str -> str.toUpperCase()).forEach(str -> System.out.println(str));

reduce（）

reduce操作可以實現從一組元素中生成一個值，sum()、max()、min()、count()等都是reduce操作，將他們單獨設爲函數只是因爲常用

//返回最大的值
Optional<String> longest = stream.reduce((s1, s2) -> s1.length()>=s2.length() ? s1 : s2);
//Optional<String> longest = stream.max((s1, s2) -> s1.length()-s2.length());

//累加
Integer lengthSum = stream.reduce(0,　// 初始值　// (1)
        (sum, str) -> sum+str.length(), // 累加器 // (2)
        (a, b) -> a+b);　// 部分和拼接器，並行執行時纔會用到 // (3)
// int lengthSum = stream.mapToInt(str -> str.length()).sum();

//轉list
List<String> list = stream.collect(Collectors.toList());
//轉set
Set<String> set = stream.collect(Collectors.toSet());
//轉map
//Function.identity()等價於t->t
Map<String, Integer> map = stream.collect(Collectors.toMap(Function.identity(), String::length)); // (3)

// 使用toCollection()指定規約容器的類型
ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));// (3)
HashSet<String> hashSet = stream.collect(Collectors.toCollection(HashSet::new));// (4)

// 使用toMap()統計學生GPA
Map<Student, Double> studentToGPA =students.stream().collect(Collectors.toMap(Functions.identity(),student -> computeGPA(student)));

//把集合分爲兩部分，滿足條件，或不滿足
Map<Boolean, List<Student>> passingFailing = students.stream()
         .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

//按照某個屬性對數據進行分組，屬性相同的元素會被對應到Map的同一個key上
Map<Department, List<Employee>> byDept = employees.stream()
           .collect(Collectors.groupingBy(Employee::getDepartment));

// 先分組，然後統計
Map<Department, Integer> totalByDept = employees.stream()
           .collect(Collectors.groupingBy(Employee::getDepartment,                                           Collectors.counting()));// 下游收集器

// 按照部門對員工分佈組，並只保留員工的名字
Map<Department, List<String>> byDept = employees.stream()                .collect(Collectors.groupingBy(Employee::getDepartment,
                        Collectors.mapping(Employee::getName,
                                Collectors.toList())));

// 使用Collectors.joining()拼接字符串
Stream<String> stream = Stream.of("I", "love", "you");
String joined = stream.collect(Collectors.joining());// "Iloveyou"
String joined = stream.collect(Collectors.joining(","));// "I,love,you"
String joined = stream.collect(Collectors.joining(",", "{", "}"));// "{I,love,you}"