数组的定义
数组是相同类型数据的有序集合。
每个数组元素通过下标来进行访问
数组的创建
首先必须声明数组变量
类型[] 变量名;
或
类型 变量名[];
数组的元素通过索引访问,索引从0开始。
内存分析
- 堆:存放new的对象和数组,可以被所有的线程共享,不会存别的对象引用
- 栈:存放基本变量类型(会包含这个基本类型的具体数值)
引用对象的变量(会存放这个引用在堆里面的具体地址)
-方法区:可以被所有的线程共享,包含了所有的class和static变量
数组的特点
- 长度确定,一旦创建,大小不可以改变
- 元素类型必须相同
- 数组中的元素可以是任何数据类型,包括基本类型和引用类型。
- 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。
- 数组本身就是对象,java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
小结
- 数组是相同数据类型(数据类型可以为任意类型)的有序集合
- 数组也是对象。数组元素相当于对象的成员变量
- 数组长度是确定的,不可变的。—越界异常:ArrayIndexOutOfBounds
//反转数组
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;
}
//打印数组元素
public static void printArray(int[] arrays){
for(int i = 0;i < arrays.length;i++){
System.out.print(arrays[i] + " ");
}
}
}
二维数组
int a[] [] = new int [2][5];
arrays 类
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而“不用”使用对象来调用
具备以下常用功能:
- 给数组赋值:通过fill方法。
- 对数组排序:通过sort方法,按升序。
- 比较数组:通过equals方法比较数组中元素值是否相等。
- 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。
冒泡排序
1、比较数组中,两个相邻的元素,如果第一个比第二个打,交换位置
2、每一次比较,都会产生一个最大或最小的数字;
3、下一轮则可以少一次排序
4、一次循环,直到结束
public static int[] sort(int[] array){
//外层循环,判断要走多少次
for(int i = 0; i < array.length-1; i++){
//内层循环,比较两个数,当第一个大于第二个时,交换位置
for(int j = 0;j < array.length-1;j++){
if(array[j+1]>array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
return array;
}
稀疏数组
public static void main(String[] args){
//1、创建一个二维数组11*11 0:没有棋子。 1:黑棋 2:白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始数组
System.out.println("输出原始的数组");
for(int[] ints :array1){
for(int anInt : ints){
System.out.print(anInt + "\t");
}
System.out.println();
}
//转换为稀疏数组保存
//获取有效值的个数
int sum =0;
for(int i = 0;i < 11;i++){
for(int j = 0; j< 11;j++){
if(array1[i][j]!=0){
sum++;
}
}
}
System.out.println("有效值的个数:"+sum);
//2、创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组,将非零的值,存放稀疏数组中
int count = 0;
for(int i =0;i < array1.length;i++){
for(int j = 0; j < array1[i].length; j++){
if(array[i][j]!=0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//输出稀疏数组
for(int i = 0; i < array2.length;i++){
System.out.println(array2[i][0]+"\t"
+array2[i][1]+"\t"
+array2[i][2]+"\t");
}
//还原数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//给其中的元素还原值
for(int i =1; i < array2.length;i++){
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//输出还原的数组
for(int[] ints:array3){
for(int anInt : ints){
System.out.print(anInt+"\t");
}
}