Java数组

yuboyao1012

已于 2023-04-08 14:27:43 修改

阅读量92

点赞数

文章标签： java 开发语言

于 2022-04-12 16:33:21 首次发布

本文介绍了Java中数组的基础概念，如数组定义、创建（静态和动态）、索引访问、内存结构、经典错误处理、初始化、特点及使用方法。涵盖了for循环、for-each循环、数组参数传递、返回值和多维数组，以及Arrays类的实用功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

朝酒花也

定义

相同类型数据的，有序集合
通过数组下标访问数组元素

数组的创建

需要先声明

int[] nums; //定义   int nums2 [] 也可
int[] array = null;	//创建数组为空
int[] nums2 = new int[10];	//声明和创建可以一步完成
int[] a = {1,2,3,4,5,6,7,8};	//创建+赋值
Man[] mans = {new Man(),new Man2()};		//引用类型的创建数组

使用new来创建数组
```
 nums = new int[10];
```

数组索引从0开始

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;
        System.out.println(nums[9]);    //没有赋值，默认值为0

求数组元素和

//计算所有元素的和；
        int sum = 0;
        for(int i = 0; i < nums.length; i++) {          //数组长度
            sum+=nums[i];
        }
        System.out.println("总和为："+sum);

Java内存分析

Java内存分为：

堆：存放刚new出来的对象和数组
栈：存放变量的类型
方法区：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VsBv9YNH-1649751902609)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220411153530891.png)]$

经典错误

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

Index 10 out of bounds for length 10 at Array.ArrayDemo01.main(ArrayDemo01.java:17)			//数组下标越界

数组初始化

静态初始化

int[] a = {1,2,3,4,5};
System.out.println(a[0]);

动态初始化(包含默认初始化)

int[] b = new int[10];
b[0] = 10;			//默认初始值都是0
System.out.println(b[0]);

数组的特点

长度固定，创建之后无法改变
数组元素必须是相同类型
数组元素可以是任何数据类型，包括基本类型和引用类型
数组变量属于引用类型，数组可以看成是对象
数组对象本身在堆中

数组的使用

基本用法：

普通for循环用来返回特定数组元素值

package Array;
public class ArrayDemo03 {
    public static void main(String[] args){
        int[] arrays = {1,2,3,4,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++) {                    //用了0，下标就从1开始
            if(arrays[i] > max){
                max = arrays[i];
            }
        }
        System.out.println("最大元素是："+max);
}
}
结果：
1
2
3
4
5
----------------
sum = 15
----------------
最大元素是：5

进阶用法

For-Each循环用来打印数组结果

package Array;
public class ArrayDemo04 {
    public static void main(String[] args){
        int[] arrays = {1,2,3,4,5,};
        //JDK1.5    没有下标
        for (int a : arrays) {          //arrays.for(每个元素：数组名):增强型的for循环
            System.out.println(a);
        }
     }
}
结果：
1
2
3
4
5

数组入参

package Array;
public class ArrayDemo04 {
    public static void main(String[] args){
        int[] arrays = {1,2,3,4,5,};
        printArray(arrays);
    }
        //打印数组元素
        public static void printArray(int[] arrays){
            for(int i = 0; i < arrays.length; i++) {
                System.out.print(arrays[i]+" ");
            }
        }
}
结果：
1 2 3 4 5

数组作为返回值

package Array;
public class ArrayDemo04 {
    public static void main(String[] args){
        int[] arrays = {1,2,3,4,5};
        int[] Reverse = Reverse(arrays);
        printArray(Reverse);
    }
    //打印数组元素
        public static void printArray(int[] arrays){
            for(int i = 0; i < arrays.length; i++) {
                System.out.print(arrays[i]+" ");
            }
        }
    //反转数组
    public static int[] Reverse(int[] arrays){
        int[] result = new int[arrays.length];               //定义要返回的数组
        for(int i = 0; i <= arrays.length-1; i++) {          //当i < arrays.length-1时，输出结果是0，4,3,2,1 
            result[arrays.length-i-1] = arrays[i];
        }
        return result;
    }
}
结果：
5 4 3 2 1

多维数组

数组嵌套了数组

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qRjmqqp5-1649751902611)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220411165341077.png)]$

多维数组定义：

package Array;
public class ArrayDemo05 {
    public static void main(String[] args){
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
}
}

package Array;
public class ArrayDemo05 {
    public static void main(String[] args){
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        System.out.println(array[0]);
}
}
结果：
[I@119d7047
//当插入 //打印数组元素
        public static void printArray(int[] arrays){
            for(int i = 0; i < arrays.length; i++) {
                System.out.print(arrays[i]+" ");
            }
        }

结果：
1 2

package Array;
public class ArrayDemo05 {
    public static void main(String[] args){
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        System.out.println(array[1][1]);
        System.out.println(array.length);
        System.out.println(array[0].length);
        for(int i = 0; i < array.length; i++) {
            for(int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
        }
    }
}

结果：
3
4
2
1 2 2 3 3 4 4 5

Arrays类

可以在JDK里查看Arrays类的详细说明

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zRJJKgcj-1649751902612)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220411205300572.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-16GaCwt8-1649751902613)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220411205651489.png)]$

