Java基础类(五)：Arrays类

目录

1、Arrays

1.1、Arrays.sort()

1.2、Arrays.binarySearch()

1.3、Arrays.equals()（比较两个数组是否相等，布尔型不能比较）

1.4、Arrays.fill()

1.5、Arrays.copy of()

1.6、Arrays.asList()

1.7、Arrays.toString()

---

1、Arrays

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

• sort - 排序
• binarySearch - 查找
• equals - 比较
• fill - 填充
• hash - 哈希
• asList - 转列表
• toString - 转字符串

1.1、Arrays.sort()

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

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

1.2、Arrays.binarySearch()

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

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

1.3、Arrays.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

1.4、Arrays.fill()

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

fill(Arrays list,Object o)（用对象o替换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

1.5、Arrays.copy of()

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

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

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]

1.6、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);
    }

}

1.7、Arrays.toString()

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]