一、一维数组
数组是一种固定大小，具有相同数据类型的数据结构。数组是多个相同类型数据的组合，数组变量是引用类型变量，数组中的元素可以是基本数据类型变量，也可以是引用类型变量，数组变量的数据类型与数组中元素的数据类型相同。
1.数组的定义
数据类型 数组名[ ];
数据类型[ ] 数组名;
注：数组声明的时候，[ ] 中不能写数据；数组只要创建成功，长度就不可以改变
声明数组举例：
int a[];
Student[] b;2.初始化数组
创建数组后，可以使用以下方法对数组进行初始化：
(1)静态初始化的一般形式：
数据类型[ ] 数组名 = new 数组类型[数组长度];
数据类型[ ] 数组名 = new 数组类型[ ]{数组元素列表};
数据类型[ ] 数组名 = {数组元素列表};
（左侧也可以采用数据类型 数组名[ ]的形式）
静态初始化举例：
int[] intArray = new int[5];
int[] intArray = new int[]{1,2,3,4,5};
int[] intArray = {1,2,3,4,5};(1)动态初始化的一般形式：
先声明，后初始化：
声明：
数据类型 数组名[ ];
数据类型[ ] 数组名;
初始化：
数组名 = 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;注：静态初始化与动态初始化的区别就在于，静态是声明的同时初始化，动态是先声明，再初始化
a = new int[5];
给a数组重新赋值，使用元素列表的形式创建数组，数组的长度由元素列表决定
并且创建成功后，数组中的元素为1，2，3，4，5，而之前的数组变成了垃圾
a = new int[]{1,2,3,4,5};3.访问数组元素
可以使用索引访问数组中的元素，索引从0开始，最大索引为数组长度减1。（注意数组越界）
int[] intArray = {1,2,3,4,5};
System.out.println(intArray[0]); //输出第一个元素：1
System.out.println(intArray[2]); //输出第三个元素：3
当索引访问数组元素时，需要确保索引的取值在合法范围内，（即大于等于0，且小于数组的长度）
如果索引超出了数组有效范围，就会抛出数组越界异常
System.out.println(intArray[5]); //抛出ArrayIndexOutOfBoundsException 异常4.获取数组长度
使用length属性获取数组长度，length为常量，该属性返回数组中元素的个数，数组创建后长度不
能改变。
int[] intArray = {1,2,3,4,5};
int length = intArray.length;
System.out.println(length); //输出数组长度：55.遍历数组
使用循环结构（如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);
}二、操作数组的常用方法
1.复制与替换方法
（1）copyOf(arr,int newLength)方法
静态方法，属于Java.util.Arrays类，有多种重载形式
参数说明：
arr:源数组（可以是多种类型）
newLength:int型常量，复制后新数组的长度
返回类型：arr数组类型
如果newLength大于数组arr的长度，用该类型的0值填充新数组
int[] arr1 = {1,2,3,4,5};
int[] arr2 = Arrays.copyOf(arr1,3); //复制到原始数组的前三个元素
//使用循环遍历打印数组元素
for(int i = 0;i<arr2.length;i++){
System.out.print(arr2[i]+" ");
}
System.out.println(); //换行
char[] charArr1 = {'a','b','c'};
char[] charArr2 = Arrays.copyOf(charArr1,5);//复制原始数组，并扩展新数组长度为5
//使用循环遍历打印数组元素
for(int i = 0;i<charArr2.length;i++){
System.out.print(charArr2[i]+" ");
}
System.out.println(); //换行输出结果
第一个循环中，打印了数组arr2的元素，即复制了原始数组arr1的前三个元素。
第二个循环中，打印了数组charArr2的元素，即复制了原始字符数组charArr1的所有元素，并在扩
展的位置使用了默认值。
（2）copyOfRange(arr,int from,int to)方法
静态方法，属于Java.util.Arrays类，有多种重载形式
参数说明：
arr:源数组
from:开始复制数组的索引位置（包括）
to:复制数组的最后位置索引（不包括）
返回类型：arr数组类型，复制时如果数组越界会抛出异常
int[] a = {1,2,3,4,5};
//数组复制copyOfRange
//第一个参数是要复制的数组，第二个参数是从哪个索引开始，第三个参数是到哪个索引
//结束，开始位置的数据要复制，结束位置的数据不复制
int[]c = Arrays.copyOfRange(a,1,4);
for (int i:c){
System.out.println(i+" ");
}
输出结果
通过使用copyOfRange()方法，可以复制数组的制定范围，从得到新的数组，并对新数组进行进一步的处理。
（3）arraycopy(Object src,int srcPos,Object dest,int destPos,int length)方法
静态方法，属于Java.util.Arrays类，有多种重载形式
参数说明：
src:源数组
srcPos:源数组中的起始位置（包括）
dest:目标数组
destPos:目标数组中的起始位置
length:复制的元素长度
返回类型：void,复制时如果数组超出范围会抛出异常。
int[] a = {1,2,3,4,5};
int[] b = {7,8,9,10,11};
int[] c = Arrays.copyOf(a,a.length+b.length);
//第一个参数是要复制的源数组，第二个参数是源数组中开始复制的位置索引
//第三个参数是要复制到的新数组，第四个参数是新数组中保存数据的位置索引
//第五个参数是复制多长的数据
System.arraycopy(b,0,c,5,b.length);
for (int i:c){
System.out.print(i+" ");
}
输出结果
(4)fill(arr,int value)方法
静态方法，属于Java.util.Arrays类，有多种重载形式
参数说明：
arr:要填充的数组，可以是多种类型
value:要存储在数组所有元素中的值
返回类型：void
int[] a = {1,2,3,4,5};
int[] c = Arrays.copyOf(a,a.length+b.length);
//数组填充，将数组中的元素全部赋值成一样的数据
Arrays.fill(c,5);
for (int i:c){
System.out.print(i+" ");
}
通过使用fill( )方法，可以快速地将数组的所有元素设置为特定的值。
2.排序方法
（1）冒泡排序
int[] a = {9,5,7,6,3,2,8,4,1};
for (int i = 0;i<a.length-1;i++){
for (int j = i+1;j<a.length;j++){
if (a[i]<a[j]){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
for(int i:a){
System.out.print(i+" ");
}输出结果
冒泡排序算法的核心思想是通过相邻元素之间的比较和交换来逐步将最大的元素移动到数组的末尾，通过多次遍历和比较，最终实现整个数组的排序。
（2）升序排序
sort(arr)方法
静态方法，属于Java.util.Arrays类，有多种重载形式
参数说明：
arr：要排序的数组，（可以是多种类型）
返回类型：void
int[] a = {9,5,7,6,3,2,8,4,1};
Arrays.sort(a);//升序排序
for(int i:a){
System.out.print(i+" ");
}输出结果
3.查找方法
binarySearch(arr,key)方法
使用二分搜索法来搜索指定数组，以获得指定的值的索引位置
注：使用前需要先排序，否则结果可能不准确
静态方法，属于Java.util.Arrays类，有多种重载形式
参数说明：
arr:要搜索的数组，可以是多种类型
key:搜索内容
返回类型：int 类型，如果搜索到，则返回key值的下标；
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
int ket = 6;
int index = Arrays.binarySearch(numbers,key);
if(index>=0){
System.out.println("元素"+key+"在数组中的索引位置为"+index);
}else{
System.out.println("元素"+key+"不在数组中");
}注：binarySearch()方法要求被搜索的数组必须是有序的，在使用binarySearch()方法之前，确保对数组进行了排序。
三、多维数组
1.二维数组的定义
二维数组：如果一个一维数组中的各元素仍然是一维数组，那么这个数组被称为二维数组。
（1）先声明，后初始化
声明：
数组类型 数组名[ ][ ]
数组类型[ ][ ] 数组名
初始化：
数组名 = new 数组类型[数组长度][数组长度]（一维长度必须指定，二维长度可以省略）
数组名 = new 数组类型[ ][ ]{数组元素列表}
数组名[下标] = new 数组类型[数组长度]
int[][] a;
a = new int[1][2];
int[][] b;
b = new int[3][];
b[0] = new int[] {1,2,3,4};
int[][] c;
c = new int[][] {{3,23.2,14},{1,2}};（2）声明同时初始化
数组类型[ ][ ] 数组名 = new 数组类型[数组长度][数组长度]；
数组类型[ ][ ] 数组名 = new 数组类型[ ][ ]{数组元素列表}；
数组类型[ ][ ] 数组名 = {数组元素列表}；
int d[][] = new int[3][];
int e[][] = new int[][]{{1,2,3},{4,5,6}};
int f[][] = {{1,2,3},{4},{5,6,7,8}};2.二维数组的遍历
int[][] a = {{1,2,3,4},{5},{6,7,8,9}};
//二维数组的遍历
for (int i = 0;i<a.length;i++){
for (int j = 0;j<a[i].length;j++){
//i表示第几个一维数组，j表示这个数组中的第几个元素
System.out.print(a[i][j]+" ");
}
System.out.println();
}输出结果
注：输出结果的格式与二维数组的结构对应，每一行的元素以空格分隔，每一行末尾换行。
也可以使用for-each循环遍历二维数组
int[][] a = {{1,2,3},{4},{5,6,7,8}};
//使用for-each循环遍历二维数组
for(int[] row:a){
for(int element:row){
System.out,print(element+" ");
}
System.out,println( );
}
扫一扫
776
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
