Java数组（上）

一维数组

数组是一种固定大小的、具有相同数据类型的数据结构。数组是多个相同类型数据的组合，数组变量是引用类型变量，数组中的元素可以是基本数据类型变量，也可以是引用类型变量，数组变量的数据类型与数组中元素的数据类型相同。

数组的定义

数据类型 数组名[];

数据类型[] 数组名;

说明：“[]”表示声明的数据类型是数组，声明时“[]”中不能写入长度.

例如：
int[] a;
float b [];
String s[];

数组声明时下标不能指定长度，以下是错误的案例

int e[6];
double[5] f

 初始化数组

创建数组后，可以使用以下两种方法对数组进行初始化：

静态初始化：在声明的同时进行初始化。

动态初始化：先声明再进行初始化

静态初始化的一般形式：

数据类型[] 数组名 = new 数组类型[数组长度];

数据类型[] 数组名= new 数组类型[]{数组元素表列};

数据类型[] 数组名 = {数组元素表列};

（左侧也可以采用数据类型 数组名[]的形式，数组名和[]的位置可以互换）

在声明数组时，可以直接指定元素的初始值。以下是一个初始化的例子：

int[] intArray = new int[5];
int[] intArray = new int[]{1, 2, 3, 4, 5};
int[] intArray = {1, 2, 3, 4, 5}
String [] s=new String[5];

 在上述例子中第一个只是声明一个长度为5的数组，初始值:0,0,0,0,0

                        第二个第三个都为intArray指定元素的初始值:1,2,3,4,5；

前3个都是基本数据类型数组，第4个是引用数据类型数组,在仅声明s是一个长度为5的数组时，其初始值:null;null;null;null;null;

动态初始化的一般形式：

声明：

数据类型 数组名[];

数据类型[] 数组名;

初始化：

数组名 = new 数组类型[数组长度]

数组名 = new 数组类型[]{数组元素表列}

在声明数组后，可以逐个为数组元素赋值。

以下是一个动态初始化的例子

int[] intArray = new int[5];
intArray = new int[]{1, 2, 3, 4, 5};
intArray[0] = 1;
intArray[1] = 2;
intArray[2] = 3;
intArray[3] = 4;
intArray[4] = 5;

我们在对数组进行初始化之后可以使用索引访问数组中的元素。索引从 0 开始，最大索引为数组长度减 1。以下是如何访问数组元素的示例：

int[] intArray = {1, 2, 3, 4, 5}; 
System.out.println(intArray[0]); // 输出第一个元素：1 
System.out.println(intArray[2]); // 输出第三个元素：3

 我们可以使用 length 属性获取数组的长度，该属性返回数组中元素的个数，length 为常量， 数组创建后长度不能改变

数组越界问题

在Java中，数组越界问题指的是程序在访问数组元素时访问了超出数组边界的索引位置。数组的索引是从0开始的，而数组的长度是从1开始计算的。当程序试图访问数组的索引小于0或大于等于数组长度时，就会发生数组越界问题。

数组越界问题会导致程序抛出ArrayIndexOutOfBoundsException（数组索引越界异常）。这是一个运行时异常，如果不处理它，程序将会终止并输出异常信息。

public class ArrayOutOfBoundsExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        // 访问数组索引为3的元素，正常情况
        System.out.println("numbers[3] = " + numbers[3]);

        // 访问数组索引为5的元素，超出了数组边界
        System.out.println("numbers[5] = " + numbers[5]);
    }
}
 

在上面的代码中，我们定义了一个长度为5的整数数组numbers，然后分别尝试访问索引为3和索引为5的元素。输出结果如下：

numbers[3] = 4
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at ArrayOutOfBoundsExample.main(ArrayOutOfBoundsExample.java:9)
 

可以看到，第一个访问是正常的，输出了数组元素的值；第二个访问超出了数组边界，导致抛出了ArrayIndexOutOfBoundsException异常。

为了避免数组越界问题，我们应该始终确保访问数组时的索引值在合法范围内。

