学习时间

2020-12-17

学习内容

Arrays类的概述

Arrays类是针对数组进行操作的工具类。
提供了排序，查找等功能。

Arrays类的成员方法

public static String toString(int[] a)  					返回指定数组内容的字符串表示形式。
public static void sort(int[] a)     						对指定的 int 型数组按数字升序进行排序。
public static void sort(float[] a, int fromIndex, int toIndex) 
      	对指定 float 型数组的指定范围按数字升序进行排序。
public static int binarySearch(int[] a,int key) 			使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
static boolean equals(int[] a, int[] a2) 					比较两个数组中的元素，是否一样
static int[] copyOf(int[] original, int newLength)  
		复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
static int[] copyOfRange(int[] original, int from, int to) 
		复制旧数组中的指定范围间的几个元素到新数组中

演示：

import java.util.Arrays;

public class Test2 {
  public static void main(String[] args) {
    int[] arr1 = {1, 2, 3, 4};
    int[] arr2 = {1, 2, 3, 4, 5};
    int[] arr3 = {12, 3, 3, 5, 2, 5, 34, 645, 34, 7};
    int[] arr4 = {4, 3, 2, 1};
    int[] arr5 = {12, 3, 3, 5, 2, 5, 34, 645, 34, 7};
    System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]
    Arrays.sort(arr4);
    System.out.println(Arrays.toString(arr4));//[1, 2, 3, 4]
    Arrays.sort(arr3, 0, 4);
    System.out.println(Arrays.toString(arr3));//[3, 3, 5, 12, 2, 5, 34, 645, 34]
    Arrays.sort(arr5);
    System.out.println(Arrays.toString(arr5));
    System.out.println(Arrays.binarySearch(arr5, 7));//5
  }
}

---

介绍

在java.util中有一个Arrays类，此类包含用于操纵数组的各种方法，例如：二分查找（binarySearch）、拷贝操作（copyOf）、比较(equals)、填充(fill)、排序（sort）等，功能十分强大。

随便写一下Collections 工具类的讲解

Arrays工具类常见方法

1.binarySearch

代码：

public static void main(String[] args) {
    int dataA[] = new int[] {1,2,5,4,3};
    System.out.println(Arrays.binarySearch(dataA,5));
}

输出：2

2.toString

代码:

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

输出：[1, 2, 5, 4, 3]

3.copyOf

代码：

public static void main(String[] args) {
    int []dataA = new int[] {1,2,5,4,3};
    int []dataB = Arrays.copyOf(dataA, 3);
    System.out.println(Arrays.toString(dataB));
}

输出[1, 2, 5]

4.equals

代码：

public static void main(String[] args) {
    int []dataA = new int[] {1,2,5,4,3};
    int []dataB = new int[] {1,2,5,4,3};
    int []dataC = new int[] {1,2,3};
    System.out.println(dataA.equals(dataB));
    System.out.println(Arrays.equals(dataA,dataB));
    System.out.println(Arrays.equals(dataA,dataC));
}

输出：

false
true
false

5.fill

代码：

public static void main(String[] args) {
    int []dataA = new int[] {1,2,5,4,3};
    Arrays.fill(dataA, -1);
    System.out.println(Arrays.toString(dataA));
}

输出：

[-1, -1, -1, -1, -1]

6.sort

代码：

public static void main(String[] args) {
    int []dataA = new int[] {1,3,5,4,-1};
    Arrays.sort(dataA);
    System.out.println(Arrays.toString(dataA));
}

输出：

[-1, 1, 3, 4, 5]

7.asList()

// *************转列表 asList()****************
/*
* 返回由指定数组支持的固定大小的列表。
* （将返回的列表更改为“写入数组”。）该方法作为基于数组和基于集合的API之间的桥梁，与	Collection.toArray()相结合 。
* 返回的列表是可序列化的，并实现RandomAccess 。
* 此方法还提供了一种方便的方式来创建一个初始化为包含几个元素的固定大小的列表如下：
*/
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
System.out.println(stooges);		

JDK 源码对于这个方法的说明：

/**
 *返回由指定数组支持的固定大小的列表。此方法作为基于数组和基于集合的API之间的桥梁，与           Collection.toArray()结合使用。返回的List是可序列化并实现RandomAccess接口。
 */ 
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

7.1《阿里巴巴Java 开发手册》对其的描述

Arrays.asList()将数组转换为集合后,底层其实还是数组，《阿里巴巴Java 开发手册》对于这个方法有如下描述：

也就是说我们在使用的时候不能进行add、remove、clear等方法

7.2使用时的注意事项总结

传递的数组必须是对象数组，而不是基本类型。

Arrays.asList()是泛型方法，传入的对象必须是对象数组。

int[] myArray = { 1, 2, 3 };
List myList = Arrays.asList(myArray);
System.out.println(myList.size());//1
System.out.println(myList.get(0));//数组地址值，即把myArray当成一个元素
System.out.println(myList.get(1));//报错：ArrayIndexOutOfBoundsException
int [] array=(int[]) myList.get(0);
System.out.println(array[0]);//1

