温故而知新

24.5.7

关于各大长度获取

//数组的长度，比较特殊，没有括号
Integer []a = new Integer[4];
int length = a.length;

//String类型的长度，他是一个引用对象。应该是有方法的
String abc = "hello";
abc.length();

//集合的长度
List<Integer> hello = new ArrayList<>();
hello.size();

数组转化为集合

2、最简便的方法

1	List list = new ArrayList<>(Arrays.asList("a", "b", "c"))

3、使用 Java8 的 Stream(推荐)

Integer [] myArray = { 1, 2, 3 };
List myList = Arrays.stream(myArray).collect(Collectors.toList());
//基本类型也可以实现转换（依赖boxed的装箱操作）
int [] myArray2 = { 1, 2, 3 };
List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList());

导包

Arrays的常用方法那肯定是在Arrays类内了，所以导包：java.util.Arrays;

1.Arrays.toString()方法

方法作用：快速输出数组内容，可以偷偷懒🌚

1
2
3

int[] a = {1,2,3,4,5};
System.out.println(Arrays.toString(a));
// 输出格式：[1,2,3,4,5]

2.Arrays.sort()方法

方法运用:给数组排序，默认升序

int[] a = new int[5]{5，4，3，2，1};
Arrays.sort(a); // 1 2 3 4 5
System.out.println(Arrays.toString(a));
// [1,2,3,4,5]

两种重载方式：

①.Arrays.sort(数组名)

②.Arrays.sort(数组名，起始下标，排序个数)

Scanner s = Scanner(System.in);
int n = s.nextInt();
int[] a = new int[n]
for(int i = 0; i < n; i++)
   a[i] = s.nextInt();
Arrays.sort(a,0,n - 1);
//输入n个数，按照升序排列

对字符串进行排序时，是对每一个字符比较，而不是简单的比较长度

1
2
3

// str1 = abd
// str2 = abcdef
// 因为d > c,所以 str1 > str2

它是一个很强大的方法，具体见博文：浅谈Arrays.sort()原理

3.Arrays.equals()方法

方法作用：比较两个数组内容是否相等

int[] a = {1,2,3};
int[] b = {1,2,3};
boolean isSame = Arrays.equals(a,b);
//true

注意：Arrays.equals()是比较数组内容，而a.equals(b) 这样的方法是比较地址值

注意！注意！

以后使用java提供的引用数据内容(数组、字符串、各种集合….)时，一定要用equals()方法比较内容是否相等，而不是傻傻的用 ==了！因为官方已经把equals()给重写了。如果你要比较你自己写的类，例如学生按成绩排序，就要自己重写equals()方法

4.Arrays.binarySearch()

方法作用：在数组中查找元素

1	int Arrays.binarySearch( Datatype[], Datatype key)

再数组中查找指定值，若找到，则返回此值的下标，

若没找到，返回 -插入点-1；

如：

int[] a = {1,5,6,7};
Arrays.binarySearch(a,2)  //没找到，插入点为1，则返回 -2
Arrays.binarySearch(a,4)  //没找到，插入点为1，则返回 -2
Arrays,binarySearch(a,8)  //没找到，插入点为4，则返回 -5
Arrays.binarySearch(a,5)  //找到了！返回下标 1
只要返回值 ≥ 0 ，就代表找到了。

5.Arrays.copyOf()

方法作用：拷贝数组

源码如下：第一个参数是原数组，第二个参数是拷贝长度，返回值是将原数组拷贝一份返回

（它的底层其实是调用了System.arrayCopy()方法）

1
2
3

public static <T> T[] copyOf(T[] original, int newLength) {
      return (T[]) copyOf(original, newLength, original.getClass());
}

需要注意的是返回值是一个新数组，会改变接收这个新数组的引用的一些属性

public static void main(String[] args) {
        int[] arr1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int[] arr2 = new int[5];
        arr2 = Arrays.copyOf(arr1, 10);
}

Arrays.copyOf()的拷贝是从下标0开始的，如果你想从其他下表开始，可以使用Arrays.copyOfRange()方法

1
2
3

// from 表示开始位置， to 表示结束位置  
// 复制下标为 ：[from, to)
Arrays.copyOfRange(int[] original, int from, int to)

6.Arrays.fill()

fill(T[] a, T val)

将某个数组的元素全部置为val值

7.Arrays.asList()

1、Arrays.asList()是泛型方法，传递的数组必须是对象数组，而不是基本类型。

Arrays.asList()在平时开发中还是比较常见的，我们可以使用它将一个数组转换为一个 List 集合。

