数组

数组是相同数据类型数据的有序集合，数组下标从0开始，length-1结束

dataType[] arrayRefVar; //首选方法，数组声明

Java语言使用new操作符来创建数组

dataType[] arrayRefVar = new dataType[arraySize]；

获取数组长度

array.size();

数组是引用类型，元素相当于类的实例变量

  • 长度是确定的

  • 元素类型相同

  • 元素可以是任意数据类型

  • 数组变量是引用类型，数组也可以看成是对象，元素相当于该对象的成员变量

    数组对象本身是在堆中的

内存分析

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

Arrays类

列举类中的一些方法

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,1212,2306,2004,23};
        System.out.println(a);

        //打印数组元素Arrays.toString()
        System.out.println(Arrays.toString(a));
        //对数组进行排序Arrays.sort()
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

常用功能：

  • 给数组赋值：通过fill方法
  • 对数组排序：通过sort方法，升序
  • 比较数组：通过equals方法比较数组中元素值是否相等
  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找

冒泡排序

//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换位置
//2.每一次比较，都会产生一个最大或最小的数字
//3.下一轮则少比较一次
//4.依次循环，直到结束！
public static void sort(int[] array) {
	int temp = 0;
	for(int i = 0; i < array.length-1; i++){
		for(int j = 0; j < array.length-1-i; j++){
			if(array[j+1] > array[j]){
				temp = array[j];
				array[j] = array[j+1];
				array[j+1] = temp;
			}
		}
	}
}

稀疏数组

数组中大部分元素为0，或者为同一值的数组时，可以采用稀疏数组保存该数组

处理方式：

  • 记录数组一共有几行几列，有多少个不同值
public class Demo {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11  0代表无棋子，1代表白棋，2代表黑棋
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;

        //输出原始数组
        System.out.println("输出原始数组");
        for(int[] ints: a){//增强for循环
            for(int anInt: ints){
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        //统计不同值的个数
        int sum = 0;
        for(int[] ints: a){
            for(int anInt: ints){
                if(anInt != 0){
                    sum++;
                }
            }
        }
        //创建一个稀疏数组
        int[][] b = new int[sum+1][3];
        b[0][0] = 11;//输入原数组行数
        b[0][1] = 11;//输入原数组列数
        b[0][2] = sum;//输入原数组不同值个数
		
        //构建稀疏数组
        int count = 1;
        for(int i = 0; i < 11;i++){
            for (int j = 0; j < 11;j++){
                if(a[i][j] != 0){
                    b[count][0] = i;
                    b[count][1] = j;
                    b[count][2] = a[i][j];
                    count++;
                }
            }
        }
        System.out.println("稀疏数组：");
        
        //输出稀疏数组
        for (int[] ints : b) {
            System.out.println(ints[0] + "\t" + ints[1] + "\t" + ints[2] + "\t");
        }
        //尝试还原数组
        System.out.println("还原数组：");
        //创建还原数组
        int[][] c = new int[b[0][0]][b[0][1]];
        for(int i = 1; i <= b[0][2]; i++){
            c[b[i][0]][b[i][1]] = b[i][2];
        }
        System.out.println("输出还原数组");
        for(int[] ints: c){
            for(int anInt: ints){
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }

}