数组的定义
数组是相同类型数据的有序集合。
声明创建:
首先必须声明数组变量,才能在程序中使用数组。变量类型(int[])变量名(任意)=变量值;
如:int[] nums=new int[10];
使用new来创建数组。
int[] nums;//1.声明一个数组
nums=new int[10];//2.创建一片空间,创建一个数组
//3.给数组元素赋值
nums[0]=1;
nums[1]=2;
nums[2]=3;
System.out.println(nums[9]);
//计算所有元素的和
int sum=0;
for (int i = 0; i < nums.length; i++) {
sum=sum+nums[i];
}
System.out.println(sum);
内存分析
自定义类对象运行时需要在堆中动态分配 栈存放的是对象的引用指向堆或常量池中的对象实例
![](https://i-blog.csdnimg.cn/blog_migrate/0906e7a6d573e127785d41d0b251a319.png)
报错异常为:数组下标越界
数组初始化
//静态初始化
int[] a={1,2,3,4,5};
//动态初始化
int[] b=new int[10];
b[0]=1;
数组的基本特点
长度确定,数组一旦被创建,它的大小不可以改变
元素必须是相同类型
数组的元素可以是任何数据类型,包括基本类型和引用类型
数组变量属引用类型,数组也可看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
数组使用
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
// for (int array : arrays) {
// 增强型的for循环,后面代表数组,前面的变量代表数组里的每个元素,但没有下标
// System.out.println(array);
// }
// printarry(arrays);
printarry(reverse(arrays));//54321
}
//打印数组元素
public static void printarry(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
}
//反转数组
public static int[] reverse(int[] arrays) {
int[] result = new int[arrays.length];
for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}
多维数组
//4行2列
/*
1,2
2,3
3,4
4,5
*/
int[][] array={{1,2},{2,3},{3,4},{4,5}};
System.out.println(array[0][0]);
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]);
}
System.out.println();
}
Arrays类
数组的工具类
由于数组对象本身没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本操作。
int[] a={1,2,3,4,100,23,45};
//打印数组元素Arrays.toString
Arrays.sort(a);//排序
System.out.println(Arrays.toString(a));
//Arrays.fill(a,0);//填充,将特定值分配给每个元素
System.out.println(Arrays.toString(a));
Arrays.fill(a,2,5,0);
System.out.println(Arrays.toString(a));
冒泡排序
两层循环,外层冒泡轮数,里层依次比较。
//冒泡排序
/*
比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置;
每一次比较,都会产生一个最大或最小的数字;
下一轮可以少一次排序;
依次循环,直到结束;
*/
int[] a={2,6,4,9,5};
int temp =0;
for (int i = 0; i < a.length-1; i++) {
boolean flag=false;//优化:通过flag标识位减少没有意义的比较(本来就有序)
for (int j = 0; j < a.length-1-i; j++) {
//内层循环-i:每一轮外层循环都产生一个最大或最小的数,下一轮就不用再对它们进行循环,当然,不-i对结果也没有影响
if (a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
flag=true;
}
}
if (flag==false){
break;
}
}
System.out.println(Arrays.toString(a));
稀疏数组
数组中有大部分0或为同一值时,可以使用稀疏数组来保存。
记录数组一共有几行几列,有多少给不同值。
把具有不同值的元素和行列及值记录在一个小规模的数组中。
package array;
public class Demo07 {
public static void main(String[] args) {
//创建一个二维数组11*11 0:没有棋子,1:黑棋,2:白棋
int[][] a=new int[11][11];
a[1][2]=1;
a[2][3]=2;
System.out.println("输出原始数组");
//二维数组双重嵌套,第一个for取每行,第二个for取每列,一维数组用一个for就可以了
for(int[] i:a){
for(int j:i){
System.out.print(j+"\t");
}
System.out.println();
}
//转换为稀疏数组
//获取有效值的个数
System.out.println("======================");
int sum=0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (a[i][j]!=0){
sum++;
}
}
}
System.out.println("有效值个数"+sum);
//创建一个稀疏数组
int[][] b=new int[sum+1][3];
b[0][0]=11;
b[0][1]=11;
b[0][2]=sum;
//遍历二维数组,将非零的值,存放稀疏数组中
int count=0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if (a[i][j]!=0){
count++;
b[count][0]=i;
b[count][1]=j;
b[count][2]=a[i][j];
}
}
}
//输出稀疏数组
for (int i = 0; i < b.length; i++) {
System.out.println(b[i][0]+"\t"
+b[i][1]+"\t"
+b[i][2]+"\t");
}
System.out.println("======================");
//还原
//读取稀疏数组
int[][] c=new int[b[0][0]][b[0][1]];
//给其中的元素还原值
for (int i = 1; i < b.length; i++) {
c[b[i][0]][b[i][1]]=b[i][2];
}
for(int[] i:a){
for(int j:i){
System.out.print(j+"\t");
}
System.out.println();
}
}
}
//这两个增强for可以用前几次学的栈和堆来理解,
// 假如这边的二维数组是a[2][3],
// 那么在堆中显示的是a[0]-{0,0,0},a[1]-{0,0,0},
// 再根据这个来理解两个增强for
![](https://i-blog.csdnimg.cn/blog_migrate/a8c1a89ab224ff0d9e9532ac1ccbfb22.png)