Java数组

数组概述

数组的定义：

• 数组是相同数据类型的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 每个数据称作一个数组元素，每个数组元素可以通过一个下标来访问

数组声明、创建及初始化

	//数组声明
	dataType[] arrayRefVar;//首选方法
	
	dataType arrayRefVar[];//效果同上，但非首选

	//数组创建
	arrayRefVar = new dataType[arraySize];//创建

	dataType[] arrayRefVar = new dataType[arraySize];//声明+创建
	
	//数组初始化

	//静态初始化
	int[] a = {1,2,3};
	Man[] mans = {new Man(1,1),new Man(2,2)};//引用类型

	//动态初始化：包含默认初始化
	int[] a = new int[2];
	a[0] = 1;
	a[1] = 2;

	//默认初始化
	//数组是引用类型，数组元素相当于类的实例变量，因此数组一经分配空间，每个元素也被按照实例变量同样的方式隐式初始化	

	/*
	注：数组的元素是通过索引访问的，数组索引从0开始
		通过array.length获取数组长度
	*/
	

数组特点

• 长度确定，数组一旦被创建，大小不可变
• 元素必须是相同类型
• 数组元素可以是任何数据类型
• 数组变量属于引用类型
• 数组本身就是对象，Java中对象在堆中，所以无论数组保存原始类型还是其他对象类型，数组对象本身是在堆中的

内存分析

• 堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用
• 栈：存放基本变量类型（包含具体值）；引用对象的变量（包含引用在堆里的具体地址）
• 方法区：可以被所有的线程共享，包含所有的class和static变量

数组边界

下标的合法区间：[0,length-1]
数组下标越界异常：ArrayIndexOutOfBoundsException

数组使用

For-Each循环

	//没有下标地遍历数组
	
	int[] arrays = {1,2,3,4,5};

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

其他使用：

• 普通for循环
• 数组做方法入参
• 数组做返回值

多维数组

多维数组可以看成数组的数组

如二维数组的定义：

	int a[][] = new int[3][4];

上面代码定义了一个3行4列的数组

多维数组类似二维数组

Arrays类

数组的工具类：java.util.Arrays

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名调用，不用使用对象来调用

常用功能：

• 给数组赋值：fill()
• 对数组排序：sort()（升序）
• 比较数组：equals()
• 打印数组元素：toString()
• 查找数组元素：binarySearch()（对排好序的方法进行二分查找法）

冒泡排序

定义：

• 比较数组中相邻的两个元素，如果第一个数比第二个数大，就交换位置
• 每一次比较，都会产生一个最大和一个最小
• 下一轮则可以少一次排序
• 依次循环，直至结束

package dengaku;

import java.util.Arrays;

public class Test {
    
    public static void main(String[] args) {
        
        //定义数组a并初始化
        int a[] = {5,2,0,0,1,3,1,4};
        //定义数组sort为数组a按升序排序后的数组
        int[] sort = sort(a);
        //输出排序后的数组sort
        System.out.println(Arrays.toString(sort));
    }

    //冒泡排序
    public static int[] sort(int[] array){

        //临时变量
        int temp = 0;
        
        //外层循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {

            //通过flag标识减少没有意义的比较（优化）
            boolean flag = false;

            //内层循环，比较两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length-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==false){
                break;
            }
        
        }
        
        return array;  
    }
    
}

	//输出：[0, 0, 1, 1, 2, 3, 4, 5]

稀疏数组

稀疏数组的概念

当数组中大部分元素为0或同一值时，可以使用稀疏数组来保存该数组，稀疏数组是二维数组

稀疏数组的处理方式：

• 记录数组一共有几行几列，有多少个不同值
• 把具有不同值的元素及其行、列记录在一个小规模数组中，以缩小程序规模

以棋盘为例，棋盘信息：

• 大小：11*11
• 黑棋*1，位置：2行3列
• 白棋*1，位置：3行4列

package dengaku;

public class Test {
    
    public static void main(String[] args) {
        
        //创建一个二维数组：11*11  0：没有棋子  1：黑棋  2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        
        //输出原始数组
        System.out.println("输出原始数组");

        //For-Each循环
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        
        System.out.println("=========================================");
        
        //转换为稀疏数组保存
        //获取有效值的个数并输出
        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("有效值的个数为"+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 <  array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[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("=========================================");
        
        //稀疏数组还原
        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-Each循环
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

//输出：
输出原始数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
=========================================
有效值的个数为2
输出稀疏数组
11	11	2	
1	2	1	
2	3	2	
=========================================
还原原始数组
输出还原数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0
    

稀疏数组的结构

	行(row)	列(col)	值(value)
[0]	11(原始数组的行数)	11(原始数组的列数)	n(有效数字的个数)
[1]	1(有效数字1的行值)	2(有效数字1的列值)	1(有效数字1的值)
[2]	2(有效数字2的行值)	3(有效数字2的列值)	2(有效数字2的值)
[…]	…	…	…
[n]	x(有效数字n的行值)	y(有效数字n的列值)	z(有效数字n的值)