ctrl+左键点击Arrays查看源码

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NGWHlJf8-1649751902614)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220411205751582.png)]$

点击structure查看具体的方法(类似于目录），这些方法都是static修饰的静态方法，在使用的时候可以直接用类名进行调用。

package Array0;
import java.util.Arrays;
public class ArrayDemo06 {
    public static void main(String[] args){
        int[] a = {1,2,3,4,9009,1221,232,43,2131};
        System.out.println(a);      //[I@119d7047  结果是哈希code
        //打印数组元素
        System.out.println(Arrays.toString(a)); //将数组转化成String类型，这样输出就不报错了
        printArray(a);
        Arrays.sort(a);         //将数组a排序，此时数组a已经有序了
        System.out.println(Arrays.toString(a));//要输出数组只能用.toString()
        Arrays.fill(a,2,4,0);   //填充数组  这里不用打"val:0"    把[2,4)填充成0
        System.out.println(Arrays.toString(a));
    }
    //重复造轮子
    public static void printArray(int[] b){
        for(int i = 0; i < b.length; i++) {             //学习一下这个for循环
            if(i==0){
                System.out.print("[");
            }
            if(i==b.length-1){
                System.out.println(b[i]+"]");
            }else{
                System.out.print(b[i]+", ");
            }
        }
    }
}

结果:
[I@119d7047
[1, 2, 3, 4, 9009, 1221, 232, 43, 2131]
[1, 2, 3, 4, 9009, 1221, 232, 43, 2131]
[1, 2, 3, 4, 43, 232, 1221, 2131, 9009]
[1, 2, 0, 0, 43, 232, 1221, 2131, 9009]

冒泡排序

介绍八大排序中的冒泡排序：外层冒泡轮数，内层依次比较

时间复杂度O（n²）

package Array;
import java.util.Arrays;
public class ArrayDemo07 {
    public static void main(String[] args){
        int[] a = {1,3,42,52,234,12,5,23};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    //冒泡排序: ①比较数组中，两个相邻元素，如果第一个数比第二个数大，就交换位置    ②每轮比较都会产生一个最大或者最小的数字    ③则下一轮可以少一次排序    ④依次循环，直到结束
    public static void sort(int[] m){	//当int[]时，要return m 剩下全都不变
        int n = 0;
        for(int i = 0; i < m.length; i++) {
            for(int j = i; j < m.length; j++) {
                if(m[i]>m[j]){
                    n = m[i];
                    m[i] = m[j];
                    m[j] = n;		//出现问题的时候用Debug一行行的过就可以发现错误，别慌
                }
            }
        }
    }
}

结果：
[1, 3, 5, 12, 23, 42, 52, 234]

package Array;
import java.util.Arrays;
public class ArrayDemo07 {
    public static void main(String[] args){
        int[] a = {2,43,112,54,63,13,2342,1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    //冒泡排序: ①比较数组中，两个相邻元素，如果第一个数比第二个数大，就交换位置    ②每轮比较都会产生一个最大或者最小的数字    ③则下一轮可以少一次排序    ④依次循环，直到结束
    public static int[] sort(int[] m){
        int n = 0;
        for(int i = 0; i < m.length-1; i++) {
            boolean flag = false;   //通过flag减少没有意义的比较
            for(int j = 0; j < m.length-i-1; j++) {
                if(m[j]>m[j+1]){
                    n = m[j];
                    m[j] = m[j+1];
                    m[j+1] = n;
                    flag = true;
                }
            }
            if(flag == false) {break;}
        }
        return m;
    }
}

结果：
[1, 2, 13, 43, 54, 63, 112, 2342]

稀疏数组

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xgrr9GDl-1649751902615)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220412110317802.png)]$

当数组中大部分元素是0，或者为同一值时，可以使用稀疏数组来保存。

稀疏数组的处理方式：

几行几列，多少个不同值
把具有不同值的元素和行跟列记录在一个小规模的数组中，缩小程序的规模 $[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JsQj9Yrq-1649751902615)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220412110814332.png)]$

package Array;
public class ArrayDemo08 {
    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[] row : array1) {              //array1.for + Enter    这两个for循环多走几遍
            for (int col : row) {
                System.out.print(col+"\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+=1;
            }
        }
        System.out.println("有效值个数为："+sum);

        //2.创建一个稀疏数组
        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];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组为：");
        for(int i = 0; i < array2.length; i++) {
            for(int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j]+"\t");        //这里用" "会出现稀疏数组对不齐的情况
            }
            System.out.println();
        }
        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];
        }
        //3.打印
        System.out.println("输出还原的数组：");
        for (int[] a : array3) {
            for (int b : a) {
                System.out.print(b+"\t");
            }
            System.out.println();
        }
    }
}

结果:
输出原始的数组：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
有效值个数为：2
稀疏数组为：
11	11	2	
1	2	1	
2	3	2	
+++++++++++++++++++++++++++++++++++++++++++++++++
还原稀疏数组：
输出还原的数组：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0