1. 数组概述

数组是相同类型数据的有序集合，长度固定，同一数组元素必须是同一类型。

public class ArrayDemo{
    
	//变量类型 变量名 = 变量值；
	//在IDEA中，psvm即可打出来
	public static void main(String[] args){
    
		int[] nums;//声明一个数组
		//int nums[];//也可
		nums = new int[10];//初始化，创建数组，可以存放10个int类型的数据
		//int[] nums = new int[10]
		//给数组元素赋值
		nums[0]=1;
		nums[1]=2;
		nums[2]=3;
		nums[3]=4;
		nums[4]=5;
		nums[5]=6;
		nums[6]=7;
		nums[7]=8;
		nums[8]=9;
		nums[9]=10;
		//取值
		System.out.println(nums[0]);
		//打印数组元素
		for (int i=0; i<nums.length; i++){
    
			System.out.println(nums[i]);
		}
		for (int array: arrays){
    
			System.out.println(array);
		}
		//计算所有元素的和
		int sum = 0;
		for (int i=0; i<nums.length; i++){
    
			sum = sum + nums[i];
		}
		System.out.println("总和为" + sum);
	}
}

2. 三种初始化及内存分析

初始化过程：现在栈中声明，然后在堆中创建。

静态初始化、动态初始化、默认初始化：

public class ArrayDemo{
    
	//变量类型 变量名 = 变量值；
	public static void main(String[] args){
    
		//静态初始化：创建+赋值
		int[] a = {
    1, 2, 3, 4, 5};
		
		//动态初始化：默认初始化为空或0
		int[] b = new int[10];
		b[0] = 10;
	}
}

3. 数组的使用

public class ArrayDemo{
    
	public static void main(String[] args){
    
		int[] arrays = {
    1,2,3,4,5};

		//查找最大元素
		int max = arrays[0];
		for (int i=0; i<arrays.length; i++){
    
			if (arrays[i]>max){
    
				max = arrays[i];
			}
		}
		System.out.println("sum=" + sum);

		int[] reverse = reverse(arrays);
		printArray(reverse);
	}

	//反转数组
	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.println(arrays[i]+" ");
		}
	}
}

4. 二维数组

public class ArrayDemo{
    
	public static void main(String[] args){
    
		//3行2列的数组
		int[][] array = {
    {
    1,2},{
    3,4},{
    5,6}};
		printArray(array)
	}

	//打印数组元素
	public static void printArray(int[] arrays){
    
		for (int i=0; i<arrays.length; i++){
    
			System.out.print(arrays[i]+" ");
		}
	}
}

5. Arrays类

import java.utils.Arrays
public class ArrayDemo{
    
	public static void main(String[] args){
    
		int[] a = {
    1,2,3,4,121,2331,121,12,2};
		System.out.println(a);//[I@4554617c

		//打印数组元素Arrays.roString
		System.out.println(Arrays.toString(a))；
		Arrays.sort(a); //对数组进行排序：升序
		Arrays.fill(a,val:0);//将a数组填充为0
	}

	public static void printArray(int[] a){
    
		for (int i=0; i<a.length; i++){
    
			if (i==0){
    
				System.out.print("[");
			}
			if (i==a.length-1){
    
				System.out.print(a[i]+"]");
			}else{
    
				System.out.print(a[i]+",");
			}
		}
	}
}

6. 冒泡排序

public class Demo(){
    
	public static void main(String[] args){
    
		int[] array = {
    1,2,5,7,3,4};
		BubbleSort(array);
	}

	public static void BubbleSort(int[] array){
    
		boolean flag = false;
		int tmp = 0;
		for (int i=0; i<array.length-1; i++){
    
			for (int j=0; j<array.length-1; j++){
    
				//降序
				if (array[j+1]>array[j]){
    
					tmp = array[j];
					array[j] = array[j+1];
					array[j+1] = tmp;
					flag = true;
				}
			}
			if (flag==false){
    
				break;
			}
		}
	}
}

7. 稀疏数组

当一个数组大部分元素为0或者为同一个值时，可以使用稀疏数组来保存该数组。如图所示：

public class ArrayDemo{
    
	public static void main(String[] args){
    
		//创建一个二维数组11*11 0:没有棋子 1:黑棋 2:白棋
		int[][] array1 = new int[11][11];
		array1[1][2] = 1;
		array2[2][3] = 2;
		//输出原始数组
		System.out.println("输出原始的数组");
		
		for (int[] ints: array1){
    
			for (int anInt: ints){
    
				System.out.println(anInt+"\t");
			}
			System.out.println();
		}
		//转换成稀疏数组来保存
		//获取有效值的个数
		int sum = 0;
		for (int i=0; i<11; i++){
    
			for (int j=0; j<11; j++){
    
				if (array[i][j]!=0){
    
					sum++;
				}
			}
		}
		System.out.println("有效值的个数："+sum);
		//创建一个新的数组
		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<array.length; i++){
    
			for (int i=0; i<array[i].length; j++){
    
				if (array[i][j]!=0){
    
					count++;
					array2[count][0] = i;
					array2[count][1] = j;
					array2[count][2] = array[i][j];
				}
			}
		}
		//输出稀疏数组
		System.out.println("稀疏数组");
		for (int i=0; i<array2.length; i++){
    
			System.out.println(array2[i][0]+"\t"
					+array2[i][1]+"\t"
					+array2[i][2]+"\t");
		}
		System.out.println("还原");
		//读取稀疏数组
		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];
		}
		//打印还原后的数组
		System.out.println("还原后的数组");
		for (int[] ints: array1){
    
			for (int anInt: ints){
    
				System.out.println(anInt+"\t");
			}
			System.out.println();
		}
	}
}