1、Arrays

java中包装数组的一些基本用法的抽象类 java.util.Arrays。这个类中包含操作数组（例如排序和搜索）的一些算法。他们都是抽象方法

1.1 、binarySearch

主要用来搜索数组中有没有该元素，如果有，返回它的下标值

1.2、copy of

抽象方法，用来进行数组的复制。返回复制完成的数组。如果newLength > 原数组的大小，则新数组用数据类型的默认值填充。如果newLength < 原数组的大小，则原数组从下标0开始进行复制，知道复制newlength个之后结束。这个方法不是特别方便。

** 复制都得从下标0开始，无法自由选择。**

1.3、fill

填充/插入 fill，给定一个数据，将其填充整个数组或者数组中的部分元素

1.4、sort

排序：对数组中的全部元素或者部分元素根据元素升序进行排列。数组中的数据类型必须实现compareble接口。

1.5、Arrays.asList()

该方法返回是Arrays内部静态类ArrayList，不是平常用的ArrayList，该静态类ArrayList没有覆盖父类的add, remove等方法，如果直接调用，会报UnsupportedOperationException异常。

将数组转换为集合，接收一个可变参

List list = Arrays.asList(1, 2, 3);
list.forEach(System.out::println); // 1 2 3

如果将基本数据类型的数组作为参数传入，该方法会把整个数组当作返回的List中的第一个元素

int[] ints = {1,2,3};
        List list2 = Arrays.asList(ints);
        System.out.println(Arrays.toString((int[]) list2.get(0)));
        list2.add(4);
        //Exception in thread "main" java.lang.UnsupportedOperationException
        //System.out.println(Arrays.toString((int[]) list2.get(0)));

        int[] data = {1, 2, 3};
        List<int[]> list = Arrays.asList(data);
        System.out.println(Arrays.toString(list.get(0))); // [1, 2, 3]

源码如下：

public class Arrays {

     private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {

        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

        @Override
        public int size() {
            return a.length;
        }

        @Override
        public Object[] toArray() {
            return a.clone();
        }

        @Override
        @SuppressWarnings("unchecked")
        public <T> T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
                return Arrays.copyOf(this.a, size,
                                     (Class<? extends T[]>) a.getClass());
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

        @Override
        public E get(int index) {
            return a[index];
        }

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            if (o == null) {
                for (int i = 0; i < a.length; i++)
                    if (a[i] == null)
                        return i;
            } else {
                for (int i = 0; i < a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }

        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }

 

public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

}

2、实例

第一：工具类Collectons用于操作集合类，如list，set。常用方法如下

（1）、equals（比较两个数组是否相等，布尔型不能比较）

public class TestArrays { public static void main(String[] args) {
 int[] a = { 1, 2, 3};
 int[] b = { 1, 2, 3};
 int[] c = { 4, 5, 6};
 System.out.println(Arrays.equals(a, b));
 System.out.println(Arrays.equals(a, c));
 }
}
//结果：true
//     false

（2）、fill(Arrays list,Object o)（用对象0替换list中的所有元素）

public class TestArrays {

 public static void main(String[] args) {
       int[] arr = {1, 2, 3, 4};
       Arrays.fill(arr, 8);
       for (int i : arr) {
  System.out.print(i);
  }
 }

//运行结果：8888
 （3）、BinarySearch方法的使用（找到元素在数组中的下标）

public class TestArrays {
  public static void main(String[] args) {
  String[] str = {"a" ,"b" ,"c" ,"d" };
  int index=Arrays.binarySearch(str,"c");
  System.out.println(index);

        }

}

//运行结果：2

（4）、toString（Object[] o）方法的使用（将数组转为字符串进行输出）。

public class TestArrays {
  public static void main(String[] args) {
      int[] a1={1,2,3,4};
      System.out.println(Arrays.toString(a1));

    }

}

//运行结果：[1, 2, 3, 4]

（5）、copyOf（Object[] o,int i）方法的使用（将一个数组复制成一个新的数组)

public class TestArrays { public static void main(String[] args) {
  int[] arr={11,22,33,44};
  int[]arr2=Arrays.copyOf(arr,2);
  System.out.println(Arrays.toString(arr2));
      }

}

//运行结果：[11, 22]

（6）、sort方法的使用（对数组进行排序,默认按照升序排序）

public class TestArrays { public static void main(String[] args) {
  int[] arr = { 2, 3, 1, 4 };
  Arrays.sort(arr);
  for (int i : arr) {
  System.out.print(i);
  }
         }

}

//结果：1234

补充：经典算法之二分搜索技术
使用算法原因：为了提高开发效率，突然想到之前看到的一副动态图，动态图分为两部分，上部分是一条狗叼着一根木棍往门里冲，可木棍的长度长于门的宽度，导致狗始终无法通过门，而且狗还在一直横冲直撞。下部分同样是一条狗叼着一根木棍往门里冲，可当狗发现木棍的长度长于门的宽度的时候，狗进行了几秒的“思考”，然后把脖子一歪，木棍也随然斜了，正好能让狗通过门。动态图的标题是“不会算法的程序员和会算法的程序员的区别”。动态图很搞笑，可揭露的问题却很深刻。不会算法的程序猿只会蛮干一起，最后可能也无法实现目的，即时实现了也算是暴力实现，效率并不怎么高。

在没使用算法之前时间复杂度是O(N)，而在使用算法之后，时间复杂度就变成了O(logN)，大大节省了时间，提高了开发效率。

二分搜索使用的前提是搜索的数据是有序的，如：升序。当然如果数据是无序的我们也可以先利用冒泡算法将无序的数据变成有序的数据，然后再利用二分搜索法进行搜索。

二分搜索的思路：首先我们需要获取三个值，分别是第一个数据、最后一个数据、中间数据。然后我们需要进行数据的比较，先比较中间值是否等于我们的目标值，如果中间值大于我们的目标值，我们则将中间值做为最后一个数据，如果中间值小于我们的目标值，我们则将中间值做为第一个数据，这样就出现了一串新的有序的数据，然后再比较目标值是否等于第一值和最后一个值，就这样进行循环，直到在搜索数据中找到目标值。

如果查找成功，返回匹配的下标。如果查找的不成功，确定比查找项大的第一个项的位置，对该位置加1然后返回改值得相反数。不成功时返回值总是负的，因为它最大是-1，最小是-a.length-1。

public class TestBinarySearch {
  public static void main(String[] args) { 
  int[] arr = {1,2,3,4,5,6,7,8,9};
  System.out.println(binarySearch(arr,7));
  }
  public static int binarySearch(int[]arr,int k){
  int low = 0;
  int high = arr.length;
  int mid = 0;
  while(low < high){
  mid = (low + high) / 2;
  if(arr[mid] < k){
  low = mid + 1;
  }else{
  high = mid;
  }
  }
  if(arr[low] == k){
  return low;
  }
  return -(low+1);
  }
 }

Java基础类(五)：Arrays类