可变参数及Lambda表达式

6.可变参数及Lambda表达式

6.1.可变参数

6.1.1.背景

• 在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

//修饰符 返回值类型 方法名(参数类型... 形参名){ }  JDK1.5之后支持，可以改变参数的数量

//修饰符 返回值类型 方法名(参数类型[] 形参名){ }   一直支持，相对复杂，不如可变参数简单

//二者完全等价，唯一不同之处是后者需要传入数组，前者直接传递数据即可

• 同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

  个人理解：为什么说可变参数写法简单呢？

  假设这样一个场景，有一个函数，求两数之和，但是某天，要求变了，变为三个数的和，某天又变了，变为n个数的和，这时可变参数就变得非常简便了，因为只要添加修改函数内容即可，就参数而言，不管需要传入多少个，只要类型一样均可以用…形式代表

6.1.2.Example

public class ChangeArgs {
    public static void main(String[] args) {
        int[] arr = { 1, 4, 62, 431, 2 };
        int sum = getSum(arr);
        System.out.println(sum);
        // 6 7 2 12 2121
        // 求这几个元素和 6 7 2 12 2121
        int sum2 = getSum(6, 7, 2, 12, 2121);
        System.out.println(sum2);
    }
    /*
    * 完成数组 所有元素的求和 原始写法
        public static int getSum(int[] arr){
            int sum = 0;
            for(int a : arr){
                sum += a;
            }
            return sum;
        }
    */
    
    //可变参数写法
    public static int getSum(int... arr) {
        int sum = 0;
        for (int a : arr) {
        	sum += a;
        }
   		return sum;
    }
}

6.2.Lambda表达式

6.2.1.冗余的Runnable代码

• 传统写法：当需要启动一个线程去完成任务时，通常会通过 java.lang.Runnable 接口来定义任务内容，并使用java.lang.Thread 类来启动该线程

public class Demo_Runnable {
        public static void main(String[] args) {
        // 匿名内部类
        Runnable task = new Runnable() {
            @Override
            public void run() { // 覆盖重写抽象方法
            	System.out.println("多线程任务执行！");
            }
        };
        new Thread(task).start(); // 启动线程
    }
}

• lambda写法：不在意内部如何完成，省略到最简

public class Test_LambdaRunnable {
	public static void main(String[] args) {
		new Thread(() ‐> System.out.println("多线程任务执行！")).start(); // 启动线程
	}
}

6.2.2.参数和返回值

public class Person {
    private String name;
    private int age;
    // 省略构造器、toString方法与Getter Setter
}

//传统写法
public class Demo06Comparator {
    public static void main(String[] args) {
        // 本来年龄乱序的对象数组
        Person[] array = {
            new Person("古力娜扎", 19),
            new Person("迪丽热巴", 18),
            new Person("马尔扎哈", 20) 
        };

        // 匿名内部类
        Comparator<Person> comp = new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() ‐ o2.getAge();
            }
        };
        Arrays.sort(array, comp); // 第二个参数为排序规则，即Comparator接口实例
        for (Person person : array) {
            System.out.println(person);
        }    
    }
}


//Lambda写法
public class Demo07ComparatorLambda {
    public static void main(String[] args) {
        Person[] array = {
            new Person("古力娜扎", 19),
            new Person("迪丽热巴", 18),
            new Person("马尔扎哈", 20) 
        };
        Arrays.sort(array, (Person a, Person b) ‐> {
            return a.getAge() ‐ b.getAge();
        });
        for (Person person : array) {
            System.out.println(person);
        }
    }
}