Arrays

排序

  • Arrays.sort() 及其它的重载方法
  • 双轴快速排序

  1. 如果不指定外部比较器，则要求比较对象实现 Comparable 接口 ```java // 一个实现了 Comparable 接口的类 @AllArgsConstructor @NoArgsConstructor @Getter @Setter @ToString class Person implements Comparable { private Integer age;

    // 比较大小 @Override public int compareTo(Person otherPerson) {

    1.  if (null == otherPerson) {
    2.      return 1;
    3.  }
    4.  if (this == otherPerson) {
    5.      return 0;
    6.  }
    7.  if (null == this.getAge()) {
    8.      return -1;
    9.  }
    10.  if (this.getAge().equals(otherPerson.getAge()))
    11.      return 0;
    12.  return this.getAge() > otherPerson.getAge() ? 1 : -1;

    } }

private static void sourt1() { List people = new ArrayList<>(4); people.add(new Person(30)); people.add(new Person(20)); people.add(new Person(10)); people.add(new Person(40));

  1. Person[] personArrays = new Person[people.size()];
  2. people.toArray(personArrays);
  4. System.out.println("排序前" + Arrays.toString(personArrays));
  5. // 不指定外部比较器的用法，要求比较对象实现 Comparable 接口
  6. Arrays.sort(personArrays);
  7. System.out.println("排序后:" + Arrays.toString(personArrays));

}

  2. 2. **指定外部比较器**
  4. ```java
  5. // 如果没有实现 Comparable 接口
  6. @AllArgsConstructor
  7. @NoArgsConstructor
  8. @Getter
  9. @Setter
  10. @ToString
  11. class Person {
  12.     private Integer age;
  13. }
  15. private static void sourt1() {
  16.     List<Person> people = new ArrayList<>(4);
  17.     people.add(new Person(30));
  18.     people.add(new Person(20));
  19.     people.add(new Person(10));
  20.     people.add(new Person(40));
  22.     Person[] personArrays = new Person[people.size()];
  23.     people.toArray(personArrays);
  25.     System.out.println("排序前" + Arrays.toString(personArrays));
  27.     // 如果自定义类没有实现 Comparable 接口，那么 sort 需要指定下 Comparator
  28.         Arrays.sort(personArrays, new Comparator<Person>() {
  29.             /**
  30.              * a negative integer, zero, or a positive integer as the
  31.              * first argument is less than, equal to, or greater than the second.
  32.              *
  33.              * 负数则         o1 < o2
  34.              * 0 则           o1 = o2
  35.              * 正数则         o1 > o2
  36.              *
  37.              * @param o1
  38.              * @param o2
  39.              * @return
  40.              */
  41.             @Override
  42.             public int compare(Person o1, Person o2) {
  43.                 if (o1 == o2) {
  44.                     return 0;
  45.                 }
  46.                 if (null == o1.getAge()) {
  47.                     return -1;
  48.                 }
  49.                 if (o1.getAge().equals(o2.getAge()))
  50.                     return 0;
  51.                 return o1.getAge() > o2.getAge() ? 1 : -1;
  52.             }
  53.         });
  55.     System.out.println("排序后:" + Arrays.toString(personArrays));
  56. }

二分查找

  • 要求

    1. 已排序
    2. 如果没有指定比较器，则要求查找对象实现 Comparable 接口
      1. int result = Arrays.binarySearch(personArrays, new Person(20));
      2. if (result < 0) {
      3. System.out.println("未找到");
      4. } else {
      5. System.out.println("已找到，下标为: " + result);
      6. }

  • 看下底层源码

    1. // Like public version, but without range checks.
    2. // a：我们要搜索的数组
    3. // fromIndex：从那里开始搜索，默认是0
    4. // toIndex：搜索到何时停止，默认是数组大小
    5. // key：我们需要搜索的值 
    6. // c：外部比较器
    7. private static <T> int binarySearch0(T[] a, int fromIndex, int toIndex,
    8.                                    T key, Comparator<? super T> c) {
    9.   // 如果没有指定外部比较器，则使用 key 自带的比较器
    10.   if (c == null) {
    11.       return binarySearch0(a, fromIndex, toIndex, key);
    12.   }
    13.   int low = fromIndex;
    14.   int high = toIndex - 1;
    16.   while (low <= high) {
    17.       // 中间坐标
    18.       int mid = (low + high) >>> 1;
    19.       T midVal = a[mid];
    20.       int cmp = c.compare(midVal, key);
    21.       // c > key
    22.       if (cmp < 0)
    23.           low = mid + 1;
    24.       // c < key
    25.       else if (cmp > 0)
    26.           high = mid - 1;
    27.       // c == 0
    28.       else
    29.           return mid; // key found
    30.   }
    31.   return -(low + 1);  // key not found.
    32. }

拷贝

  • Arrays.copyOfRange()

    1. Person[] people1 = Arrays.copyOfRange(personArrays, 0, personArrays.length);

  • 源码，底层是调用 System.arraycopy()

    1. public static <T> T[] copyOfRange(T[] original, int from, int to) {
    2.   return copyOfRange(original, from, to, (Class<? extends T[]>) original.getClass());
    3. }
  1.  public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
  2.         int newLength = to - from;
  3.         if (newLength < 0)
  4.             throw new IllegalArgumentException(from + " > " + to);
  5.         @SuppressWarnings("unchecked")
  6.         T[] copy = ((Object)newType == (Object)Object[].class)
  7.             ? (T[]) new Object[newLength]
  8.             : (T[]) Array.newInstance(newType.getComponentType(), newLength);
  9.         System.arraycopy(original, from, copy, 0,
  10.                          Math.min(original.length - from, newLength));
  11.         return copy;
  12.     }

Collections

排序

二分查找

查最大、最小

  • 只看一种
  • Collections.max(), 提供两个重载方法
    1. // 利用泛型要求 比较对象
    2. // 1. 继承于 Objects
    3. // 2. 实现了 Comparable 接口
    4. public static <T extends Object & Comparable<? super T>> 
    5.   T max(Collection<? extends T> coll) {}
  1. public static <T> 
  2.     T max(Collection<? extends T> coll, Comparator<? super T> comp) {}

集合

线程安全

不可变

  • unmodifiable 开头的方法，将传入的集合类转变为不可变对象
    • 仅提供读取方法
    • 其实就是将 set、add 等修改类方法全体抛出异常 throw new UnsupportedOperationException();

**

Objects

判断相同

  • Objects.equals()

    • 比较对象
      1. public static boolean equals(Object a, Object b) {
      2.    return (a == b) || (a != null && a.equals(b));
      3. }

  • Objects.deepEquals()

    • 比较数组
      1. public static boolean deepEquals(Object a, Object b) {
      2.    if (a == b)
      3.        return true;
      4.    else if (a == null || b == null)
      5.        return false;
      6.    else
      7.        return Arrays.deepEquals0(a, b);
      8. }