Java常用API（三）

一、Arrays类

1.定义

Arrays是一个用于操作数组的工具类。

2.常用方法

1.toString方法 

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

通过源码可以发现，就是很普通的遍历数组，将数组元素添加到 StringBuilder 对象中。

2.binarySearch方法

public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        //binarySearch  二分查找法查找元素（前提：数组必须有序且升序）
        System.out.println(Arrays.binarySearch(arr, 10));//9
        System.out.println(Arrays.binarySearch(arr, 2));//1
        System.out.println(Arrays.binarySearch(arr, 20));//-11
    }
}

细节：

① 二分查找的前提是有序表，但是对于 binarySearch 方法，还需要是升序的。

② 如果要查找的元素存在，返回索引；如果不存在，返回的是   -插入位置 - 1。

question：为什么需要 -1 呢？

对于该数组，如果要查找数字 0 ，此时 0 是不存在的。

如果只返回 -插入位置，也就是 -0 ，即 0 。

此时就没法确定，返回的这个 0 是表示数字 0 存在时返回的索引，还是不存在时的返回值。

为了避免这样的情况产生，java在此基础上，进行了 -1。

3.copyOf 方法

public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        //copyOf  拷贝数组
        int[] newArr = Arrays.copyOf(arr, 20);
        System.out.println(Arrays.toString(newArr));
        //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    }
}

细节：

① 方法底层实际上调用的就是 System 类的 arraycopy 方法。

②  参数一是原数组，参数二表示新数组的长度。方法的底层会根据第二个参数来创建新的数组。

I.   如果新数组的长度 < 原数组的长度，则部份拷贝

II.  如果新数组的长度 = 原数组的长度，则完全拷贝

III. 如果新数组的长度 > 原数组的长度，则会补上默认初始化值。

4.copyOfRange方法

public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        //copyOfRange  拷贝数组（指定范围）--> 包头不包尾，包左不包右
        int[] newArr = Arrays.copyOfRange(arr, 0, 9);
        System.out.println(Arrays.toString(newArr));
        //[1, 2, 3, 4, 5, 6, 7, 8, 9]
    }
}

细节：

copyOfRange 方法在拷贝数组时，包头不包尾，包左不包右。

5.fill 方法 

public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        //fill  填充数组
        Arrays.fill(arr, 100);
        System.out.println(Arrays.toString(arr));
        //[100, 100, 100, 100, 100, 100, 100, 100, 100, 100]
    }
}

细节：

在底层，实质上就是一个 for 循环，将数组的每一个元素进行覆盖。

 6.sort 方法

public class Demo {
    public static void main(String[] args) {
        int[] arr = {10, 2, 3, 5, 6, 1, 7, 8, 4, 9};

        //sort  排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }
}

细节：

默认情况下，给基本数据类型进行升序排列，底层使用的是快速排序

question：如果我想对数组进行降序，如何实现？

************************************************************************************************************** 

7.sort 重载方法

public class Demo {
    public static void main(String[] args) {
        Integer[] arr = {10, 2, 3, 5, 6, 1, 7, 8, 4, 9};

        //public static void(数组, 排序规则)  按照指定规则进行排序
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(Arrays.toString(arr));
        //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }
}

细节：

① 该方法只能给引用数据类型进行排序，如果数组是基本数据类型，需要变成其对应的包装类。

② 该方法的第二个参数是一个接口，表示排序规则。所以调用方法时，可以使用匿名内部类来作为这个接口的实现类对象。

③  底层原理是使用折半插入排序（插入排序 + 二分查找）。

④ compare 方法的形参：

I.  o1 表示在无序序列中，遍历得到的每一个元素；

II. o2 表示有序序列中的元素（按二分查找的顺序）。

compare 方法的返回值：

I.  负数：表示当前要插入的元素 < 已排好的元素，插在前面

II. 正数：表示当前要插入的元素 > 已排好的元素，插在后面

III.   0  ： 表示当前要插入的元素 = 已排好的元素，同样也插在后面

结论：

（1）待排（o1）-已排（o2）为正，说明待排 > 已排，待排放已排右边，即是升序。

（2）已排（o2）-待排（o1）为正，说明已排 > 待排，已排放待排右边，既是降序。

二、lambda表达式 

1.函数式编程

面向对象编程：先创建对象，再让对象做事情。、

 对于这种写法中，我们只关心方法中的逻辑（方法体），并不关心是哪个对象调用了这个方法。

但是对于面向对象编程，又不得不先创建对象，所以造成了一定的麻烦。

**************************************************************************************************************

函数式编程：忽略面向对象的复杂语法，强调做什么，而不是谁去做。

2.函数式接口

函数式接口：有且仅有一个抽象方法的接口（两个条件缺一不可）。 

接口上方可以加上 @FunctionalInterface 注解进行验证，若不满足条件，则会报错。

3.Lambda表达式

Lambda表达式是JDK8开始后的一种新的语法格式。

（1）Lambda表达式的完整格式

省略 new，接口名，函数名等，用一个箭头让形参指向方法体,即：() -> {}

注意点：

① Lambda表达式可以用来简化匿名内部类的书写

② Lambda表达式只能简化函数式接口的匿名内部类的写法。

public class Demo {
    public static void main(String[] args) {
        Integer[] arr = {10, 2, 3, 5, 6, 1, 7, 8, 4, 9};

        //public static void(数组, 排序规则)  按照指定规则进行排序
        Arrays.sort(arr,(Integer o1, Integer o2) -> {
                return o1 - o2;
            }
        );
        System.out.println(Arrays.toString(arr));
        //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }
}

（2） Lambda表达式的简写格式

即：凡是能推导出来的，都可以省略。

具体省略规则：

① 参数的数据类型可以省略不写

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

public class Demo {
    public static void main(String[] args) {
        Greeting greeting = name -> {
            System.out.println("Hello " + name);
        };

        greeting.greet("John");
    }
}


@FunctionalInterface
interface Greeting {
    public abstract void greet(String name);
}

③ 如果方法体只有一行，{}，分号，return，都可以省略不写，但必须同时省略。

public class Demo {
    public static void main(String[] args) {
        Integer[] arr = {10, 2, 3, 5, 6, 1, 7, 8, 4, 9};

        //public static void(数组, 排序规则)  按照指定规则进行排序
        Arrays.sort(arr,(o1, o2) -> o1 - o2);
        System.out.println(Arrays.toString(arr));
        //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }
}