遍历数组

遍历数组 可以使用循环结构（如 for 循环）遍历数组中的所有元素。以下是如何遍历数组的示例：

int[] intArray = {1, 2, 3, 4, 5};
for (int i = 0; i < intArray.length; i++) {
System.out.println(intArray[i]);
}

也可以使用 for-each 循环遍历数，示例：

for (int i :intArray) {
System.out.println(i);
}

操作数组的常用方法

复制与替换方法

数组复制copyof方法

第一个参数是要复制的数组，第二个参数是新数组的长度

如果新数组的长度大于原数组的长度，用该类型的 0 值填充新数组。

数组复制copyofRange方法

第一个参数是要复制的数组，第二个参数是从那个索引开始，第三个参数是到哪个索引结束，开始位置的数据要复制，结束位置的数据不复制

import java.util.Arrays;

public class ArrayTest03 {
    public static void main(String[] args) {
        // 初始化数组a，包含5个元素
        int[] a = {1, 2, 3, 4, 5};
        
        // 使用Arrays.copyOf方法复制数组a，创建一个新数组b，长度为10
        // 如果原数组长度小于新数组长度，则新数组中剩余的元素将被初始化为0
        int[] b = Arrays.copyOf(a, 10);
        
        // 使用Arrays.copyOfRange方法复制数组a的一个子数组，创建一个新数组c
        // 从索引1开始，到索引4结束（不包括索引4），即复制a[1]到a[3]
        int[] c = Arrays.copyOfRange(a, 1, 4);
        
        // 遍历数组b，并打印每个元素
        for (int i : b) {
            System.out.print(i + " ");
        }
        
        // 打印一个换行符，用于分隔输出结果
        System.out.println();
        
        // 遍历数组c，并打印每个元素
        for (int i : c) {
            System.out.print(i + " ");
        }
    }
}

 结果：

 arraycopy方法

第一个参数是要复制的源数组，第二个参数是源数组中开始复制的位置索引第三个参数是要复制到的新数组，第四个参数是新数组中保存数据的位置索引第五个参数是复制多长对的数据

fill方法

数组填充，将数组中的元素全部赋值成一样的数据

import java.util.Arrays;

public class ArrayTest04 {
    public static void main(String[] args) {
        // 初始化数组a，包含5个元素
        int[] a = {1, 2, 3, 4, 5};
        // 初始化数组b，包含5个元素
        int[] b = {7, 8, 9, 10, 11};
        
        // 创建一个新数组c，长度是数组a和数组b长度之和
        // 使用Arrays.copyOf复制数组a到新数组c
        int[] c = Arrays.copyOf(a, a.length + b.length);
        
        // 使用System.arraycopy方法将数组b的内容复制到数组c
        // 从数组b的索引0开始，复制到数组c的索引5开始的位置，复制长度为b.length
        System.arraycopy(b, 0, c, 5, b.length);
        
        // 遍历数组c，并打印每个元素
        for (int i : c) {
            System.out.print(i + " ");
        }
        // 打印一个换行符，用于分隔输出结果
        System.out.println();
        
        // 使用Arrays.fill方法将数组c的所有元素设置为5
        Arrays.fill(c, 5);
        
        // 再次遍历数组c，并打印每个元素
        // 此时所有元素都应该是5
        for (int i : c) {
            System.out.print(i + " ");
        }
    }
}

结果：

排序方法

升序排序法：Arrays.sort(a);

二分查找法：Arrays.binarySearch（使用前必须进行升序排序，否则结果不准确）

import java.util.Arrays;
public class ArrayTest05 {
    public static void main(String[] args) {
        int a[]={1,3,9,5,6,7,1,5,4,8};
//        升序排序法
       Arrays.sort(a);
//       二分查找法，使用前必须进行升序排序，否则结果不准确
        int x=Arrays.binarySearch(a,5);
        System.out.println(x);
        for (int i:a){
            System.out.print(i+" ");
        }
    }
}