Java-Lambda相关使用介绍
频繁使用的语句
Lambda又涉及到comparator和comparable区别(Comparable是实现comparable接口,实现后可以使用Collections.sort或Arrays.sort,而Comparator是个比较接口,内部有compare和equals函数,而
Labmda中的sort就是实现的后者comparator接口,具体可以见代码),匿名内部类实现和Lambda实现互相转换(Lambda就是把匿名内部类简化了),数组和链表的转换(lambda有toArray函数,Arrays.aslist可以转化成list)
//Arrays循环输出
Arrays.stream(heros).forEach(System.out::println);
//Arrays排序
Arrays.stream(arr).sorted((arr1, arr2)-> arr2-arr1).forEach(System.out::println); //int[]的sorted方法无入参
//filter筛选
heros.stream().filter(hero -> testMethod(hero)).forEach(hero -> System.out.println(hero));
//map转换成list进行存储
List<String> temp = heros.stream().map(hero -> hero.getName() + "-" + hero.getHp() + "-" + hero.getDamage()).collect(Collectors.toList());
//得到某个对象
Hero firstHero = heros.stream().findFirst().get();
前言
组长让我用Lambda加个功能的时候,网上搜到了使用教程,不是很熟练,趁着端午节详细学习一下Lambda相关内容.
Lambda简介
- 普通类:循环遍历集合,进行输出或比较
- 匿名类:实现接口的方法,循环编辑进行输出
- Lambda:简化代码,实际操作也是转换成匿名类进行处理。
Lambda引用类型(包含普通语句,静态方法,对象方法,容器对象方法,构造器,这里只写平时用得着的)
- 普通语句
List<Hero> list = new ArrayList<>();
list.stream().filter(h->h.getDamage() > 10 && h.getDamage() < 50).forEach(System.out::println);
- 静态方法
List<Hero> list = new ArrayList<>();
list.stream().filter(h->bewteen(h)).forEach(System.out::println);
private static boolean bewteen(Hero h){
return h.getDamage() > 10 && h.getDamage() < 50;
}
Lambda聚合类型
对元素进行筛选:
filter 匹配
distinct 去除重复(根据equals判断)
sorted 自然排序
sorted(Comparator
limit 保留
skip 忽略
转换为其他形式的流
mapToDouble 转换为double的流
map 转换为任意类型的流
forEach() 遍历每个元素
toArray() 转换为数组
min(Comparator
max(Comparator
count() 总数
findFirst() 第一个元素
上述功能介绍
package lambda;
import charactor.Hero;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author :Empirefree
* @description:TODO
* @date :2020/6/25 14:50
*/
public class testLambda4 {
public static void main(String[] args) {
Random r = new Random();
List<Hero> heros = new ArrayList<Hero>();
for(int i = 0; i < 10; i++) {
heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
}
// filter(heros, h->testMethod(h));
/* //制造重复元素
heros.add(heros.get(0));
heros.stream().filter(hero -> testMethod(hero)).forEach(hero -> System.out.println(hero));
System.out.println("============去重");
heros.stream().distinct().forEach(hero -> System.out.println(hero));
System.out.println("============自然排序");
heros.stream().sorted().forEach(hero -> System.out.println(hero));
System.out.println("============按规则排序");
heros.stream().sorted((h1, h2)->h1.getHp() >= h2.getHp() ? 1: -1).forEach(hero -> System.out.println(hero));
System.out.println("============只输出3个");
heros.stream().limit(3).forEach(System.out::println);
System.out.println("============忽略前3个");
heros.stream().skip(3).forEach(System.out::println);
System.out.println("============转化为double流");
heros.stream().mapToDouble(Hero::getHp).forEach(System.out::println);
System.out.println("============转化为任意类型的流");
heros.stream().map(hero -> hero.getName() + "-" + hero.getHp() + "-" + hero.getDamage()).forEach(System.out::println);
List<String> temp = heros.stream().map(hero -> hero.getName() + "-" + hero.getHp() + "-" + hero.getDamage()).collect(Collectors.toList());
System.out.println("============map转换成list存储");
System.out.println(temp);*/
Object[] objects = heros.stream().toArray();
// List<Hero> temp = Arrays.asList(objects);
System.out.println("============转化为数组");
System.out.println(Arrays.toString(objects));
Hero minDamageHero = heros.stream().min((h1, h2)->h1.getDamage() - h2.getDamage()).get();
System.out.println(minDamageHero);
Hero maxDamagehero = heros.stream().max((h1, h2)->h1.getDamage() - h2.getDamage()).get();
System.out.println(maxDamagehero);
long cout = heros.stream().count();
System.out.println(cout);
Hero firstHero = heros.stream().findFirst().get();
System.out.println(firstHero);
}
private static boolean testMethod(Hero hero){
return hero.getDamage() > 10 && hero.getDamage() < 60;
}
private static void filter(List<Hero> heros, heroChecker checker) {
for (Hero hero : heros) {
if (checker.test(hero)) {
System.out.print(hero);
}
}
}
}
匿名内部类与Lambda+链表和数组转换+排序
package lambda;
import charactor.Hero;
import java.lang.reflect.Array;
import java.util.*;
/**
* @author :Empirefree
* @description:TODO
* @date :2020/6/25 12:07
*/
public class test {
public static void main(String[] args) {
Long l1 = new Long(100);
Long l2 = new Long(200);
System.out.println(l1.equals(l2));
System.out.println(l1.longValue() < l2.longValue());
/*
Integer[] arr = {4, 1, 3, 5, 6, 7, 9, 1};
*/
/* Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});*//*
Arrays.stream(arr).sorted((arr1, arr2)-> arr2-arr1).forEach(System.out::println);
*/
/* List<String> heroes = new LinkedList<>();
heroes.add("asdf");
String[] temp = new String[]{"1243", "asdf"};
for (String string : temp){
System.out.println(string);
}
heroes.toArray(temp);
System.out.println(heroes);
System.out.println(temp);
for (String string : temp){
System.out.println(string);
}
List<String> hero2 = Arrays.asList(temp);
System.out.println(hero2);*/
}
}
我曾七次鄙视自己的灵魂:
第一次,当它本可进取时,却故作谦卑;
第二次,当它在空虚时,用爱欲来填充;
第三次,在困难和容易之间,它选择了容易;
第四次,它犯了错,却借由别人也会犯错来宽慰自己;
第五次,它自由软弱,却把它认为是生命的坚韧;
第六次,当它鄙夷一张丑恶的嘴脸时,却不知那正是自己面具中的一副;
第七次,它侧身于生活的污泥中,虽不甘心,却又畏首畏尾。