当传入一个原生数据类型数组时，Arrays.asList() 的真正得到的参数就不是数组中的元素，而是数组对象本身！此时List 的唯一元素就是这个数组，这也就解释了上面的代码。

我们使用包装类型数组就可以解决这个问题。

Integer[] myArray = { 1, 2, 3 };

使用集合的修改方法: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 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。

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

下图是java.util.Arrays$ArrayList的简易源码，我们可以看到这个类重写的方法有哪些。

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

        @Override
        public E get(int index) {
          ...
        }

        @Override
        public E set(int index, E element) {
          ...
        }

        @Override
        public int indexOf(Object o) {
          ...
        }

        @Override
        public boolean contains(Object o) {
           ...
        }

        @Override
        public void forEach(Consumer<? super E> action) {
          ...
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
          ...
        }

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

我们再看一下java.util.AbstractList的remove()方法，这样我们就明白为啥会抛出UnsupportedOperationException。

public E remove(int index) {
    throw new UnsupportedOperationException();
}

7.3如何正确的将数组转换为ArrayList?

1. 自己动手实现（教育目的）

//JDK1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}
Integer [] myArray = { 1, 2, 3 };
System.out.println(arrayToList(myArray).getClass());//class java.util.ArrayList

2. 最简便的方法(推荐)

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());

4. 使用 Apache Commons Collections

List<String> list = new ArrayList<String>();
CollectionUtils.addAll(list, str);

Collections 工具类常用方法

1.排序操作

void reverse(List list)//反转
void shuffle(List list)//随机排序
void sort(List list)//按自然排序的升序排序
void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
void swap(List list, int i , int j)//交换两个索引位置的元素
void rotate(List list, int distance)//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。

示例代码:

 ArrayList<Integer> arrayList = new ArrayList<Integer>();
		arrayList.add(-1);
		arrayList.add(3);
		arrayList.add(3);
		arrayList.add(-5);
		arrayList.add(7);
		arrayList.add(4);
		arrayList.add(-9);
		arrayList.add(-7);
		System.out.println("原始数组:");
		System.out.println(arrayList);
		// void reverse(List list)：反转
		Collections.reverse(arrayList);
		System.out.println("Collections.reverse(arrayList):");
		System.out.println(arrayList);


		Collections.rotate(arrayList, 4);
		System.out.println("Collections.rotate(arrayList, 4):");
		System.out.println(arrayList);

		// void sort(List list),按自然排序的升序排序
		Collections.sort(arrayList);
		System.out.println("Collections.sort(arrayList):");
		System.out.println(arrayList);

		// void shuffle(List list),随机排序
		Collections.shuffle(arrayList);
		System.out.println("Collections.shuffle(arrayList):");
		System.out.println(arrayList);

		// void swap(List list, int i , int j),交换两个索引位置的元素
		Collections.swap(arrayList, 2, 5);
		System.out.println("Collections.swap(arrayList, 2, 5):");
		System.out.println(arrayList);

		// 定制排序的用法
		Collections.sort(arrayList, new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				return o2.compareTo(o1);
			}
		});
		System.out.println("定制排序后：");
		System.out.println(arrayList);

2.查找,替换操作

int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的
int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。
int frequency(Collection c, Object o)//统计元素出现次数
int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).
boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素

示例代码：

ArrayList<Integer> arrayList = new ArrayList<Integer>();
		arrayList.add(-1);
		arrayList.add(3);
		arrayList.add(3);
		arrayList.add(-5);
		arrayList.add(7);
		arrayList.add(4);
		arrayList.add(-9);
		arrayList.add(-7);
		ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
		arrayList2.add(-3);
		arrayList2.add(-5);
		arrayList2.add(7);
		System.out.println("原始数组:");
		System.out.println(arrayList);

		System.out.println("Collections.max(arrayList):");
		System.out.println(Collections.max(arrayList));

		System.out.println("Collections.min(arrayList):");
		System.out.println(Collections.min(arrayList));

		System.out.println("Collections.replaceAll(arrayList, 3, -3):");
		Collections.replaceAll(arrayList, 3, -3);
		System.out.println(arrayList);

		System.out.println("Collections.frequency(arrayList, -3):");
		System.out.println(Collections.frequency(arrayList, -3));

		System.out.println("Collections.indexOfSubList(arrayList, arrayList2):");
		System.out.println(Collections.indexOfSubList(arrayList, arrayList2));

		System.out.println("Collections.binarySearch(arrayList, 7):");
		// 对List进行二分查找，返回索引，List必须是有序的
		Collections.sort(arrayList);
		System.out.println(Collections.binarySearch(arrayList, 7));

3.Collection.toArray()方法使用的坑&如何反转数组

该方法是一个泛型方法：T[] toArray(T[] a); 如果toArray方法中没有传递任何参数的话返回的是Object类型数组。

String [] s= new String[]{
    "dog", "lazy", "a", "over", "jumps", "fox", "brown", "quick", "A"
};
List<String> list = Arrays.asList(s);
Collections.reverse(list);
s=list.toArray(new String[0]);//没有指定类型的话会报错

