Java数组

1.概述

• 定义

  • 相同类型数据的有序集合
  • 描述的相同类型的托干数据，且有序组合而成
  • 每一个数据称作数组元素，每个元素可以通过一个下标访问他们

  数组下标从0开始

2.声明、创建

• 声明

int[] nums; //一般写法
int nums1[];//C快速导入Java

• 创建

//这里面可以放10个int类型的数据
nums = new int[10];

• 赋值

//给数组中的元素赋值
nums[0] = 1;
nums[1] = 1;
nums[2] = 1;
nums[3] = 1;

**属性：**数组长度 length

Java内存

1. 堆

   • 存放new的对象和数组
   • 可以被所有的线程共享，不会存放别的对象引用

2. 栈

   • 存放基本变量类型(包括数值)
   • 引用对象的变量(会存放这个引用在堆里面的具体地址)

• 三种初始化

  //1. 静态初始化
  int[] a = {1,2,3,4,5};
  //2. 动态初始化 包含默认初始化
  int[] b = new int[5];
  b[1] = 1;
  //3. 默认初始化，默认值
  

数组的而四个基本特点

• 长度是确定的，不可更改
• 元素必须是相同类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组本身就是对象，数组变量属于引用类型。

数组有效区间[0,length-1]

越界会报异常：ArrayIndexOutofBoundsException

3.数组的使用

• for-each

• for循环

• 数组作为方法的参数

• 数组作为方法的返回值

4.多维数组

可以看成数组的数组，比如一个二维数组，其中每一个元素都是一个一维的数组

int[][] arrays = new int[3][3];

实质

5.Arrays类

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

public class Demo01 {
    public static void main(String[] args) {
        int[] b = {4,3,6,90,58,45};
        //输出数组 Arrays.toString
        System.out.println(Arrays.toString(b));
        Arrays.sort(b);//排序  升序 Arrays.sort
        System.out.println(Arrays.toString(b));
    }
}

• 给数组赋值：fill方法
• 对数组排序：同各国sort方法，按照升序
• 比较数组：equals方法 返回boolean
• 查找数组元素：binarySearch方法对排序好的数组进行二分查找

冒泡排序

public class Demo02 {
    public static void main(String[] args) {
        int[] a = {2,565,11,564,52,3,5456,65};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(a));
    }
    //冒泡排序
    //1. 比较数组中每两个相邻的元素，如果第一个元素比第二个元素大，就交换他们的位置
    //2. 每一次比较都会产生一个最大的数字
    //3. 下一轮比较就可以少一次
    //依次循环直到结束！
    public static int[] sort(int[] a){
        //定义临时变量，方便交换值
        int temp = 0;
        //外层循环，控制比较的轮数
        for (int i = 0; i < a.length-1; i++) {
            //内层循环，控制每一轮比较的次数
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j+1]>a[j]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        return a;
    }
}

6.稀疏数组

• 稀疏数组是一种数据结构，为了压缩数据，减少空间的浪费
• 当一个数组中有很多相同值的时候就可以使用稀疏数组储存
• 稀疏数组的处理方式：
  • 记录数组一共有几行几列，有多少个不同取值
  • 把具有不同取值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

public class Demo03 {
    //稀疏数组
    public static void main(String[] args) {
        //0表示没有棋子 1表示黑棋 2表示白棋
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        //输出原始数组
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        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] = a.length;
        b[0][1] = a[0].length;
        b[0][2] = sum;
        //遍历原始数组  给稀疏数组赋值
        int count = 0;//计数有效元素
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                if(a[i][j]!=0){
                    count++;
                    b[count][0] = i;
                    b[count][1] = j;
                    b[count][2] = a[i][j];
                }
            }
        }
        //输出稀疏数组
        for (int[] ints : b) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        System.out.println("=================================");

        //稀疏数组还原为原来的原始数组
        //创建一个数组 稀疏数组的第一行的信息为其创建元素做铺垫
        int[][] c = new int[b[0][0]][b[0][1]];
        //从第二行开始遍历稀疏数组，依次给每一个有效元素赋值
        for (int i = 1; i < b.length; i++) {
            c[b[i][0]][b[i][1]] = b[i][2];
        }
        //输出还原的原始数组
        for (int[] ints : c) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}