Java之数组专题

Java基础之数组专题

本文章是作者学习B站系列视频《狂神说Java》与经典书籍《Java核心技术》的记录笔记与心得，创作不易，希望能够得到您的支持。

数组的定义

数组是相同类型的数据的有序集合，它存储着相同类型值得序列。每一个数据都是一个数组元素，可以根据在数组中的位置用下表来访问它们。

数组的声明与初始化

定义变量的通用格式：变量类型 + 变量名 = 变量值

使用数组前必须先声明数组，声明数组有两种语法：

* int[] a;
//dataType[] arrayRefVar;
//更推荐第一种风格，因为可以将类型int[]整型数组，与变量名分开
* int a[];
//dataType arrayRefVar[];

//以上语句只声明了变量a，但是没有初始化，应该用new进行创建

int[] a= new int[10];//数组长度为10

在Java中，提供了一种定义与初始化同时实现的简写形式(静态初始化)：

int[] instance={1,2,3};
//这种写法的好处：方便随时给数组添加值

数组元素的访问

对数组中任何元素的访问和操作都是通过数组的下标实现的。注意：数组的第一个元素下标为0，往后则数组依次增加。数组的有序性也可以在这里体现。

int[] num= new int[10];
// dataType[] arrayReVar = new dataType[arraySize];
num[0]=1;//将数组中的第一个元素(下标为0)赋值为1
num[1]=2;//将数组中的第二个元素(下标为1)赋值为2
……
num[8]=9;//将数组中的第九个元素(下标为8)赋值为9
for(int i=0;i<10;i++)
{
    System.out.println(num[i]);
}
//这里第十个元素(下标为9)会输出0，因为没有被初始化和定义的整型元素会被自动赋值为0；

注意事项：

1. 如果试图访问超过数组下标的元素，则会引发" Array Index Out Of Bounds Exception"(数组下标越界异常)

2. 想要获取数组中的元素个数，可以用array类中的length方法获取(array.length)

内存分析

1. 声明数组时，栈区会开辟一段内存空间，存放数组类型

2. 创建数组时，堆区会开辟一段内存空间，存放new出来的对象和数组

int []array;
//栈区存放array数据类型
array=new int[10];
//堆区存放十个数据的空间，即使此时十个数据还没有被赋值。数据在被赋值后，会被存放在堆区中

定义出的数组的本质是数组类的对象，而Java中的对象存放在堆区里。所以数组里不管存放什么样的数据类型，对象本身依然是在堆中。

数组的使用

For-Each 循环

for-each循环可以处理数组的每个元素，无需考虑下标，是一种增强的for循环

语法：for (variable:collection) statement

public class Array1
{
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
     
        int max=arrays[0];
        for (int i = 0; i < 5; i++) {
            if(arrays[i]>max)
            {
                max=arrays[i];
            }
        }
        System.out.println(max);
        //常规for循环，需要通过下标访问
        for (int array : arrays) {
            System.out.println(array);
            //for-each循环，没有下标
        }
    }
}

数组作方法入参

public class Array2 {
    //数组作为参数
    public static void main(String[] args) {
        int[] num={1,2,3,4,5};
        printArray(num);//num作为printArray类的参数

    }
    public static void printArray(int[] arrays)
    {
        for(int i=0;i< arrays.length;i++)
        {
            System.out.println(arrays[i]);
        }
    }
}

冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5,6,7,8,9};
        sort(arrays);
        for(int i=0;i<arrays.length;i++)
        {
            System.out.println(arrays[i]);
        }
        //输出结果：9 8 7 6 5 4 3 2 1

    }
    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-i-1;j++)//内层循环，两个数进行比较的次数
            {
                if(array[j+1]>array[j])
                {
                    temp =array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;//实现两个数的交换
                }
            }
        }
    }
}

多维数组

• 多维数组使用多个下标访问数组元素，可以理解为原来的一位数组的每一个元素都是一个数组，即数组的嵌套。

• 多维数组的定义方式与一维类似：

  数组内存储的数据类型 [][]……[] +数组名称
  其中，方括号的个数即为数组的元素

稀疏数组

数组中有很多元素为0，或者很多元素重复时，使用稀疏数组。先记录原数组的行数、列数，与数组中的有效元素，再将以上数据存放在一个新的数组中。

public class Chess {
    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 (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 < 11; i++) {
           for(int j=0;j<11;j++)
           {
               if(array1[i][j]!=0)
               {
                   sum++;
               }
           }
        }
        System.out.println("有效值的个数"+sum);
        //创建稀疏数组
        int[][] array2=new int[sum+1][3];//加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];

                }
            }
    }
        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("=====================");
        //稀疏数组还原为原数组
        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];
        }
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        }
}