数组
存储一堆数据得集合,这一堆数据的数据类型是一致的
语法:
数据类型 [] 数组名称 = new 数据类型[长度]; 显式数组
数据类型 [] 数组名称 = {值1,值2,值3......}; 隐式数组
隐式数组的长度根据初始化定义时的值的数量来决定
//数组名:arr 数据类型:int 数组长度:5
//显式数组
int [] arr = new int[5];
//隐式数组
int [] arr ={1,2,3,4,5};
规则:
-
数组的数据类型: 数据类型 [] 数据类型可以是基本数据类型(byte short int long float double char boolean), 引用数据类型, String类型
-
长度: 数组能储存多少个相同类型的数据,长度一旦确定,则无法变更,否则报错
-
在数组中,位置按照下标的定义来进行存储
-
如果数组的下标值超过了数组初始定义的长度,则出现错误,异常: ArrayIndexOutOfBoundsException 数组下标越界
注:
数组的下标是从0开始的,也就是说第一个数据的下标是0,之后的数据的下标都是数组中实际位置减1;
获取元素值:
数组的数据类型 数组元素值 = 数组名称[下标值];
语法:
获取数组长度: int i = 数组名称.length;
//获取数组arr的长度
int i = arr.length;
System.out.println("数组的长度为:"+i);
使用循环遍历数组
for(int i = 0; i < arr.length;i ++){
System.out.println(arr[i]);
}
数组工具类:
快速打印: String str = new Arrays.toString(数组名称);
快速排序(升序): Arrays.sort(数组名称);
数组填充:Arrays.fill(数组名称,覆盖的值);
//数组名:arr 数据类型:int 数组长度:5
int [] arr ={1,2,3,4,5};
Arrays.sort(arr);
//升序排列
for (int i = 0; i <arr.length; i++) {
System.out.println(arr[i]);
}
//降序排列
for (int i =arr.length-1; i >=0; i--) {
System.out.println(arr[i]);
}
//快速打印
System.out.println(Arrays.toString(arr));
//把数组内的所有内容替换成0
Arrays.fill(arr,0);
System.out.println(Arrays.toString(arr));
//把数组内的2-4替换为0 2是起始位置,4是终止位置的下标,0是覆盖的值
Arrays.fill(arr,2,4,0);
System.out.println(Arrays.toString(arr));
二维数组
二维数组是特殊的一维数组,其每一个元素都是一个一维数组
语法:
数据类型 [] [] 数组名 = [长度] [长度];
第一个长度决定了总数组的长度,及包括了多少小数组
第二个长度决定了小数组的长度,及包括了多少的数据
/*
* 第一行存了1,2
* 第二行存了2,3
* 第三行存了3,3
* 第四行存了4,4
* 第五行存了5,5
* */
int [][] arr = {{1,2},{2,3},{6,3},{4,4},{5,5}};
//第一个数组的值1的下标是(0,0)/值2的下标为(0,1)
//第二个数组的值2的下标的(1,0)/值3的下标为(1,1)
冒泡排序
冒泡排序是最为出名的一种排序算法
比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置
每一次比较,都会产生出一个最大,或者最小的数字
下一轮则可以少一次排序!
依次循环,直到结束!
public static void main(String[] args) {
//冒泡排序
int [] a = {1,34,656,788,21,75,34,23};
int[] sort = sort(a);//调用完我们排序方法后,返回一个排好序的数组
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int [] arr){
//临时变量
int temp = 0;
//外层循环,判断我们要走多少次
for (int i = 0; i < arr.length; i++) {
boolean flag = false; //通过flag标识符减少没有意义的比较
//内层循环 比较判断两个数,如果第一个数比第二个数大,则交换位置
for (int j = 0; j < arr.length -1-i; j++) {
//当前为降序排序,如果要更改为升序,只需要把下面的'>'更改为'<'
if ( arr[j+1] > arr[j]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = true;
}
}
if (flag == false){
break;
}
}
return arr;
}
稀疏数组
稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组
public static void main(String[] args) {
//1. 创建一个二维数组 11*11 0:没有棋子 1:黑棋 2:白棋
int [][] arr= new int [11][11];
arr[1][2] = 1;
arr[2][3] = 2;
arr[3][4] = 3;
//输出原始的数组
System.out.println("输出原始的数组");
for ( int [] ints: arr ) {
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 (arr[i][j] != 0){
sum++;
}
}
}
System.out.println("有效值个数为:"+sum);
//2. 创建一个稀疏数组
int [][] array = new int [sum+1][3];
array[0][0] = 11;
array[0][1] = 11;
array[0][2] = sum;
//遍历二维数组, 将非零的值, 存放稀疏数组中
int count = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
if (arr[i][j] != 0){
count++;
array[count][0] = i;
array[count][1] = j;
array[count][2] = arr[i][j];
}
}
}
//输出稀疏数组
System.out.println("稀疏数组");
for (int i = 0; i < array.length; i++) {
System.out.println(array[i][0]+"\t"
+array[i][1]+"\t"
+array[i][2]+"\t");
}
System.out.println("==================================");
System.out.println("还原");
//1. 读取稀疏数组的值
int [][] arrayx = new int[array[0][0]][array[0][1]];
//2. 给其中的元素还原它的值
for (int i = 1; i < array.length; i++) {
arrayx[array[i][0]][array[i][1]] = array[i][2];
}
//3/ 打印
System.out.println("输出还原的数组");
for ( int [] ints: arr ) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println( );
}
}