java—数组的定义与使用
数组的基本概念:
数组指的就是一组相关变量的集合。
² 声明并开辟数组：数据类型 数组名称[]=new 数据类型[长度];
² 分布完成：
l 声明数组：数据类型 数组名称[] = null;
l 开辟数组：数组名称 = new 数组类型[长度];
当数组开辟空间之后，那么可以采用“数组名称[下标|索引]”的形式进行访问，但是所有数组的下标都是从零开始的，即：如果是3个长度的数组，那么下标的范围是0~2，一共是三个内容。如果访问的时候超过了数组的允许下标长度，那么会出现数组越界的异常信息，ArrayIndexOutOfBoundsException
以上给出的数组定义结构使用的是动态初始化的方式，即：数组会首先开辟内存空间，但是其数组中的内容都是其对应数据类型的默认值。
由于数组是一种顺序的结构，并且数组的长度都是固定的，那么可以使用循环的方式输出数组里的内容，而且在Java里面为了方便数组的输出提供有一个“数组名称.length”的属性，可以取得数组的长度。
数组麻烦之处在于，它也属于引用数据类型，所以以上的代码依然需要牵扯到内存分配，与对象保存的区别在于：对象中的堆内存保存的是属性，而数组中的堆内存保存的是一组信息。
既然数组属于引用数据类型，那么数组一定可以发生引用传递（不同栈内存，不同地址，指向同一堆内存）。
|
public class ArrayDemo {
public static void main(String[] args) { int[] data = new int[3];//声明并开辟一个长度为3的数组 data[0]=10; data[1]=20; data[2]=30; int[] temp = data; //data为地址，意为将data的地址赋给temp数组 temp[2]=50; for(int i=0;i<data.length;i++){ System.out.println(data[i]); } }
}
|
以上数组的定义格式严格来说是属于动态初始化，它的操作特点：先开辟好数组空间，再进行赋值。还有静态初始化的操作，即：数组定义的同时就设置好了相应的数据内容。
l 格式一：数据类型 数组名称[]= {值，值，值……}；
l 格式二：数据类型 数组名称[]= new int[]{值，值，值………}；
|
public class ArrayDemo {
public static void main(String[] args) { int[] data = new int[]{1,2,3,4,5,6}; for(int i=0;i<data.length;i++){ System.out.println(data[i]); } } }
|
二维数组：
二维数组就是后面有两个“[]”,一维数组严格来讲就是一行，类似于如下的形式：
|
索引 |
0 |
1 |
2 |
3 |
4 |
5 |
|
数据 |
10 |
20 |
30 |
40 |
50 |
60 |
如果在一维数组里面找到一个数据,只需要确定一个索引就够了.
二维数组就是一张数据表,有行有列,类似于:
|
索引 |
0 |
1 |
2 |
3 |
4 |
5 |
|
0 |
12 |
89 |
03 |
98 |
45 |
89 |
|
1 |
52 |
56 |
13 |
56 |
23 |
46 |
|
2 |
23 |
28 |
34 |
23 |
48 |
66 |
二维数组则需要行和列同时定位,例如数字13:行1列2,[1][2].
二维数组定义语法如下:
l 动态初始化:数据类型[][] 数组名称 = new 数据类型[行数][列数];
l 静态初始化:
数据类型[][] 数字名称 = new 数据类型[][]{{值,值},{值,值}};
|
package MianXiangDuiXiang;
public class Arraydemo1 { public static void main(String args[]){ /*int[][] arr = new int[][]{ {1,2,3}, {4,5,6}, {7,8,9} };*/ //外层循环控制行 for(int i=1;i<=9;i++){ //内层循环控制列 for(int j=1;j<=10-i;j++){ System.out.print(i+"*"+j+"="+(i*j)+"\t"); } System.out.println(); } } } |
数组与方法参数的传递(难点):
|
public class arrayDemo { public static void change(int temp[]){ for(int i=0;i<temp.length;i++){ temp[i]*=2; //原数组乘2并保存 } } } public static void main(String args[]){ int[] data = new int[]{2,3,6}; change(data); for(int j=0;j<data.length;j++){ System.out.println(data[j]); } } }
|
|
public class arrayDemo { public static void main(String args[]){ int[] data = new int[]{2,3,6}; int[] temp = data; //数据传递 for(int i=0;i<temp.length;i++){ temp[i]*=2; //原数组乘2并保存 } for(int j=0;j<temp.length;j++){ System.out.println(temp[j]); } } }
|
上面两种程序结果一致，实现方法不一样，第二种使用引用传递的方法实现。
在进行数组的引用传递的过程当中，方法对数组的修改会影响数据的原始数据，
Eg:数组的排序：
冒泡排序基本原理：
² 原始数据： 2,1,9,0,5,3,7,6,8
² 第一次排序：1,2,0,5,3,7,6,8,9
² 第二次排序：1,0,2,3,5,6,7,8,9
² 第三次排序：0,1,2,3,5,6,7,8,9.
|
public class arrayDemo { public static void print(int temp[]){ for(int x=0;x<temp.length;x++){ System.out.print(temp[x]+"、"); } System.out.println(); } public static void sort(int[] arr){ //外层循环控制循环次数 for(int i=0;i<arr.length;i++){ for(int j=0;j<arr.length-1;j++){ if(arr[j]>arr[j+1]){ int q = arr[j]; arr[j]= arr[j+1]; arr[j+1]=q; } } } } public static void main(String args[]){ int[] data = new int[]{2,1,9,0,5,3,7,6,8}; print(data); sort(data); print(data); } }
|
Eg:数组的转置：
转置的概念：
² 原始数组: 1,2,3,4,5,6,7,8,
² 转置后的数组: 8,7,6,5,4,3,2,1.
操作有两个思路:
l 重新定义一个新的数组,而后将原始数组按照倒序的方式插入到新的数组当中,随后改变原始数组的引用.
|
import java.util.Arrays;
public class Reverse { public void reverse(int[] arr){ int i = arr.length; //创建新的数组接收原数组的倒序插入 int[] arr1 = new int[i]; int b=0; for(int a=arr.length-1;a>=0;a--){ arr1[b]=arr[a]; b++; } System.out.println(Arrays.toString(arr1)+"\t"); }
public static void main(String[] args) { int[] data={1,2,3,4,5,6,7,8}; Reverse re = new Reverse(); re.reverse(data); }
} |