Lambda作为方法的一部分

Lambda作为方法的参数

需求说明

假设有一个Person类，含有String name和int age两个成员变量。创建对象数组，存储多个Person对象，然后对该数组的Person进行排序：按照年龄从小到大。数据如下：

new Person("古力娜扎", 19),new Person("迪丽热巴", 18),new Person("马尔扎哈", 20)

传统写法

如果使用传统的代码对Person[]数组进行排序，步骤如下：

1) 创建对象数组

2) 使用匿名内部类创建比较器，并重写方法，按年龄从小到大排序

3) 调用数组类的sort()方法排序

4) 输出排序后的结果

class Person {
​
    private String name;
​
    private int age;
    ......
}
​
 
public class DemoPerson {
​
    public static void main(String[] args) {
​
        //1)    创建对象数组
​
        Person [] persons = {
​
                new Person("古力娜扎", 19),
​
                new Person("迪丽热巴", 18),
​
                new Person("马尔扎哈", 20)
​
        };
​
        System.out.println("没有排序");
​
        for (Person person : persons) {
​
            System.out.println(person);
​
        }
​
//        2)    使用匿名内部类创建比较器，并重写方法，按年龄从小到大排序
​
   Comparator<Person> c1 = new Comparator<Person>() {
​
            @Override
​
            public int compare(Person o1, Person o2) {
​
                return o1.getAge() - o2.getAge();
​
            }
​
        };
​
//        3)    调用数组类的sort()方法排序
        Arrays.sort(persons, (o1,o2) -> o2.getAge() - o1.getAge());
        
​
//        4)    输出排序后的结果
​
        System.out.println("排序后");
​
        for (Person person : persons) {
​
            System.out.println(person);
​
        }
    }
}
​

作为方法的返回值

如果一个方法的返回类型是一个接口，并且接口中只有一个方法，
​
那么就可以使用Lambda表达式实现方法的主体，并且返回这个接口的对象。

如：当使用方法Arrays.sort(数组, 比较器)对数组进行排序的时候，

这个方法需要传递一个java.util.Comparator类型的对象作为排序器。

我们可以写一个方法返回比较器接口对象，而这个比较器对象可以在方法中使用Lambda表达式得到。

案例需求

1) 创建类有如下字符串数组："Jack","Rose","make","tom","1000","9"

2) 创建方法 private static Comparator<String> stringLengthComparator()，用于返回一个比较器对象。

3) 使用内部匿名类实现这个比较器，比较规则如下：

先比较长度，长度大的比较大。如果长度相同，则按以前的规则比较大小，然后返回比较器对象。

4) 输出排序前的数组

5) 调用Arrays.sort()排序方法，调用上面的方法得到一个比较器。

6) 输出排序后的结果

7) 使用Lambda表达式实现这个比较器，返回比较器对象。

案例代码

public class DemoString {
​
    public static void main(String[] args) {
​
//        1)    创建类有如下字符串数组："Jack","Rose","make","tom","1000","9"
​
        String[] names = {"Jack","Rose","make","tom","1000","9"};
​
//        4)    输出排序前的数组
​
        System.out.println("排序前：" + Arrays.toString(names));
​
//        5)    调用Arrays.sort()排序方法，调用上面的方法得到一个比较器。
​
        Arrays.sort(names, stringLengthComparator1());
​
//        6)    输出排序后的结果
​
        System.out.println("排序后：" + Arrays.toString(names));
​
//        7)    使用Lambda表达式实现这个比较器，返回比较器对象。
        Arrays.sort(names, stringLengthComparator2());
​
//输出排序后的结果
​
        System.out.println("排序后：" + Arrays.toString(names));
    }
​
    //2)创建方法 private static Comparator<String> stringLengthComparator()，
    //用于返回一个比较器对象。
​
    private static Comparator<String> stringLengthComparator1() {
​
        //        3)    使用内部匿名类实现这个比较器，比较规则如下：
        //先比较长度，长度大的比较大。如果长度相同，则按以前的规则比较大小，然后返回比较器对象。
​
        return new Comparator<String>() {
​
            @Override
​
            public int compare(String o1, String o2) {
​
                return o1.length() - o2.length() == 0? o1.compareTo(o2): o1.length() - o2.length();
​
            }
​
        };
    }
​
    //使用Lambda表达式实现这个比较器，返回比较器对象。
    private static Comparator<String> stringLengthComparator2() {
​
        return (o1, o2) -> o1.length() - o2.length() == 0? o1.compareTo(o2): o1.length() - o2.length();
​
    }
}
​

对集合进行遍历

在Java中使用集合最常见的操作就是进行遍历。现在使用Lambda可以让遍历的代码更加简洁。

遍历的语法

java.lang.Iterable接口中的方法	说明
void forEach(Consumer action)	在JDK8的java.lang.Iterable这个接口中新定义了迭代的方法，用于对单列集合的遍历。Iterable的子接口有List和Set，也就是所有的List和Set中都有这个方法。
参数：Consumer是操作一个变量的接口，我们可以使用Lambda实现接口中的方法，方法没有返回值。public interface Consumer<T> { //对给定的变量进行指定的操作 void accept(T t);}

​

java.util.Map接口中的方法	说明
void forEach(BiConsumer action)	在JDK8的java.util.Map接口新增的迭代元素的方法，用于对双列集合进行遍历。
参数：BiConsumer是操作两个变量的接口，我们可以使用Lambda实现接口中的方法，方法没有返回值。public interface BiConsumer<T, U> { //对给定的2个变量进行指定的操作 void accept(T t, U u);}

演示案例

案例需求：

1) 创建List集合，Set集合，Map集合

2) 使用Consumer匿名内部类和BiConsumer匿名内部类遍历输出每种集合

3) 使用Lambda遍历输出每种集合

案例代码：

public class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list= new ArrayList<>();
        Collections.addAll(list,3,354,354,5,3,53,53,6,7,67,68,23,4);
​
//        list.forEach(new Consumer<Integer>() {
//            @Override
//            public void accept(Integer integer) {
//                System.out.println(integer);
//            }
//        });
​
        list.forEach((i)-> System.out.println(i));
​
        HashSet<Integer>  set=new HashSet<>();
​
        Collections.addAll(set,3,354,354,5,3,53,53,6,7,67,68,23,4);
​
        set.forEach((i)-> System.out.println(i));
​
​
        HashMap<Integer,Integer>  map=new HashMap<>();
        map.put(1,3);
        map.put(2,5);
        map.put(3,7);
        map.put(4,9);
​
        map.forEach((i1,i2)-> System.out.println(i1+"=="+i2));
    }
}
​
​