由于JVM优化，new String[0]作为Collection.toArray()方法的参数现在使用更好，new String[0]就是起一个模板的作用，指定了返回数组的类型，0是为了节省空间，因为它只是为了说明返回的类型。详见：https://shipilev.net/blog/2016/arrays-wisdom-ancients/

总结

Arrays功能比较多，上面列举出一些，如果还想知道一些其他的功能可以自行翻阅文档。Arrays平时刷题的时候可以适当使用，节约自己写代码的时间。

1.Arrays类

• Arrays位于java.util包下(Arrays是一个操作数组的工具类)
• Arrays包含各种操作数组的方法(例如排序和搜索)。该类还包含一个静态工厂，允许将数组视为列表。
• Arrays类里的方法都是静态方法可以通过Arrays.方法名()直接调用

2.Arrays常用方法

(1) asList(T… a):主要用于遍历

 List<String> list = Arrays.asList("a","b","c");

• 该方法适用于对象型数据的数组（String、Integer…）
• 该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）
• 该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新
• 不支持add()、remove()、clear()等方法
  

运行效果:

(2) fill()

给定特定值val，使整个数组中或者某下标范围内的元素值为val。

代码实例:

import java.util.Arrays;
public class ArraysTest04
{
	public static void main(String[] args)
	{
		int[] a = new int[7];
		int[] b = new int[7];
		Arrays.fill(a,3);
		Arrays.fill(b,3,5,6);
		
		for(int i = 0;i<a.length;i++)
		{
			System.out.print(a[i]+",");
		}
		System.out.print("\n");
		for(int i = 0;i<b.length;i++)
		{
			System.out.print(b[i]+",");
		}
		System.out.print("\n");
	}
}

运行效果:

(3) copyOf() && copyOfRange()

• copyOf()：将原始数组的元素，复制到新的数组中，可以设置复制的长度（即需要被复制的元素个数）。
  

• copyOfRange()：将某个范围内的元素复制到新的数组中。
  

代码实例:

import java.util.Arrays;
public class ArraysTest03
{
	public static void main(String[] args)
	{
		int[] a = {1,3,5,3,6,7};
		int[] b;
		int[] c;
		int[] d;
		System.out.println("-----------原始数组---------");
		for(int i = 0;i<a.length;i++)
		{
			System.out.print(a[i]+",");
		}
		System.out.print("\n");
		
		b = Arrays.copyOf(a,7);//将a数组的内容复制到b数组中，如果新的数组长度大于原来数组的长度，那么用0来填充
		c = Arrays.copyOf(a,3);
		d = Arrays.copyOfRange(a,2,4);
		System.out.println("-----------复制数组---------");
		for(int i = 0;i<b.length;i++)
		{
			System.out.print(b[i]+",");
		}
		System.out.print("\n");
		
		
		for(int i = 0;i<c.length;i++)
		{
			System.out.print(c[i]+",");
		}
		System.out.print("\n");
		
		for(int i = 0;i<d.length;i++)
		{
			System.out.print(d[i]+",");
		}
		System.out.print("\n");
		
	}
}

运行效果:

(4) equals()

判断两个数组中的元素是否一一对应相等。

代码实例:

import java.util.Arrays;
public class ArraaysTest05
{
public static void main(String[] args)
{
	int[] a = new int[]{1,2,3};
	int[] b = null;
	int[] c = new int[]{};
	int[] d = new int[]{1,2,3};
	
	System.out.println(Arrays.equals(a,b));
	System.out.println(Arrays.equals(a,c));
	System.out.println(Arrays.equals(a,d));
	System.out.println(Arrays.equals(b,c));
	System.out.println(Arrays.equals(b,d));
	System.out.println(Arrays.equals(c,d));
}
}

运行效果:

(5) sort()

对数组进行升序排序，排序后 ，数组中存放的是排序后的结果。

代码实例:

import java.util.Arrays;
public class ArraysTest05
{
public static void main(String[] args)
{
	int[] a ={34,56,23,565,23,-56};
	
	Arrays.sort(a);
	
	for(int i = 0;i<a.length;i++)
	{
		System.out.print(a[i]+",");
	}
	System.out.print("\n");
}
}

运行效果:

(6) binarySearch()

对排序好的数组，采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

代码实例:

import java.util.Arrays;

public class ArraysTest02
{
	public static void main(String[] args)
	{
		int[] a = {1,45,78,23,123,98,67,12,90,56};
		
		System.out.println("-----------原始数组---------");
		for(int i = 0;i<a.length;i++)
		{
			System.out.print(a[i]+",");
		}
		System.out.print("\n");
		
		
		Arrays.sort(a);
		System.out.println("-----------排序后数组---------");
		for(int i = 0;i<a.length;i++)
		{
			System.out.print(a[i]+",");
		}
		System.out.print("\n");
		System.out.print("在整个数组中寻找：");
		System.out.println(Arrays.binarySearch(a,78));
		System.out.print("在局部范围内寻找：");
		System.out.println(Arrays.binarySearch(a,4,7,1));
		
	}
}

运行效果：

本篇博客主要对Java Arrays工具类用法详解进行学习!