数组

数组

• 声明创建

• 数组的使用

• 多位数组

• Arrays类

• 稀疏数组（数据结构，压缩便于保存）

数组是存放相同类型数据的有序集合，按存入的先后次序排列组合而成

数组的声明&定义

• 声明语法：

通用java定义规则 变量类型 变量名 = 变量值

对于数组来说有两种声明方式，一种在变量类型后加中括号（推荐），一种在变量名后加中括号。

int[] a; (java推荐写法)

int a[]; (c/c++中写法)

只声明是不分配内存空间的

• 定义要通过new来赋值
  dataType[] arrayRefVar = new dataType[arraySize];
  int[] nums = new int[10]; //一次性分配10个地址空间，定义后数组大小不可改变

• 通过.length属性获取数组长度

• java内存分析
  

  

数组的三种初始化

1. 静态初始化

创建+赋值，如int[] a = {1,2,3,4,5,6,7,8}

2. 数组的默认初始化

数组是引用类型（除了基本数据类型都是引用），它的元素相当于类的实例变量。

数组一经分配空间，其中的每一个元素也被按照实例变量同样的方式被隐式初始化。

3. 动态初始化

先分配内存空间，然后再赋值
int[] a = new int[10];//空间中已经拥有int类型默认值0
a[0] = 3; ..

数组的四个基本特点

1. 一旦被创建，长度是固定的。下标[0,length-1], 越界报异常ArrayIndexOutofBounds

2. 数组可以是任意数据类型数组，基本数据类型或者某引用类型

3. 数组元素必须相同，不允许出现混合类型

4. 数组变量是引用类型，数组本身是对象，每个元素相当于该对象的成员变量。

   java中对象存储在堆中，即数组对象存储在堆中

数组的使用

1. 增强for循环适合输出数组里的每一个元素,没有下标

具体操作数组元素的要使用常规的for循环

for (int array : arrays) {
	System.out.println(array);
}

2. 应用：反转数组

public static int [] reverse(int[] arrays){

	int[] result = new int[arrays.length];
	//一个for循环可以定义多个变量
	for(int i = 0, j = result.length-1; i <  arrays.length-1; i++,j-- ){
	result[i] = arrays[j];
	}
	return result;
    
    //单循环
    /*for (int i = 0; i < result.length-1; i++){
        result[i]=array[result.length-1-i];
    }*/
}

多维数组

数组的数组就是多维数组，即数组里面每个元素存储的还是数组

对于二维数组来说，可以理解为一个一维数组里面每个元素仍然是个一维数组。

​ int a[] [] = new int[2] [5]; //第一维表示行，第二维表示列，此处是两行五列数组

//定义4行2列数组

int[] [] array = {{1,2},{2,3},{3,4},{4,5}}
for(int i = 0; i<array.length; i++){
      for(int j = 0; j < array[i].length; j++){
            System.out.println(array[i][j]);
      }
}

定义三维数组就是二维数组里面的元素有一个仍然是数组

int[] [] array = {{{1，9},2},{{2，9},3},{{3，9},4},{{4，9},5}}

实际中用的最多的是一二维数组，更对的是用对象多个属性表示。

Arrays 类

数组工具类java.util.Arrays

• 打印数组的元素 toString()

• 排序sort()

• 比较数组：equals()

• 查找数组元素：binarySearch()

冒泡排序

八大排序算法之一，两次循环，外层表示轮数，里层表示比较。嵌套算法复杂度O(n^2)

	/*冒泡排序
	  1.比较数组中两个元素，如果第一个比第二个数大，交换二者位置
	  2.第i轮比较都会得到第i小（大）的数
	  3.下一轮比较次数减1
	  4.依次循环直到结束
	  5.优化定义flag如果数组进来就是排好序的，没有产生比较就不需要进行下次循环了
	*/
public static int[] sort(int[]  array){

int len = array.length;
int temp = 0;
int flag=flase;
for(int i = 0; i<len-1; i++){
	for (int j = 0; j<len-1-i;j++){
		if(array[j] >array[j+1]){
			
			temp = array[j];
			array[j] = array[j+1];
			array[j+1] = temp;
			flag = true;
		}
	}
	if(flag = true){
	break;
	}
	
}
return array;
}

稀疏数组---数据结构

1. 应用场景
   需求：编写五子棋游戏，有存盘退出和续上盘的功能用数组存储。
   分析：因为该二维数组没下棋的地方有很多默认值为0，记录了没有意义的数据，可以使用稀疏数组来存盘
   
   当一个数组中大部分元素都是同一值时（如 0），就可以使用稀疏数组来保存该数组
2. 稀疏数组的处理方式
   • 记录数组一共有几行几列，有多少个不同值
   • 把具有不同值的元素和行列及值记录在一个小规模的数组中（记录坐标定位值），从而缩小程序的规模
     

  //1. 创建一个二维数组11*11 0:没有棋子 1：黑棋 2：白棋
	  int[] [] array1 = new int[11][11]
	  array[1][2] = 1;
	  array[2][3] = 2;
	System.out.println("输出原始数组")
	for(int[] ints : array1){
		for (int anInt : ints){
			System.out.print(anInt+ "\t");
		}
		System.out.println();
	}
	
	//转换为稀疏数组
	//1. 获取有效值的个数
	int sum = 0;
	for(int i =0; i < 11;i++){
		for (int j = 0; j < 11; j++){
	if(array1[i][j] !=0){
			sum++;
		 }
	}
	}
	
	//2.创建稀疏数组
	int[] [] array2 = new int[sum+1][3]
	
	array2[0][0] = 11;
	array2[0][1] = 11;
	array2[0][2] = sum;
	
	//3.遍历原来的二维数组，将原来的非0数存储到稀疏数组
	int index=1;
	for(int i =0; i < array.length;i++){
		for (int j = 0; j < array.length; j++){
		if(array1[i][j] !=0){
			array2[index++][0] = i;
		array2[index++][1] = j;
			array2[index++][2]=array1[i][j];
		 }
		}
	}
	
	//4.输出稀疏数组
	for(int i = 0; i< sum; i++){
		for (int j = 0;j < 3; j++){
			System.out.print(array2[i][j]+"\t");
	}
		System.out.println();
	}
	
	System.out.println("========还原========")
	
	//1.读取稀疏数组第一行创建原数组
	int[][]array3 = 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];
	}