方法引用

静态方法引用：ClassName::methodName
实例上的实例方法引用：instanceReference::methodName
超类上的实例方法引用：super::methodName
类型上的实例方法引用：ClassName::methodName
构造方法引用：Class::new

数组构造方法引用：TypeName[]::new

Lambda表达式

排序替换

1.之前实现匿名内部类可以用Lambda表达式替换

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
  @Override
  public int compare(String a, String b) {
      return b.compareTo(a);
  }
});

2.替换后的结果

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});

3.省略return写法

Collections.sort(names,(String a,String b)->b.compareTo(a));

4.遍历方法（lambda表达式）

String[] atp = {"Rafael Nadal", "Novak Djokovic",
            "Stanislas Wawrinka",
            "David Ferrer","Roger Federer",
            "Andy Murray","Tomas Berdych",
            "Juan Martin Del Potro"};
List<String> players =  Arrays.asList(atp);
players.forEach(player-> System.out.println(player));

实体类的集合操作

自定义List塞数据构建集合

System.out.println("下面是月薪超过 $1,400 的PHP程序员:");
phpProgrammers.stream()
            .filter(person -> (person.getSalary() > 1400))
            .forEach(person -> System.out.println(String.format("%s %s;", person.getFirstName(), person.getLastName())));

自定义过滤器

Predicate<Person> ageFilter = person -> (person.getAge() > 25);
Predicate<Person> salaryFilter = person -> (person.getSalary() > 1400);
phpProgrammers
      .stream()
      .filter(ageFilter)
      .filter(salaryFilter)
      .forEach(person -> System.out.println(String.format("%s %s ;", person.getFirstName(), person.getLastName())));

排序选择构建集合
List collect = javaProgrammers .stream() .sorted((p, p2) -> (p.getFirstName().compareTo(p2.getLastName()))) .limit(5) .collect(toList());
collect.forEach((p) -> System.out.printf(“%s %s; %n”, p.getFirstName(), p.getLastName()));
取最大值最小值 ``` System.out.println(“工资最低的 Java programmer:”);
Person pers = javaProgrammers
```
    .stream()  
    .min((p1, p2) -> (p1.getSalary() - p2.getSalary()))  
    .get()  
