数组是同一种类型数据的集合，其实就是一个容器。
那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素,数组可以装任意单一固定类型的数据。即是数组一旦定义，那么里边存储的数据类型也就确定了。

数组的特点

在Java中，无论使用数组或集合，都有边界检查。
如果越界操作就会得到一个RuntimeException异常。
数组只能保存特定类型。数组可以保存原生数据类型，集合则不能。
集合不以具体的类型来处理对象，它们将所有对象都按Object类型处理，集合中存放的是对象的引用而不是对象本身。
集合类只能保存对象的引用。而数组既可以创建为直接保存原生数据类型，也可以保存对象的引用。
在集合中可以使用包装类（Wrapper Class），如Integer、Double等来实现保存原生数据类型值。
对象数组和原生数据类型数组在使用上几乎是相同的；
唯一的区别是对象数组保存的是引用，原生数据类型数组保存原生数据类型的值。

一、数组的基本使用

1、声明数组变量

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar;   // 首选的方法

或

dataType arrayRefVar[];  // 效果相同，但不是首选方法

注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。
dataType arrayRefVar[] 风格是来自 C/C++ 语言，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

实例

下面是这两种语法的代码示例：

double[] myList;         // 首选的方法

或

double myList[];         //  效果相同，但不是首选方法

2、创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

使用 dataType[arraySize] 创建了一个数组。
把新创建的数组的引用赋值给变量 arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

//方式一
dataType[] arrayRefVar = new dataType[arraySize];

另外，你还可以使用如下的方式创建数组。

//方式二
dataType[] arrayRefVar = {value0, value1, ..., valuek};

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

实例

下面的语句首先声明了一个数组变量 myList，接着创建了一个包含 10 个 double 类型元素的数组，并且把它的引用赋值给 myList 变量。

TestArray.java 文件代码：

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

以上实例输出结果为：

总和为： 11367.373

创建数组的三种方式及区别

public static void main(String[] args) {  
    // 1.方式一  声明 分配空间并赋值  
    int[] arr1 = {1,2,3};  
    // 2.方式二 显示初始化  
    int[] arr2;  
    arr2 = new int[]{1,2,3};   
    // 3.方式三 显示初始化()  
    int[] arr3;  
    arr3 = new int[3];  
}

他们的区别，

方式一：在声明的时候直接就已经分配空间，并赋值，方式一是不能写成如下这种形式的。

int[] arr1;  
arr1 = {1,2,3};//错误写法 编译不同过

方式二和方式三,声明和内存分配是分开的，如上面的例子，
int[] arr2; 和 int[] arr3;
这一步是在栈空间分配一个引用，存放的是一个引用，null
arr2 = new int[]{1,2,3};arr3 = new int[3];
到这一步的时候jvm才开始在内存堆区域分配空间，并赋值，
方式二直接赋值 1,2,3 方式三默认初始化，基本类型是 0 布尔类型是 false 引用类型为null，

注意：内存一旦分配不能改变，所有说数组长度固定

数组初始化注意事项

方式一：不使用运算符new

int[]arr = { 1, 2, 3, 4, 5 };

方式二：使用运算符new

int[] arr2 = new int[] { 1, 2, 3, 4, 5 };
int[] arr3=new int[3];
arr3[0]=1;
arr3[1]=5;
arr3[2]=6;

如果数组初始化中不使用运算符new。需要注意：下列写法是错误的。

int[] arr;
arr={1,2,3,4,5};

此时初始化数组，必须将声明，创建，初始化都放在一条语句中个，分开会产生语法错误。

所以只能如下写：

int[] arr={1,2,3,4,5};

二、数据的常用操作

1、数组的遍历

public static void main(String[] args) {
	int[] x = { 1, 2, 3 };
	for (int y = 0; y < x.length; y++) {
		System.out.println(x[y]);
	} 
}

2、数组的复制

java.lang.System
 
public static void arraycopy(Object src,  int srcPos, Object dest,  int destPos,  int length)

参数详解如下：

src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。

3、一个数组取出最大值

 /*定义一个获取最大值的功能：
1、确定结果 ：返回值类型 int
2、未知内容：要获取哪个数组的最大值没有确定，则是数组没有确定
 
思路：
1、定义一个变量，记录住数组的比较大的元素。
2、遍历整个数组，让数组的每一个元素都和该变量进行对比即可。
3、当变量遇到比它大的元素，则让该变量记录该元素的值，当循环结束时，最大   值产生了
*/
public static int getMax(int[] arr)
{
//定义变量记录较大的值，初始化为数组中的任意一个元素。
int max = arr[0];
for(int x=1; x<arr.length; x++)
{
if(arr[x]>max)
max = arr[x];
}
return max;
}

4、排序

1、直接排序

