【java学习笔记】数组的语法、创建、特点、初始化、多维数组、扩展（冒泡、稀疏）

一、数组

• 数组这是很大一坨，但这里只粗浅的讲一些主要内容
• 数组是一个数据相同的集合

1.声明数组的语法：

	detaType[] arrayRefVat; //此为首选方法 》》  类型【】 变量名
	detaType arrayRefVat[]; //  》》》》         类型 变量名【】

2.调用创建的数组

	detaType[] arrayRefVat = new fataType[arraySize];
	//创建什么类型，就new怎该类型的数组

• 数组是通过索引来访问。索引从0开始

arrays.length   //用于获取数组的长度

例子：
int[] nums;  //声明一个数组
nums = new int[10];  //创建一个数组 能存放10个内容
nums[0] = 1;  //赋值

3.特点

• 数组一旦被创建就无法被改变
• 一个数组中的元素都是相同元素的集合
• 数组是基本类型 或者 引用类型
• 数组对象的本身就是在堆中

二、java的初始化

这里会涉及堆 和栈的区别

1.初始化：

	静态：
	int[] a={2,3,4,5}; //基本类型
	Man[] mans = {new Man(1,1),new Man(2,2) //引用类型

	动态：
	int[] a =new int[] ;//声明
	a[0] =1;
	a[1] =2;

三、多维数组

• 多维数组可以看多数组中的数组

语法：
int a[][] = new int[2][5] //a可以看作两行五列

四、数组的使用

• 一般与循环 融合使用（逐个赋值、计算、比较） 使用 for循环、for-each循环

• 数组用于方法入参

• 数组也作为返回值

练习1（输出二维数组中全部的数）

	public static void main(String[] args) {
        int[][] array = {{1,2} , {3,4} , {5,6} , {7,8}};
        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(" ");
        }
    }

练习2（反向输出数组）

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

        for (int array: a ){
            System.out.println(array);
        }
        System.out.println("=================");

        int[] r = reverse(a);
        for (int i=0;i<r.length;i++){
            System.out.print(r[i]);
        }

    }
//反转
    public static int[] reverse(int[] arrays){
        int[] revsult = new int[arrays.length];

        for (int i=0, j = arrays.length-1 ;i<arrays.length;i++,j--){
            revsult[j] = arrays[i];
        }
        return revsult;

    }
}

五、数组的扩展

1.Arrays类

• 数组的工具类：java.util.Arrays
• 常用的方法：

赋值：fill方法
排序：sort方法，默认按升序
比较：equals方法，比较数组中两个元素是否相等
查找：binarySearch 对比排序好对数组进行二分查找

2.冒泡排序

1.两层循环，外层冒泡轮数，里层进行比较
2.时间复杂度O（n2）

练习3 排个序

public static void main(String[] args) {

        int[] a = {1,24,32,32,54,3,54,6,52,12,21,3,6};
        System.out.println(Arrays.toString(sort(a)));
    }
    //冒泡算法：
    public static int[] sort(int[] array){

        int temp =0;
        for (int i=0;i<array.length;i++){    //进行每轮排序，每一轮可排序-1
            for (int j=0;j<array.length-1-i;j++){  
                if(array[j+1]>array[j]){
                    temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }

3稀疏数组

- 什么是稀疏数组：  当数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组保存该数组。
- 目的：为了简化内容 从而节省存储空间

比如：

-处理方式：
1.记录原数中一共几行几列，有多少值
2.把具有不同值的元素和行列及值记录在一个小规模数组中，进而缩小程序的规模

练习：

    public static void main(String[] args) {
        //1 创建一个11x11的矩阵
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原数:
        System.out.println("输出原数：");
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                System.out.print(array1[i][j] + "  ");
            }
            System.out.println();
             //两个循环，输出二维数组中全部的内容
        }

        System.out.println("------------分割线----------------");  
        
        //2.转化成  稀疏数组
            
        int sum = 0;    //获取有效值（非零）数的 个数

        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("行" + " |" + "列" + " |" + "值");

        //创建一个稀疏数组
        int[][] array2 = new int[sum + 1][3];      //[sum+1]:非零数字个数+ 首行记录总共行列
        //稀疏数组第一行  一共几行几列有几个数值 
        array2[0][0] = array1.length;  //第一行记录总共  几行| 几列 | 有几个有效值
        array2[0][1] = array1[1].length;  
        array2[0][2] = sum;

        //遍历二维数组,将非0的值存入稀疏数组里
        int line = 1;
        
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    array2[line][0] = i + 1;
                    array2[line][1] = j + 1;
                    array2[line][2] = array1[i][j];
                    line++;
                }
            }
        }
        
        //输出：稀疏数组
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j] + "|");
            }
            System.out.println();
        }

        System.out.println("--------------分割线----------------");
        
        //还原：
//        创建一个数组 稀疏数组中第一行记录了整个数组的 行列
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

//        遍历稀疏数组中2~n行的信息，将稀疏数组中的 行、列、数值 还原到数组中
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]-1][array2[i][1]-1] = array2[i][2];
        }
//        输出整个数组

        for (int i =0;i< array3.length;i++){
            for (int j=0;j<array3[0].length;j++){
                System.out.print(array3[i][j]+"  ");
            }
            System.out.println();
        }
    }

自学内容，来源“kuangstudy.com”