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}"