JAVA数组

数组的定义

1. 数组是相同数据类型的有序集合

2. 数组描述的是相同类型的若干个数据，按照一定的先后顺序排列

3. 其中，每一个数据称为数组元素，每个元素可以通过数组下标来引用

数组的声明和创建

1. 静态初始化，直接给数组赋值，数组元素固定死

2. 动态初始化，通过new来初始化长度，后续再赋值

package com.liang.array;
/*
数组初始化
 */
public class Demo01 {
    public static void main(String[] args) {
        // 静态初始化定义数组，数据类型+[]+变量名+值，直接给数值赋值
        int[] a = {1,2,3,4,5,7,6,5,5};
        // 动态初始化数组，分为两步，先声明，后初始化,若初始化没有赋值，默认赋值为0
        int[] b = new int[10];
        System.out.println(b[5]);
    }
}

JAVA内存分析

在java内存中分为堆和栈两种结构

1. 栈中主要存放基本变量类型(会包含这个基本类型的具体数值)和引用对象的变量(会存放在这个引用变量在堆里的具体地址)

2. 堆是存放new的对象和数组，可以被所以的线程共享，不会被存放别的对象引用

数组的使用

数组使用的四个基本点

1. 数组的长度是确定的，一旦定义，其长度不可改变

2. 数组中的元素必须是同一种数据类型

3. 数组中的类型可以使基本类型和引用类型

4. 数组变量属于引用类型，数组也可以看作出对象，java对象是存放在堆中的

/*
数组的使用
 */
public class Demo02 {
    public static void main(String[] args) {
        int[] a = {1,5,8,3,4,7,2,5,4,3,5};
​
        // 求出数组中的所有元素之和
        int num = 0;
        for (int i =0;i <a.length;i++){
            num += a[i];
​
        }
        System.out.println(num);
        // 利用增强型for循环求出数组所有元素之和
        for (int i:a){
            System.out.println(i);
        }
        // 多维数组的定义和使用
        int b[][] = {{1,2},{3,4},{7,8},{4,8,9,6},{2,5,8}};
        for (int i=0;i<b.length;i++){
            for (int j = 0;j<b[i].length;j++){
                System.out.print(b[i][j]+",");
            }
        }
    }
}

JAVA类Arrays

数组的工具类java.util.Aarrys,由于数组本身没有什么方法可以供我们调用，但在API中提供了一个类供我们使用

Arrays类有以下方法：

1. 给数组赋值：通过fill 方法

2. 对数组排序: 通过sort方法升序

3. 比较数组： 通过equals比较数组中元素是否相等

import java.util.Arrays;
​
/*
关于java类array的使用
 */
public class Demo03 {
    public static void main(String[] args) {
        int [] a = {5,8,6,9,7,6,4};
        // 使用 java类Array对数组进行排序和打印
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,0);
        System.out.println(a[2]);
    }
}

排序算法之冒泡排序法

import java.util.Arrays;
​
/*
关于冒泡排序
 */
public class Demo04 {
    public static void main(String[] args) {
        int[] a = {6,89,5,3,5,3,54,49};
        int[] b =array(a);
        // System.out.println("排序前的数组为：", +Arrays.toString(a));
        System.out.println(Arrays.toString(b));
    }
    // 自定义冒泡排序算法
    public static int[] array(int[] a){
        int temp = 0;
        // int[] result = new int[a.length];
        for (int i =0;i<a.length-1;i++){
            for (int j=0;j<a.length-i-1;j++){
                if (a[j]>a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        return a;
    }
}
​
​

二维数组与稀疏数组

当二维数组元素个数比较多，且冗余个数比较多时，我们可以采用压缩的方式对数组进行存储，这样可以降低内存资源的使用度，常见的压缩数组即为稀疏矩阵

稀疏数组是将矩阵中不同元素按行列和值表示出来，稀疏数组第一行是二维数组的行数列数以及不同元素个数，它默认是三列，所以稀疏矩阵是一个n+1行(n为不同值元素的个数),3列的一个矩阵

/*
稀疏数组与二维数组之间的转换
 */
public class Demo05 {
    public static void main(String[] args) {
        // 定义11*11二维数组,并输出
        int[][] a = new int[11][11];
        a[5][6] = 5;
        a[3][4] = 2;
        a[5][4] = 1;
        System.out.println("二维数组为");
        // 输出这个二维矩阵
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a[i].length;j++){
                System.out.print(a[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("**************************************");
        // 计算出这个数组不同元素的个数
        int num = 0;
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a[i].length;j++){
                if (a[i][j]!=0){
                    num++;
                }
            }
        }
        // 将二维数组转换为稀疏数组
        int[][] a1 = new int[num+1][3];
        a1[0][0]=11;
        a1[0][1]=11;
        a1[0][2]=num;
        int count = 0;
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a[i].length;j++){
                if (a[i][j]!=0){
                    count++;
                    a1[count][0]=i;
                    a1[count][1]=j;
                    a1[count][2]=a[i][j];
                }
            }
        }
        // 打印出这个稀疏数组
        for (int i=0;i<a1.length;i++){
            for (int j=0;j<a1[i].length;j++){
                System.out.print(a1[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("**************************************");
​
        // 将稀疏矩阵转换为二维矩阵
​
        int[][] a2 = new int[a1[0][0]][a1[0][1]];
        for (int i=1;i<a1.length;i++) {
            int row = a1[i][0];
            int column =a1[i][1];
            int value =a1[i][2];
            a2[row][column] = value;
        }
        for (int i=0;i<a2.length;i++){
            for (int j=0;j<a2[i].length;j++){
                System.out.print(a2[i][j]+"\t");
            }
            System.out.println();
        }
    }
}