Java数组

最新推荐文章于 2025-07-14 16:15:01 发布

原创最新推荐文章于 2025-07-14 16:15:01 发布 · 136 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

本文详细介绍了Java数组的基础概念，包括数组的声明与创建、内存分布、初始化、特点、边界规则，以及如何使用for循环、多维数组、Arrays类和稀疏数组。涵盖了静态和动态初始化、冒泡排序以及数组在方法参数和返回值的应用。

Java数组

1.数组的定义

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

2.数组声明和创建

数组的声明

dataType [] arrayRefVar;//首选方法或dataType arrayRefVar [];

如

int [] nums;或int nums[];

数组的创建

//用new操作符创建数组dataType[] arrayRefVar= new dataType[arraySize]

如

int [] nums;nums =new int[5];
或int [] nums=new int[5];

数组的元素是通过索引访问的，数组索引从0开始。
获取数组长度

arrays.length

3.内存分析

1. 堆：

- 存放new的对象和数组
- 可以被所有线程共享

2.栈

 - 存放基本变量类型（会包含这个基本类型的具体数值）
 - 引用对象的变量（会存放这个引用在堆里的具体地址）

3. 方法区

  - 可被所有线程共享
  - 包含所有的class和static变量

初始化

静态初始化

//静态初始化:创建+赋值
int[] a={1,2,3,4,5,6,7,8};
System.out.println(a[0]);

动态初始化

//动态初始化:包含默认初始化
int[] a=new int[5];
a[0]=1;
a[1]=2;

默认初始化

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

4.数组的特点

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

5.数组的边界

数组边界

下标的合法区间：[0,length-1]，如果越界就会报错。

错误：ArrayIndexOutOfBoundsException

6.数组的使用

普通的for循环
for-each循环：

public static void main(String[] args) {`

   int [] num={1,2,3,4};`

   //把num中的元素都赋值给x,没有下标，适合打印输出`

   for (int i:num){`

        System.out.print(i);`

   }`

}`

数组作方法入参

public static int[] reverse(int[] arrays){}

数组作返回值

7.多维数组

数组嵌套数组

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

8.Arrays类

System.out.println(Arrays.toString(a));//输出数组元素

Arrays.sort(a);//排序（升序）

Arrays.fill(a,2,4,0);//数组填充,2到4被0填充

9.冒泡排序

方法1：

package Test;

import java.util.Arrays;

public class Maopao {
    public static void main(String[] args) {
        int[] a={1,5,3,7,8,0};
        for(int j=5;j>=0;j--){//第几个数
            for(int i=1;i<=5;i++){//每个数的比较次数
                int t=0;
                if(((j-i)>=0)&&(a[j]<a[j-i])){
                    t=a[j];
                    a[j]=a[j-i];
                    a[j-i]=t;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

方法2：

public static int[] sort(int[] array){
        boolean flag=false;//利用flag减少没有意义的比较
        int temp;
    //外层循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {
        //内层循环，比较交换位置
            for (int j = 0; j < array.length-1-i; j++) {               
        
        if (array[j]>array[j+1]){
        temp=array[j];
        array[j]=array[j+1];
        array[j+1]=temp;
        flag=true;
        }
        }
        if (flag==false){
        break;
        }
        }
        return array;
        }

10.稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组是，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

package Test;

public class Sishu {
        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;
            //输出原始数组
            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);
            //2.创建一个稀疏数组的数组
            int[][] array2 = new int[sum+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];
                    }
                }
            }
            //输出稀疏数组
            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]);
            }
            System.out.println("******************");
            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];
            }
            //输出还原数组
            System.out.println("输出还原数组");
            for (int[] ints : array1) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }
                System.out.println();
            } 
        }
}