数组可以存放 多个 同一类型 的数据，是引用类型

一般使用方式

先定义并声明

int[] arr = new int[5];
// 默认为值数据类型的值

行可以先声明 再分配空间

double[] arr2;
arr2 = new double[10];  // 分配内存空间  可以存放数据
// 若是没有分配中间直接使用 会报错 错误: 可能尚未初始化变量

也可以静态初始化

double[] weight = {55, 73, 55, 83, 55, 83,77, 53,80};

注意：double[] arr可以写成double arr[]

完整例子：

public class Array{
     public static void main(String[] args) {
        /*
        创建一个char类型的26个元素的数组，分别放置'A'-'Z'。使用for循环访问 所有元素并打印出来
        */
        char[] chars = new char[26];
        for (char i = 'A'; i <='Z'; i++){
            chars[i-'A'] = i;
        }
        // 使用增强for
        for (char i:chars){
            System.out.println(i);
        }
        /*
        请求出一个数组int[]的最大值{4，-1,9,10,23}，并得到对应的下标
        */
        int[] arr4 = {4, -1, 9 ,10 , 23};
        int arr4Max = arr4[0];
        int arr4MaxIndex = 0;

        for (int i = 1; i < arr4.length; i++) {
            if (arr4Max < arr4[i]){
                arr4Max = arr4[i];
                arr4MaxIndex = i;
            }
        }
        System.out.println(arr4Max);
        System.out.println(arr4MaxIndex);
        /**
        请求出一个数组的和 和 平均值
        */
        int[] arr5 = {1,2,34,5,6,7,8,9,2,234,5};
        int sum = 0;
        for (int i=0; i<arr5.length; i++) {
            sum += arr5[i];
        }
         System.out.println("和为" + sum + " 平均数为 " + sum/arr5.length);
     }
}

使用细节

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
3. 数组创建后，如果没有赋值，有默认值
   int 0 short 0 byte 0 long 0 float 0.0 double 0.0 char \u0000 boolean false String null
4. 使用数组的步骤
   • 声明数组并开辟空间
   • 给数组各个元素赋值
   • 使用数组
5. 数组的下标是从0开始的
6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如 int[]arr=new int[5];则有效下标为0-4
7. 数组属引用类型，数组型数据是对象(object)

引用类型和值类型

java的基础数据类型都是值类型（byte short int long float double char boolean）
而类 接口 数组是引用数据类型
引用类型和值类型在内存中的存储方式是不一样的，这也导致了操作上的区别

一些数组操作

这里记录一些常用的数组操作，有自己实现的, 也有使用java.util.Arrays类的

数组拷贝

即将一个数组在堆中重新创建一份

nt[] arr1= {1,2,3,4,5,6,7,8,9,10};
 int[] arr2= new int[arr1.length];
 // 赋值
 for (int i = 0; i < arr1.length; i++) {
	 arr2[i] = arr1[i];
 }

对应的Arrays工具类方法

type[] copyOf(type[] original, int length)

这个方法将会把original数组复制成一个新数组，其中 length 是新数组的长度。
如果 length 小于 original 数组的长度，则新数组就是原数组的前面 length 个元素，
如果 length 大于 original 数组的长度，则新数组的前面元索就是原数组的所有元素，
后面补充 0（数值类型）、false（布尔类型）或者 null（引用类型）。

type[] copyOfRange(type[] original, int from, int to)

这个方法与前面方法相似，但这个方法只复制 original 数组的 from 索引到 to 索引的元素。

数组反转

int[] arr = {12,123,92,2,10,384,12};
int start = 0;
int end = arr.length - 1;
while (start < end) {
	arr[start] ^= arr[end];
	arr[end] ^= arr[start];
	arr[start] ^= arr[end];
	start++;
	end--;
}

排序

void sort(type[] a)

该方法对 a 数组的数组元素进行排序

void sort(type[] a, int fromIndex, int toIndex)

该方法与前一个方法相似，区别是该方法仅仅对 fromIndex 到 toIndex 索引的元素进行排序

批量赋值

void fill(type[] a, type val)

该方法将会把 a 数组的所有元素都赋值为 val

void fill(type[] a, int fromIndex, int toIndex, type val)

该方法与前一个方法的作用相同，区别只是该方法仅仅将 a 数组的 fromIndex 到 toIndex 索引的数组元素赋值为 val

查询

int binarySearch(type[] a, type key)

使用二分法查询 key 元素值在 a 数组中出现的索引，如果 a 数组不包含 key 元素值，则返回负数。
调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果

int binarySearch(type[] a, int fromIndex, int toIndex, type key)

这个方法与前一个方法类似，但它只搜索 a 数组中 fromIndex 到 toIndex 索引的元素。
调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果

数组是否相等

boolean equals(type[] a, type[] a2)

如果 a 数组和 a2 数组的长度相等，而且 a 数组和 a2 数组的数组元素也一一相同，该方法将返回 true

转成字符串

String toString(type[] a)

该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。

deepToString可以转多维数组

二维数组

一个数组的元素为一个数组，则为二维数组。
二维数据在内存中：

 public class Array{
     public static void main(String[] args) {
        int[][] arr10 = {{1,2,3}, {123,21,12}, {12,3,4}};
        // 初始化
        int[][] arr11 = new int[3][2]; // {{1,2}, {2,3}, {3,4}}
        // 声明 再 初始化
        int[][] arr12;
        arr12 = new int[2][3];
        
        // 动态列数： {{1}, {1,2}, {1,2,3}}
        int[][] arr13 = new int[3][]; // !! 空着就行
        for (int i = 0; i < arr13.length; i++) {
            // 动态开辟空间
            arr13[i] = new int[i + 1];
            for (int j = 0; j < arr13[i].length; j++) {
                arr13[i][j] = j + 1;
            }
        }
     }
}