```

System.out.printf(“Name: %s %s; Salary: $%,d.”, pers.getFirstName(), pers.getLastName(), pers.getSalary())

System.out.println(“工资最高的 Java programmer:”);
Person person = javaProgrammers
.stream()
.max((p, p2) -> (p.getSalary() - p2.getSalary()))
.get()

System.out.printf(“Name: %s %s; Salary: $%,d.”, person.getFirstName(), person.getLastName(), person.getSalary())


- 拼接集合的转换

System.out.println(“将 PHP programmers 的 first name 拼接成字符串:”);
String phpDevelopers = phpProgrammers
.stream()
.map(Person::getFirstName)
.collect(joining(“ ; “)); // 在进一步的操作中可以作为标记(token)

System.out.println(“将 Java programmers 的 first name 存放到 Set:”);
Set javaDevFirstName = javaProgrammers
.stream()
.map(Person::getFirstName)
.collect(toSet());

System.out.println(“将 Java programmers 的 first name 存放到 TreeSet:”);
TreeSet javaDevLastName = javaProgrammers
.stream()
.map(Person::getLastName)
.collect(toCollection(TreeSet::new));


- 获得某个参数的并行的和

System.out.println(“计算付给 Java programmers 的所有money:”);
int totalSalary = javaProgrammers
.parallelStream()
.mapToInt(p -> p.getSalary())
.sum();


- summaryStatistics方法获得stream 中元素的各种汇总数据。 接下来,我们可以访问这些方法,比如getMax, getMin, getSum或getAverage:

//计算 count, min, max, sum, and average for numbers
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
IntSummaryStatistics stats = numbers
.stream()
.mapToInt((x) -> x)
.summaryStatistics();

System.out.println(“List中最大的数字 : “ + stats.getMax());
System.out.println(“List中最小的数字 : “ + stats.getMin());
System.out.println(“所有数字的总和 : “ + stats.getSum());
System.out.println(“所有数字的平均值 : “ + stats.getAverage());


- 从集合中取出符合条件的元素

Student student = students.stream().filter(o -> o.getId() == 3).findAny().orElse(null); 取出条件为3的一条，不存在就为null

<a name="945d3b33"></a>
### List<Map<String,Object>>中的使用

- 造数据

List> list = new ArrayList<>(); Map map1 = new HashMap<>(); map1.put(“name”, “gjc”); map1.put(“score”, 100); map1.put(“age”, 26); list.add(map1); Map map2 = new HashMap<>(); map2.put(“name”, “cgj”); map2.put(“score”, 99); map2.put(“age”, 25); list.add(map2); Map map3 = new HashMap<>(); map3.put(“name”, “cxh”); map3.put(“score”, 98); map3.put(“age”, 26); list.add(map3); list.add(map3);


- 遍历list

list.forEach(map -> System.out.println(map.values()));


- 过滤器循环

list.stream().filter(map -> MapUtils.getLong(map, “score”) > 99).forEach(map -> System.out.println(map.values()));


- 排序

升序

list.stream().sorted((m1, m2) -> (MapUtils.getLong(m1, “score”).compareTo(MapUtils.getLong(m2, “score”)))).forEach(map -> System.out.println(map.values())); 1、sorted() 默认使用自然序排序，其中的元素必须实现Comparable 接口
2、sorted(Comparator<? super T> comparator) ：我们可以使用lambada 来创建一个Comparator 实例。可以按照升序或着降序来排序元素。 list.stream().sorted() list.stream().sorted(Comparator.reverseOrder()) list.stream().sorted(Comparator.comparing(Student::getAge)) list.stream().sorted(Comparator.comparing(Student::getAge).reversed())

多字段排序

list.stream().sorted(Comparator.comparing(xx)).thenComparing(yy).collect()


- 取最值

Map map = list.stream().max((m1, m2) -> (MapUtils.getInteger(m1, “score”) - MapUtils.getInteger(m2, “score”))).get(); System.out.println(map.values());
list.stream().mapToLong(map -> MapUtils.getLong(map, “score”)).max().getAsLong();


- 取总和

int score = list.parallelStream().mapToInt(m -> MapUtils.getInteger(m, “score”)).sum(); System.out.println(score);


- 对集合中的某一参数做变化，取出该参数的集合

TreeSet score = list.stream().map(map -> MapUtils.getInteger(map, “score”) + 100).collect(toCollection(TreeSet::new)); score.forEach(integer -> System.out.println(integer)); List> score1 = list.stream().filter(map2 -> (Integer) map2.get(“score”) > 99).collect(Collectors.toList());


- 对集合参数做变化，取出整个原有集合(会影响后面的list中的map值)

list.stream().peek(map -> map.put(“score”, MapUtils.getLong(map, “score”) * 1.5)).forEach(map -> System.out.println(map.values()));


- 对参数进行去重操作

list.stream().distinct().forEach(map -> System.out.println(map.values()));


- 条件中的元素判断

List strs = Arrays.asList(“a”, “a”, “a”, “a”, “b”); boolean aa = strs.stream().anyMatch(str -> str.equals(“a”)); //任何一个匹配 boolean bb = strs.stream().allMatch(str -> str.equals(“a”));//全匹配 boolean cc = strs.stream().noneMatch(str -> str.equals(“a”));//全不匹配 ```

总结

排序： sorted((p1,p2)->p1.compareTo(p2))
过滤： filter((p1)->p1.score>100)
(1)and操作 filter(predicate.and(predicate2))
(2)or操作 filter(predicate.or(predicate2))
(3)条件取反 filter(predicate.negate())
取某个类型的元素值做操作（后续都针对该值做操作）：map(Person::getAge)
对某个类型的元素值做操作，重新改变值放入集合中：peek(map -> map.put(“score”, MapUtils.getLong(map, “score”) * 1.5))
整体进行连续叠加操作：reduce((x, y) -> x*2 + y)
取前几条值：limit(2)
丢弃前几条取剩余条数：skip(2)
去重重复的元素：distinct()
返回集合的第一个对象,findFirst()
返回取到任何一个对象,findAny(),并行效率高
再什么都没找到时，返回值，orElse()
再什么都没找到，返回具体内部的值，orElseGet()
anyMatch表示，判断的条件里，任意一个元素成功，返回true
allMatch表示，判断条件里的元素，所有的都是，返回true
noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true

Java技术栈

Java8的Lambda表达式和Stream.md

方法引用

Lambda表达式

排序替换

实体类的集合操作

升序

多字段排序

总结