Java常用算法API_Arrays和Lambda表达式——代码演示和小练习

Arrays常用方法代码演示：

        方法作用及注意点已在代码中标注

public class ArraysDemo {
    public static void main(String[] args) {
        //toString:将数组变成字符串
        int[] arr = {1,2,3,4,5,6,7,8,9};
        System.out.println(Arrays.toString(arr));
        System.out.println();

        //binarySearch:二分查找法查找元素
        //要求数组内的元素必须为升序
        //如果要查找的元素存在，则返回其索引
        //如果要查找的元素不存在，返回 （-插入点）- 1
        //插入点即要查找的元素在数组中应插入的位置的索引
        System.out.println(Arrays.binarySearch(arr, 6));
        System.out.println(Arrays.binarySearch(arr, 10));//-10 = -(9) - 1
        System.out.println();

        //copyOf:拷贝数组
        //参数一：老数组
        //参数二：新数组的长度
        //方法的底层会根据第二个参数来创建新的数组
        //如果新数组的长度小于老数组的长度，会部分拷贝
        //如果新数组的长度等于老数组的长度，会完全拷贝
        //如果新数组的长度大于老数组的长度，会补上默认初始值
        int[] newArr1 = Arrays.copyOf(arr, 9);
        System.out.println(Arrays.toString(newArr1));
        int[] newArr2 = Arrays.copyOf(arr,5);
        System.out.println(Arrays.toString(newArr2));
        int[] newArr3 = Arrays.copyOf(arr,12);
        System.out.println(Arrays.toString(newArr3));
        System.out.println();

        //copyOfRange:拷贝数组(指定范围)
        //包头不包尾，包左不包右
        int[] newArr4 = Arrays.copyOfRange(arr, 2, 4);
        System.out.println(Arrays.toString(newArr4));
        System.out.println();

        //fill:填充数组
        Arrays.fill(newArr4,10);
        System.out.println(Arrays.toString(newArr4));
        System.out.println();

        //sort:排序 默认情况下给基本数据类型进行升序排序，底层使用的是快速排序
        int[] arr2 = {2,6,1,5,3,4,9};
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));
        System.out.println();
        //sort(数组,规则)
        Integer[] arr3 = {2,6,3,8,1,4,5};
        //从小到大
        Arrays.sort(arr3, new Comparator<Integer>(){

            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(Arrays.toString(arr3));
        //从大到小
        Arrays.sort(arr3, new Comparator<Integer>(){

            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(arr3));
    }
}

Lambda表达式：

Lambda表达式的基本作用：

        简化函数式接口的匿名内部类写法。

什么是函数式接口：

        只有一个抽象方法的接口式函数式接口。

Lambda表达式的好处：

        可以使代码更简洁，更灵活，使Java语言表达能力得到了提升。

Arrays.sort(arr3, new Comparator<Integer>(){

            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        这是Arrays.sort(数组，规则)方法下的代码，摘自Arrays常用方法代码演示中，由上述代码可知，参数“规则”使用了匿名内部类的形式，但是这样写未免有些不简洁，也降低了代码可读性，所以Java中可以使用Lambda表达式来改进。

        我们可以将匿名内部类参数前的部分全部删掉，再删除一个后面的后括号（因为删除了一个前括号），再在参数和后面方法体之间加上 -> 即可，这是Lambda表达式的完整格式，代码如下

Lambda表达式完整格式：

代码演示：

public class Lambda {
    public static void main(String[] args) {
        //Lambda表达式
        Integer[] arr4 = {1,3,5,6,2,4};
        Arrays.sort(arr4, (Integer o1, Integer o2)->{
                    return o1 - o2;
                }
        );
        System.out.println(Arrays.toString(arr4));
    }
}

运行结果：

Lambda表达式的省略写法：

1.参数类型可以省略不写。

2.如果只有一个参数，参数类型可以省略，同时（）也可以省略。

3.如果Lambda表达式的方法体只有一行，大括号、分号、return可以省略不写，但需同时省略。

代码演示：

public class LambdaDemo2 {
    public static void main(String[] args) {
        Integer[] arr = {2,6,3,8,1,4,5};
        Arrays.sort(arr, (o1, o2) -> o1 - o2);
        System.out.println(Arrays.toString(arr));
        //等同于下面
        /*
        Arrays.sort(arr, new Comparator<Integer>(){

            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(Arrays.toString(arr));
         */
    }
}

运行结果：

综合小练习：

题目：Lambda表达式简化Comparator接口的匿名形式

要求：

定义数组并存储一些字符串，利用Arrays中的sort方法进行排序
要求：按照字符串的长度进行排序，短的在前面，长的在后面
（暂时不比较字符串内容）

代码：

public class Test {
    public static void main(String[] args) {
        //定义数组并存储一些字符串，利用Arrays中的sort方法进行排序
        //要求：按照字符串的长度进行排序，短的在前面，长的在后面
        //（暂时不比较字符串内容）

        //定义一个字符串
        String[] strArr = new String[]{"a", "aaa", "aaaa", "aa"};

        Arrays.sort(strArr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });

        for (int i = 0; i < strArr.length; i++) {
            System.out.println(strArr[i]);
        }

    }
}

简化后代码：

public class Test {
    public static void main(String[] args) {
        //定义数组并存储一些字符串，利用Arrays中的sort方法进行排序
        //要求：按照字符串的长度进行排序，短的在前面，长的在后面
        //（暂时不比较字符串内容）

        //定义一个字符串
        String[] strArr = new String[]{"a", "aaa", "aaaa", "aa"};

        Arrays.sort(strArr, (o1,  o2) -> o1.length() - o2.length());

        for (int i = 0; i < strArr.length; i++) {
            System.out.println(strArr[i]);
        }

    }
}

运行结果：