Arrays类的自我详解01_arrays生物-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_48810566/article/details/109209844

Arrays类的自我详解

以下以整型为例：

copyOf

public static int[] copyOf(int[] original,
                           int newLength)

复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含0 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。

参数

original - 要复制的数组

newLength - 要返回的副本的长度
结果

原始数组的副本，被截断或用零填充以获得指定的长度

异常

NegativeArraySizeException - 如果 newLength为负数

NullPointerException - 如果 original为空
```
import java.util.Arrays;
public class ArraysTest {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8};
        int[] array1 = Arrays.copyOf(array,4);
        int[] array2 = Arrays.copyOf(array,10);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}
```
结果：
```
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4]
[1, 2, 3, 4, 5, 6, 7, 8, 0, 0]
```
copyOfRange
```
public static int[] copyOfRange(int[] original,
                                int from,
                                int to)
```
将指定数组的指定范围复制到新数组中。范围（ from ）的初始指数必须在零和original.length之间，包括在内。 original[from]的值被放置在副本的初始元素中（除非from == original.length或from == to ）。原始数组中后续元素的值将被放置在副本中的后续元素中。必须大于或等于from的范围（ to ）的最终指数可能大于original.length ，在这种情况下0被放置在其索引大于或等于original.length - from的副本的所有元素中。返回的数组的长度将为to - from 。
- 参数
  
  original - 要从中复制范围的数组
  
  from - 要复制的范围的初始索引（包括）
  
  to - 要复制的范围的最终索引，排他。（该索引可能位于数组之外）
- 结果
  
  一个包含原始数组的指定范围的新数组，用零截取或填充以获得所需的长度
- 异常
  
  ArrayIndexOutOfBoundsException - 如果 from < 0或 from > original.length
  
  IllegalArgumentException - 如果 from > to
  
  NullPointerException - 如果 original为空

 int[] array3 = Arrays.copyOfRange(array,4,6);

equals

public static boolean equals(int[] a,
                             int[] a2)

如果两个指定的int数组彼此相等，则返回true 。如果两个数组都包含相同数量的元素，则两个数组被认为是相等的，并且两个数组中所有对应的元素对都相等。换句话说，如果两个数组以相同的顺序包含相同的元素，则它们是相等的。另外，如果两个数组引用都是null，则它们被认为是相等的 。

参数

a - 要测试相等的一个数组

a2 - 要测试的其他数组是否相等
结果

true如果两个数组相等

boolean flg = Arrays.equals(array,array1);
        System.out.println(flg);

fill

public static void fill(int[] a,
                        int val)

将指定的int值分配给指定的int数组的每个元素。

参数

a - 要填充的数组

val - 要存储在数组的所有元素中的值
```
  Arrays.fill(a,8);
```
fill
```
public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)
```
将指定的int值分配给指定的int数组的指定范围的每个元素。要填充的范围从索引fromIndex扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要填充的范围是空的。）
- 参数
  
  a - 要填充的数组
  
  fromIndex - 要用指定值填充的第一个元素（包括）的索引
  
  toIndex - 要用指定值填充的最后一个元素（排除）的索引
  
  val - 要存储在数组的所有元素中的值
- 异常
  
  IllegalArgumentException - 如果是 fromIndex > toIndex
  
  ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length

 int ret = Arrays.hashCode(array);
        System.out.println(ret);

hashCode

根据指定数组的内容返回哈希码。对于任何两个非空的int阵列a和b等Arrays.equals(a, b) ，也是Arrays.hashCode(a) == Arrays.hashCode(b)的情况。

通过此方法返回的值是将通过调用能够得到相同的值hashCode上的方法List含有序列Integer个实例表示的a以相同顺序的元素。如果a为null ，则此方法返回0。

参数

a - 要计算的哈希值的数组
结果

一个基于内容的散列码为 a

int ret = Arrays.hashCode(array);
System.out.println(ret);

sort

public static void sort(int[] a)

按照数字顺序排列指定的数组。

实施注意事项：排序算法是由Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch提供的双轴快速排序。该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单轴）Quicksort实现更快。

参数

a - 要排序的数组

sort

public static void sort(int[] a,
                        int fromIndex,
                        int toIndex)

按升序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex ，排他。如果fromIndex == toIndex ，要排序的范围是空的。

参数

a - 要排序的数组

fromIndex - 要排序的第一个元素（ fromIndex ）的索引

toIndex - 最后一个要排序的元素的索引
异常

IllegalArgumentException - 如果是 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0或 toIndex > a.length