原理：
以父for循环一个角标的元素和子for循环元素进行比较。在内循环第一次结束，最值出现的头角标位置上。

 /*
 选择排序
*/
 public static void main(String[] args) {
        int[] arr = {9, 6, 7, 1};
        for (int x = 0; x < arr.length - 1; x++) {
            //每一次比较,都用x角标上的元素和下一个元素进行比较
            for (int y = x + 1; y < arr.length; y++) {
                if (arr[x] > arr[y]) {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

输出结果如下：

[1, 6, 7, 9]

2、冒泡排序

原理：相邻两个元素进行比较。如果满足条件就进行位置置换。

/*
冒泡排序。
*/
public static void main(String[] args) {
        int[] arr = {9, 6, 7, 1};
        for(int x = 0; x <arr.length-1; x++) {
            for(int y = 0; y < arr.length-x-1; y++) {
                if(arr[y] > arr[y+1]) {
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

输出结果如下：

[1, 6, 7, 9]

3、折半查找（二分法）

为了提高查找效率，可使用折半查找的方式，注意：这种查找只对有序的数组有效。

//二分法
public class test1 {
    public static int halfSeach(int[] arr,int key){
        int min = 0;
        int max = arr.length - 1;
        int mid = (max + min)/2;
        while(arr[mid] != key) {
            if(key > arr[mid]) {
                min = mid + 1;
            }else if(key < arr[mid]) {
                max = mid - 1;
            }if(min > max) {
                return -1;
            }
            mid = (max+min)/2;
        }
        return mid;
    }
    public static void main(String[] args) {
        int key = 7;
        int[] arr = {9, 6, 7, 1};
        int halfSeachresult =  halfSeach(arr, key);

        System.out.println(halfSeachresult);
    }
}

输出结果如下：

4、数组翻转

public class test1 {
    public static void swap(int[] arr,int a,int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    public static void main(String[] args) {
        int key = 6;
        int[] arr = {9, 6, 7, 1};
        for(int start = 0,end = arr.length- 1; start < end; start++,end--) {
            swap(arr,start,end);
        }
        System.out.println(Arrays.toString(arr));
    }
}

输出结果如下：

[1, 7, 6, 9]

三、For-Each 循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

语法格式如下：

for(type element: array)
{
    System.out.println(element);
}

实例

该实例用来显示数组 myList 中的所有元素：

TestArray.java 文件代码：

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

以上实例编译运行结果如下：

1.9
2.9
3.4
3.5

四、java.util.Arrays

Arrays类是一个非常有用数组工具类，里面有很多工具方法，检索、填充、排序、比较、toString()等。

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

常用调用制表

用处	说明
赋值	public static int binarySearch(Object[] a, Object key) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
排序	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
比较	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
查找	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。注意：数组在调用前必须排序好的。

综合举例：

import java.util.Arrays; 

//数组综合测试 
public class TestArrays { 
        public static void main(String[] args) { 
                int[] i = new int[10]; 
                //填充数组 
                Arrays.fill(i, 2); 
                //遍历数组 
                for (int x : i) { 
                        System.out.print(x + " "); 
                } 
                //toString()数组 
                System.out.println("\n" + Arrays.toString(i)); 
                //复制数组 
                int[] b = new int[12]; 
                System.arraycopy(i, 0, b, 2, 5); 
                System.out.println(Arrays.toString(b)); 
                //一维数组的比较 
                int[] c = new int[3]; 
                int[] d = new int[3]; 
                Arrays.fill(c, 3); 
                Arrays.fill(d, 3); 
                System.out.println(c.equals(d)); 
                System.out.println(Arrays.equals(c, d)); 
                System.out.println("-------------"); 
                int[][] a1 = {{1, 2, 3}, {4, 5, 6}}; 
                int[][] a2 = {{1, 2, 3}, {4, 5, 6}}; 
                System.out.println(a1.equals(a2)); 
                System.out.println(Arrays.equals(a1, a2)); 
                System.out.println(Arrays.deepEquals(a1, a2)); 
                //深度toString() 
                System.out.println(Arrays.toString(a1)); 
                System.out.println(Arrays.deepToString(a1)); 

                //数组的排序 
                int[] a3 = {3, 2, 5, 4, 1}; 
                System.out.println(Arrays.toString(a3)); 
                Arrays.sort(a3); 
                System.out.println(Arrays.toString(a3)); 
                //一维数组数值检索 
                int index1 = Arrays.binarySearch(a3, 4); 
                int index2 = Arrays.binarySearch(a3, -12); 
                int index3 = Arrays.binarySearch(a3, 8); 
                System.out.println(index1 + " " + index2 + " " + index3); 
        } 
}

执行结果：

2 2 2 2 2 2 2 2 2 2    
[2, 2, 2, 2, 2, 2, 2, 2, 2, 2] 
[0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0] 
false 
true 
------------- 
false 
false 
true 
[[I@3e25a5, [I@19821f] 
[[1, 2, 3], [4, 5, 6]] 
[3, 2, 5, 4, 1] 
[1, 2, 3, 4, 5] 
3 -1 -6

五、数组的常见异常

1、数组角标越界异常ArrayIndexOutOfBoundsException

java.lang.ArrayIndexOutOfBoundsException

注意：数组的角标从0开始。

2、空指针异常NullPointerException

java.lang.NullPointerException

六、ArrayListList与数组相互转换

①List转换成为数组。

调用ArrayList的toArray方法。

public <T> T[] toArray(T[] a)

指定者：
接口 Collection 中的 toArray

指定者：
接口 List 中的 toArray

覆盖：
类 AbstractCollection 中的 toArray

参数：
a - 要存储列表元素的数组，如果它足够大的话；否则，它是一个为存储列表元素而分配的、具有相同运行时类型的新数组。

返回：
包含列表元素的数组。

抛出：
ArrayStoreException - 如果 a 的运行时类型不是此列表中每个元素的运行时类型的超类型。

具体用法：

List list = new ArrayList();
list.add("1");
list.add("2");
final int size =　list.size();
String[] arr = (String[])list.toArray(new String[size]);

②数组转换成为List。

调用Arrays的asList方法.

public static <T> List<T> asList(T... a)

此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素：

List stooges = Arrays.asList("Larry", "Moe", "Curly");

参数：
a - 支持列表的数组。

返回：
指定数组的列表视图。

另请参见：
Collection.toArray()

具体用法:

String[] arr = new String[] {"1", "2"};
List list = Arrays.asList(arr);

原文链接：https://blog.csdn.net/weixin_41714868/article/details/122637694