一、Lambda 表达式
Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
lambda表达式的重要特征:
- 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值。
- 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
- 可选的大括号:如果主体包含了一个语句,就不需要使用大括号。
- 可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明表达式返回了一个数值。
语法形式为 () -> {},其中 () 用来描述参数列表,{} 用来描述方法体,-> 为 lambda运算符 ,读作(goes to)。
lambda注意事项:
1.变量作用域:lambda 表达式只能引用标记了 final 的外层局部变量,这就是说不能在 lambda 内部修改定义在域外的局部变量,否则会编译错误。或者外部变量没有final标记且lambda内没有修改外部变量也不报错。总而言之 lambda 内不可以修改外部变量!
2.在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。
1.list遍历集合
.forEach()方法
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 1,2,3,4,5);
//lambda表达式1 直接输出每个元素
list.forEach(System.out::println);
//lambda表达式2 直接输出每个元素
list.forEach(element -> {
System.out.println(element);
});
2.list删除集合中的某个元素
.removeIf()方法
public class Java8Test {
private int id;
private String name;
private int age;
public Java8Test(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "id: " + id + " name: " + name + " age: " + age;
}
public static void main(String args[]){
ArrayList<Java8Test> list = new ArrayList<>();
list.add(new Java8Test(1,"zhangsan",20));
list.add(new Java8Test(2,"lisi",21));
list.add(new Java8Test(3,"wangwu",22));
list.add(new Java8Test(4,"zhaoliu",23));
list.removeIf(filter -> "lisi".equals(filter.name));
list.forEach(item -> System.out.println(item.toString()));
}
}
输出结果:
id: 1 name: zhangsan age: 20
id: 3 name: wangwu age: 22
id: 4 name: zhaoliu age: 23
3.list集合内元素的排序
.sort()方法
public class Java8Test {
private int id;
private String name;
private int age;
public Java8Test(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "id: " + id + " name: " + name + " age: " + age;
}
public static <T> void main(String args[]){
ArrayList<Java8Test> list = new ArrayList<>();
list.add(new Java8Test(1,"zhangsan",18));
list.add(new Java8Test(2,"lisi",15));
list.add(new Java8Test(3,"wangwu",20));
list.add(new Java8Test(4,"zhaoliu",19));
list.add(new Java8Test(5,"tianqi",18));
//java8版本之前排序
/*list.sort(new Comparator<Java8Test>() {
@Override
public int compare(Java8Test o1, Java8Test o2) {
return o1.age - o2.age;
}
});*/
//java8 排序
list.sort((Java8Test o1, Java8Test o2) -> o1.age - o2.age);
list.forEach(item -> System.out.println(item.toString()));
}
}
4.set遍历集合、set删除某个元素、set排序
4-1.set遍历
和list遍历相同 不在赘述
4-2.set删除某个元素
和list 删除某个元素 相同 不在赘述
4-3.set排序
public static void main(String args[]){
Set<String> set = new HashSet<>();
set.add("31");
set.add("22");
set.add("43");
set.add("12");
set.add("34");
//java8 版本之前排序
/*Set<String> sortSet = new TreeSet<String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1);//降序排列
}
});
sortSet.addAll(set);*/
//java8 lambda排序1
Set<String> sortSet = new TreeSet<String>((o1, o2) -> o2.compareTo(o1));
sortSet.addAll(set);
//java8 lambda排序2
/*Set<String> sortSet = new TreeSet<String>(Comparator.naturalOrder());//Comparator.naturalOrder()升序;Comparator.reverseOrder()降序;
sortSet.addAll(set);*/
//java8 流排序 只能升序??
/*Set<String> sortSet = new TreeSet<String>();
sortSet.addAll(set);
//sortSet.stream().sorted(Comparator.reverseOrder()); //亲测只能升序排!!what??
//sortSet.stream().sorted((o1, o2) -> o2.compareTo(o1));//亲测只能升序排!!what??
sortSet.stream().sorted(new Comparator<String>() { //亲测只能升序排!!what??
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1);//降序排列
}
});*/
sortSet.forEach(System.out :: println);
}
5.map遍历集合、map删除某个元素、map排序
public static void main(String args[]){
Map<String,String> map = new HashMap<>();
map.put("zhangsan", "15");
map.put("lisi", "20");
map.put("wangwu", "17");
map.put("zhaoliu", "19");
map.put("tianqi", "14");
//大致的思路是把Map的EntrySet转换成list,然后使用Collections.sort排序, 根据排序需求改写comparator
List<Map.Entry<String, String>> list = new ArrayList<>(map.entrySet());
//1. 匿名函数写法:
/*Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
@Override
public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
return o2.getValue().compareTo(o1.getValue());//降序
}
});*/
//2. lambda表达式写法:
//按value降序
Collections.sort(list, (Map.Entry<String, String> o1, Map.Entry<String, String> o2)->o2.getValue().compareTo(o1.getValue()));
//3.精简写法 默认升序排列,若要按value降序用上面的lambda表达式
//Collections.sort(list,Comparator.comparing(Map.Entry<String, String> :: getValue));
Map<String, String> linkedHashMap = new LinkedHashMap<>();
for (Map.Entry<String, String> e: list) {
linkedHashMap.put(e.getKey(), e.getValue());
}
//map遍历
linkedHashMap.forEach((k,v)->{
System.out.println(k+":"+v);
});
}