String[] myArray = {"Apple", "Banana", "Orange"};
List<String> myList = Arrays.asList(myArray);
//上面两个语句等价于下面一条语句
List<String> myList = Arrays.asList("Apple","Banana", "Orange");

2、使用集合的修改方法: add()、remove()、clear()会抛出异常。

List myList = Arrays.asList(1, 2, 3);
myList.add(4);//运行时报错：UnsupportedOperationException
myList.remove(1);//运行时报错：UnsupportedOperationException
myList.clear();//运行时报错：UnsupportedOperationException

Arrays.asList() 方法返回的并不是 java.util.ArrayList ，而是 java.util.Arrays 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。

1 2	List myList = Arrays.asList(1, 2, 3); System.out.println(myList.getClass());//class java.util.Arrays$ArrayList

2、最简便的方法

1	List list = new ArrayList<>(Arrays.asList("a", "b", "c"))

3、使用 Java8 的 Stream(推荐)

Integer [] myArray = { 1, 2, 3 };
List myList = Arrays.stream(myArray).collect(Collectors.toList());
//基本类型也可以实现转换（依赖boxed的装箱操作）
int [] myArray2 = { 1, 2, 3 };
List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList());

Arrays.sort()降序排列

有两种方法可以实现Arrays.sort()的降序排列，一种是可以直接往作业上抄，简便的，一种是比较麻烦的。

但是他们都有一个共同特点：

不能作用于基本数据类型！

那你说，我要是想对：{8，6，5，3，2} 排序，用什么类型呢？这些数据都是int啊，不能降序怎么办？那当然是使用我们的包装类了啊

Integer、Double、Float……

先介绍第一种。(没学的可以跳到equals()了，这里如果想用的话，直接ctrl +cv)

Collections.reverseOrder()

1
2
3

Integer[] a = {1,2,3,4,5}
Arrays.sort(a,Collections.reverseOrder())
// 输出数组的内容即为：5 4 3 2 1

来看看如果用int类型数组会发生什么：

它会提示你：“需要的是一个泛型T[]，而不是int[]” （这里不做讲解，你只要知道不能int就行了）

实现Comparator接口

Comparator接口中有一个compare()方法，重写它就可以改变Arrays.sort()的排序规则

虽然Comparator这种方法复杂一点，但是可以实现的功能就多一点

例如你可以自己写一个Student类，按照姓名排序、按照学号、成绩排序、还可以按照降序排列，找出倒数第一大怨种

总结：

这两种方法共同点都是：

1.不能对基本数据类型（int、double…）进行逆序排序

2.都要在Arrays.sort()里面加点料

Arrays.sort(a) 正常升序

Arrays.sort(a,Collections.reverseOrder()) 逆序①

Arrays.sort(a,new Mycomparator()) 逆序②

实现接口之匿名内部类

这是补充，上面那个实现comparator接口的方法实在太繁琐，你还要为此创建一个类来重写conpare方法，于是，匿名内部类的优点就体现出来了

public class Test {
    public static void main(String[] args) {
        // a数组降序排列应为： 5 4 4 3 3 2 2 1 1
        Integer[] a = {1,2,3,4,5,4,3,2,1};
 
        Arrays.sort(a, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
 
        System.out.println(Arrays.toString(a));
    }
}

是不是看不懂？没事，我把匿名内部类抠出来

你会说，接口不是不许new 对象吗？为什么直接new Comparator()了呢？

是因为匿名内部类的发明就是为了简化接口实现太复杂这个缺点，

new Comparator()后面的大括号的内容相当于一个没有名字的类，它实现了不用起名字，也不用implements Comparator 了，放到接口后面就可以

实现接口之 lambda
可是你说，匿名内部类还是好麻烦啊！还要new,还要重写，那个大括号实在是分不清谁是谁啊！

JAVA工程师自然想到了这一点，Lambda表达式应运而生

仅需一行！仅需一行！是不是很简单？我来解释一下怎么用

Lambda表达式时这样的： ( 参数) -> { 代码 }

参数有几个，完全取决于你要实现的接口方法有几个参数

你看，我们重写的compara方法有两个参数，于是Lambda表达式的()里面就有两个数：e1、e2，而且不用声明他们的类型，我们只需要用，剩下的留给JVM推断去吧

当然，如果{代码}里面只有一行的话，我们不妨大胆一点：

我直接连return 都不要 “为什么” 就不在这里补充了

如果你想了解更多关于Lambda，可以去这位大佬的博客看看（这边建议学完javase再看）

http://t.csdn.cn/gIo1w