Lambda表达式

1.知道什么是内部类----然后匿名内部类
2. 知道什么是函数式接口----只有函数式接口的匿名内部类才能写lambda
3. 知道什么是方法的引用.
4. stream
从此对集合的操作无比丝滑.效率还高
而且,真的是可读性会更高.而不是去看这个循环,那个循环

1、使用lambda表达式进行集合遍历

//不使用lambda表达式
List list = Arrays.asList("apple", "banana", "orange");
for (String fruit:list) {
    System.out.println(fruit);
}
//使用lambda表达式
list.forEach(System.out::println);
list.forEach(s -> {
            System.out.println(s);
        });

2、使用lambda表达式进行排序

//不使用lambda表达式
Collections.sort(list, new Comparator() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
//使用lambda表达式
Collections.sort(list,(o1,o2)-> o1.compareTo(o2));

3、使用lambda表达式进行过滤

//使用lambda表达式，取出所有以a开头的元素，并返回一个list集合
list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());

4、使用lambda表达式进行映射

//使用lambda表达式，获得list集合中所有元素的长度，map，类型管理
List list2 = list.stream().map(s -> s.length()).collect(Collectors.toList());

5、使用lambda表达式进行归约

进行累加

//使用lambda表达式
final List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
System.out.println(list.stream().reduce(0, (a, b) -> a + b));

6、使用lambda表达式进行分组

 //不使用lambda表达式  
 List list = Arrays.asList("apple","orange","banana");
        HashMap> groups = new HashMap<>();
        for (String s:list) {
            int length = s.length();
            if (!groups.containsKey(length)){
                groups.put(length,new ArrayList<>());
            }
            groups.get(length).add(s);
        }
 //使用lambda表达式 
final Map> collect = list.stream().collect(Collectors.groupingBy(String::length));

7、使用lambda表达式关于函数式接口的实现

//不使用lambda表达式 
final MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething(String s) {
                System.out.println(s);
            }
        };
        myInterface.doSomething("Hello world");
    }
 
    interface MyInterface {
        public void doSomething(String s);
    }
//使用lamcda表达式
 MyInterface myInterface = s -> System.out.println(s);
 myInterface.doSomething("Hello world");

8、使用lambda表达式进行线程的创建

//不使用lambda表达式 
 final Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        });
 thread.start();
//使用lambda表达式
final Thread thread = new Thread(() -> System.out.println("hello world"));
thread.start();

9、使用lambda表达式进行Optional的创建

//不使用lambda表达式
 String str = "hello world";
 if (str!=null){
      System.out.println(str.toUpperCase());
   }
//使用lambda表达式
Optional.ofNullable(str).map(String::toLowerCase).ifPresent(System.out::println);

10、使用lambda表达式进行流水线的操作

//使用lambda表达式 
  List list = Arrays.asList("apple","orange","banana");
          ArrayList list2 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("a")){
                list2.add(s.toLowerCase());
            }
        }
Collections.sort(list2);
//不使用lambda表达式
list.stream().filter(s -> s.startsWith("a")).map(String::toLowerCase).sorted().collect(Collectors.toList());