Java数组

FFeng007

于 2021-07-08 19:51:58 发布

阅读量96

点赞数

分类专栏： Java基础笔记文章标签： java

本文链接：https://blog.csdn.net/q2389419762/article/details/118580856

版权

Java基础笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的数组，包括定义、特点、声明与创建、初始化方式、内存分析、数组边界、基本使用、For-Each循环、作为方法参数及返回值等。还涉及了多维数组、Arrays类的方法如排序和填充，以及冒泡排序算法和稀疏数组的概念与转换。内容全面，适合Java初学者掌握数组操作。

摘要由CSDN通过智能技术生成

一、数组概述

1.数组的定义

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

2.数组的基本特点

长度确定，数组一旦被创建，其大小不可以改变。
元素必须是相同类型，不能是混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数对象本身是在堆中的。

二、数组的声明和创建

1.数组的声明和创建

int[] nums （首选方法）
int nums[] （效果相同，不是首选）
Java中用new操作符来创建数组。

 public static void main(String[] args) {
        int[] nums;//1.声明一个数组。
        nums = new int[10];//2.创建一个数组，这个数组包含十个（0~9）数字。
        int[] nums1 = new int[10];
        //3.给数组赋值。
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;

        //求和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println("和为" + sum);
    }

2.三种初始化

静态初始化

直接在定义数组的同时为数组元素分配空间并赋值。

int[] a = {1,2,3,4,5,6};
动态初始化

数组定义、为数组元素分配空间、赋值，分开进行。

int[] b = new int[2];
b[0] = 1;
b[1] = 2;

默认初始化

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

int[] a = new int[2];
boolean[] b = new boolean[2];
String[] c = new String[2];
System.out.println(a[0]+" "+a[1]);//0 0
System.out.println(b[0]+" "+b[1]);//false false
System.out.println(c[0]+" "+c[1]);//null null

3.内存分析

Java内存

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

在这里插入图片描述

声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法
声明一个数组的时候并没有数组被真正的创建。
构造一个数组，必须指定长度。

4.数组边界

数组的元素通过索引访问，数组索引从0开始，所以索引值是从0到arrays.length-1，arrays.length为数组长度。
下标的合法区间：[0，length-1]，如果越界就会报错。

ArrayIndexOutOfBoundsException //数组下标越界异常！

三、数组的使用

由于数组的元素类型和数组的大小都是确定的，所以处理数组元素的时候，通常使用基本循环和For- Each循环。

1.数组的基本使用

public static void main(String[] args) {
    int[] arrays = {1,2,3,10,5};

    //打印全部数组元素
    for (int i = 0; i < arrays.length; i++) {
        System.out.println(arrays[i]);
    }
    System.out.println("=================");

    //求所有数组元素的和
    int sum = 0;
    for (int i = 0; i < arrays.length; i++) {
        sum += arrays[i];
    }
    System.out.println("sum="+sum);
    System.out.println("=================");

    //查找最大值
    int max = arrays[0];
    for (int i = 1; i < arrays.length; i++) {
        if (arrays[i]>max){
            max = arrays[i];
        }
    }
    System.out.println("max="+max);
}

2.For-Each循环

For-Each 循环（加强型循环），在不使用下标的情况下遍历数组。

for(type element: array){

System.out.println(element);

}

int[] arrays = {1,2,3,4,5};

//For-Each循环  没有下标
for (int array : arrays) {
   System.out.print(array+" ");
}

3.数组作为方法入参

数组作为参数传递给方法。

//打印数组元素  数组做方法入参
public static void printArray(int[] arrays){
    for (int i = 0; i < arrays.length; i++) {
        System.out.print (arrays[i]+" ");
    }
}

4.数组做返回值

result数组作为函数的返回值

//反转数组  数组做返回值
public static int[] reverse(int[] arrays){
    int[] result = new int[arrays.length];

    //反转的操作
    for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
        result[j] = arrays[i];
    }

    return result;//result数组作为函数的返回值
}

四、多维数组

多维数组可以看成是数组的数组，例如二维数组就是一个特殊的一维数组。

//[5][2] 5行2列
/*
    1,2 array[0]
    2,3 array[1]
    3,4 array[2]
    4,5 array[3]
    5,6 array[4]
 */
int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}};
int[][] a = new int[5][2];//二维数组 5行2列

a.length为二维数组第一维度的长度。
a[0].length为第二维第一个数组的长度。

五、Arrays类

Arrays类中的方法都是static修饰的静态方法，可以直接调用，不用使用对象来调用（但是可以使用对象调用）

1.打印数组元素 Arrays.toString()

int[] a = {1,2};
//打印数组元素    Arrays.toString
System.out.println(Arrays.toString(a));//[1,2]

2.数组元素排序（升序） Arrays.sort()

int[] a = {1,6,3,244,45,556};//数组元素排序，升序
Arrays.sort(a);System.out.println(Arrays.toString(a));//[1, 3, 6, 45, 244, 556]

3.数组元素填充 Arrays.fill(）

int[] a = {1,6,3,244,45,556};
//数组填充
Arrays.fill(a,2,4,50);//填充2和4之间的元素为50，即第2个和第3个填充为50
System.out.println(Arrays.toString(a));//[1, 6, 50, 50, 45, 556]

六、冒泡排序

1.比较数组中俩个相邻的元素，如果第一个比第二个大，就调换他们的位置。
2.每一次比较，都会产生一个最大或者最小的数字。
3.下一轮可以少一次排序。
4.依次循环，直到结束。

public static void main(String[] args) {
    int[] a = {2,23,435,6,67,45,345,678,1234};
    System.out.println(Arrays.toString(sort(a)));
}

public static int[] sort(int[] array){
    //临时变量
    int temp = 0;
    //外层循环，判断循环执行多少次
    for (int i = 0; i <array.length-1; i++) {
        
        boolean flag = false;//通过flag标识来位减少没有意义的比较。
        
        //内层循环，比较俩个数，如果第一个比第二个大，则交换位置。
        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;
                flag = true;
            }
        }
        if (flag==false){
            break;
        }
    }
    return array;
}

七、稀疏数组

当一个数组中大部分元素为0，或者是相同数值的数组时，可以使用稀疏数组对其进行保存。
稀疏数组处理方式
- 确定数组有几行几列，有几个不同值。
- 把具有不同值的元素和行数列数记录在一个小规模的数组中，缩小程序的规模。（压缩）

例如：

原始数组
0 0 0 0 0
0 0 1 0 0
0 0 0 2 0
0 0 0 0 0
0 0 0 0 0

稀疏数组
行列值
5 5 2
1 2 1
2 3 2

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

    for (int[] ints : array1) {
        for (int anInt : ints) {
            System.out.print(anInt + "\t");
        }
        System.out.println();
    }
    System.out.println("=============");

    //一、转换为稀疏数组

    //1.获取有效值的个数
    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);

    //2.创建一个稀疏数组的数组
    int[][] array2 = new  int[sum+1][3];

    array2[0][0] = 11;//行数
    array2[0][1] = 11;//列数
    array2[0][2] = sum;//有效值个数

    //3.遍历二维数组，将非零的数，存放在稀疏数组中。
    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];
            }
        }
    }

    //4.输出稀疏数组
    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("====================");

    //二、还原稀疏数组

    //1.读取稀疏数组
    int[][] array3 = new int[array2[0][0]][array2[0][1]];

    //2.给其中的元素还原它得值
    for (int i = 1; i < array2.length; i++) {
        array3[array2[i][0]][array2[i][1]] = array2[i][2];
    }

    //3.打印还原的数组
    System.out.println("输出还原的数组");
    for (int[] ints : array3) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }

}