Java基础笔记（五）【数组】

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量65 收藏
点赞数
分类专栏： Java 文章标签： java 笔记 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45480682/article/details/131074618
版权

1. 数组定义

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

2. 数组声明和创建

  • 首先必须声明数组变量，才能在程序中使用数组。

    dataType[] arrayRefVar;//首选的方法
或![在这里插入图片描述](https://img-blog.csdnimg.cn/7e51513c6a374fa3b6cbab7d68f6d3f4.png)

dataType arrayRefVar[];//效果相同，但不是首选方法,c/c++用的形式

  • Java中使用new操作符来创建数组

    dataType[] arrayRefVar = new dataType[arraySize];

  • 数组的元素是通过索引访问的，数组索引从0开始

  • 获取数组长度：arrays.length()

    int类型默认值为0，string类型默认值为null

    public static void main(String[] args) {
        int[] array01;//1. 声明数组
        array01 = new int[10];//2. 创建一个数组
                              //可以存放10个int类型的数字
        int[] array02 = new int[5];//声明和创建合成一句
        int value = 1;//3. 给数组中元素赋值
        int sum = 0;
        for (int i = 0; i < array01.length; i++) {
            array01[i] = value++;
            sum += array01[i];
            System.out.print(array01[i]+"\t");
        }
        System.out.println();
        System.out.println("总和为：" + sum);
}

    //输出
1	2	3	4	5	6	7	8	9	10	
总和为：55

  • 数组的4个基本特点

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

3. Java内存分析

  • new事件都在堆里面

在这里插入图片描述

  • 初始声明一个数组在栈中，分配内存在堆中，如果数组长度为10，则十个数组元素在同一块内存中，如有超过下标的，不在内存中。

在这里插入图片描述

  • 常见的报错：【数组下标越界】java.lang.ArrayIndexOutOfBoundsException

4. 三种初始化：

  • 静态初始化：
  • 动态初始化：
  • 数组的默认初始化：
    • 数组是引用类型，它的元素相当于类的实例变量。数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
public static void main(String[] args) {
        //静态初始化：创建+赋值
        int[] a = {1,2,3,4,5,6};
        System.out.println(a[0]);

        //动态初始化：包含默认初始化
        int[] ints = new int[10];
        ints[0] = 3;
        System.out.println(ints[0]);
        System.out.println(ints[1]);//默认初始化值为0
        System.out.println(ints[2]);//默认初始化值为0
        System.out.println(ints[3]);//默认初始化值为0
        System.out.println(ints[4]);//默认初始化值为0
}

小结：

  1. 数组是相同数据类型（数据类型可以为任意类型）的有序集合
  2. 数组也是对象（因为是new出来的）。数组元素相当于对象的成员变量。
  3. 数组的长度是确定的，不可变的。如果越界就会报错。

5. 数组使用

  • 基础使用

    • 普通的for循环
    public static void main(String[] args) {
        //1. 打印所有元素
        int[] array = {6,7,8,9,10,1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.println("array["+i+"]:"+array[i]);
        }
        //2. 计算所有元素的和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println("array的元素和为："+sum);
        //3. 查找最大元素
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            //下标从1开始减少一次循环
            if (array[i]>max){
                max = array[i];
            }
        }
        System.out.println("array中最大的元素为：" + max);
}

    //输出
array[0]:6
array[1]:7
array[2]:8
array[3]:9
array[4]:10
array[5]:1
array[6]:2
array[7]:3
array[8]:4
array[9]:5
array的元素和为：55
array中最大的元素为：10

  • 进阶使用

    • foreach循环（省去了数组下标）
    • 数组作方法入参
    • 数组作返回值
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};
        //jdk 1.5以上版本开始有的，省去了数组下标
//        for (int array : arrays) {
//            System.out.println(array);
//        }
//        //数组作为方法的参数
//        printArray(arrays);
        int[] reverse = reverse(arrays);
        printArray(arrays);//打印反转后的
        printArray(reverse);//打印反转后的
    }
    //打印数组元素
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

    //反转数组
    public static int[] reverse(int[] array){
        int[] ints = new int[array.length];
        for (int i = 0, j = array.length-1; i < array.length; i++,j--) {
               ints[j] = array[i];
        }
        return ints;
}

    //输出
1 2 3 4 5 6 
6 5 4 3 2 1

6. 多维数组

可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其中每个元素都是一个一维数组。

int a[][] = new int[2][5]

以上二维数组a可以看成一个两行五列的数组。

在这里插入图片描述

二维数组：

 	public static void main(String[] args) {
        //即：4行2列数组
        /*
             1 2    doubleArray[0]
             2 3    doubleArray[1]
             3 4    doubleArray[2]
             4 5    doubleArray[3]
         */
        int[][] doubleArray = {{1,2},{2,3},{3,4},{4,5}};
        //直接打印doubleArray[0]，打印的是地址，可以借助取值方法来输出。
        System.out.println(doubleArray[0]);
        printArray(doubleArray[0]);
        System.out.println(doubleArray[0][0]);
        System.out.println(doubleArray[0][1]);
        //打印长度
        System.out.println(doubleArray.length);
        System.out.println(doubleArray[0].length);
        //打印每一个元素
        for (int i = 0; i < doubleArray.length; i++) {
            for (int j = 0; j < doubleArray[i].length; j++) {
                System.out.print(doubleArray[i][j] + " ");
            }
        }
    }

    //打印数组元素
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

[I@1540e19d
1 2 
1
2
4
2
1 2 2 3 3 4 4 5

三维数组：

	public static void main(String[] args) {
        int[][][] a = {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}}};
        printArray(a);
    }
    //打印方法
    public static void printArray(int[][][] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                for (int k = 0; k < array[i][j].length; k++) {
                    System.out.print(array[i][j][k]+" ");
                }
            }
        }
    }

//输出
1 2 3 4 5 6 7 8 9 10 11 12

7. Arrays类

在这里插入图片描述

  • Arrays.toString()：打印数组元素

    	public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(a));//打印数组元素
        //这种工具类也可以自己写，但是不建议重复造轮子，可以了解原理
        printArray(a);
    }
    //自己写打印方法
    public static void printArray(int[] array){
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length-1){
                System.out.print(array[i]);
            }else {
                System.out.print(array[i]+", ");
            }
        }
        System.out.print("]");
    }

    //输出
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]

  • Arrays.sort()：对数组进行排序（升序）

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

    [1, 2, 3, 4, 5, 6]

  • Arrays.fill()：数组填充

    public static void main(String[] args) {
        int[] a = {4,5,6,1,2,3};
        //数组填充
        Arrays.fill(a, 0);//所有元素填充0
        System.out.println(Arrays.toString(a));
}

    [0, 0, 0, 0, 0, 0]

    public static void main(String[] args) {
        int[] a = {4,5,6,1,2,3};
        //数组填充
        Arrays.fill(a, 2,3,0);//2≤x<3之间元素填充0
        System.out.println(Arrays.toString(a));
}

    [1, 2, 0, 4, 5, 6]

8. 冒泡排序

最出名的排序算法之一（总共有八大排序）

在这里插入图片描述

思想：

  1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置
  2. 每一次比较，都会产生出一个最大或者最小的数（则之后的循环比较就可以比上一次少1）
  3. 下一轮则可以少一次排序
  4. 依次循环，直到结束
//优化：通过flag标识位减少没有意义的比较，已经有序的情况下不需要再进行比较
	public static void main(String[] args) {
        int[] a = {1,5,3,7,8,2};
        bubbleSort(a);
        System.out.println(Arrays.toString(a));
    }
    public static void bubbleSort(int[] array){
        //升序为例
        //外层循环：n个数需要n-1次
        int temp ;
        int count = 0;//排序进行的次数
        for (int i = 0; i < array.length-1; i++) {
            //内存循环：当前数值与后一位数值作比较
            boolean flag = false;
            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;
                }
            }
            count++;
            if (flag == false){
                break;
            }
        }
        System.out.println(count);
    }

9. 稀疏数组

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

  • 首先记录数组有几行几列，有多少个不同的值

  • 把具有不同值的元素、行列、值记录在一个小规模的数组中，从而缩小程序的规模。

在这里插入图片描述

public static void main(String[] args) {
             //1. 创建一个二维数组 11*11 ，0：表示没有棋子，1：表示黑棋，2：表示白棋
             int[][] ints = new int[11][11];
             ints[1][2] = 1;
             ints[2][3] = 2;
             //原始二维数组
             for (int i = 0; i < ints.length; i++) {
                 for (int j = 0; j < ints[i].length; j++) {
                     System.out.print(ints[i][j]+"\t");
                 }
                 System.out.println();
             }
             System.out.println("----------------------------");
             //转换为稀疏数组保存
             //1.获取有效值的个数
             int count = 0;
             for (int i = 0; i < 11; i++) {
                 for (int j = 0; j < 11; j++) {
                     if (ints[i][j] != 0){
                         count++;
                     }
                 }
             }
             System.out.println("有效值的个数为：" + count);
     
             //2.创建一个稀疏数组
             int[][] sparseArray = new int[count+1][3];
             sparseArray[0][0] = ints.length;
             sparseArray[0][1] = ints[0].length;
             sparseArray[0][2] = count;
             //3.遍历二维数组，将非零元素存入稀疏数组中
             int num = 0;
             for (int i = 0; i < ints.length; i++) {
                 for (int j = 0; j < ints[i].length; j++) {
                     if (ints[i][j] != 0){
                         num++;
                         sparseArray[num][0] = i;
                         sparseArray[num][1] = j;
                         sparseArray[num][2] = ints[i][j];
                     }
                 }
             }
             //4.输出稀疏数组
             for (int i = 0; i < sparseArray.length; i++) {
                 for (int j = 0; j < sparseArray[i].length; j++) {
                     System.out.print(sparseArray[i][j]+"\t");
                 }
                 System.out.println();
             }
             System.out.println("---------------------------");
             //5.还原稀疏数组
             int[][] reArray = new int[sparseArray[0][0]][sparseArray[0][1]];
             for (int i = 1; i < sparseArray.length; i++) {
                 reArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
             }
             //6.打印还原的数组
             for (int i = 0; i < reArray.length; i++) {
                 for (int j = 0; j < reArray[i].length; j++) {
                     System.out.print(reArray[i][j] + "\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
TimberWill
关注
专栏目录
Java基础笔记（数组）
weixin_62618981的博客
03-12 856
概念：数组（array）是一种用于存储多个相同类型数据的存储模型数组的定义格式：（1）格式1：数据类型[ ] 变量名，例如：int [ ] arr。定义了一个int类型的数组，数组名是arr。（2）格式2：数据类型 变量名[ ]， 例如：int arr[ ]。定义了一个int类型的变量，变量名是arr数组。2. 数组静态初始化静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。格式1：数据类型 [ ] 变量名 = new 数据类型[ ] {数据1， 数据2， 数据3， …}
【Java基础笔记】数组
Silence的学习小站
01-28 308
目录前言数组静态初始化数组动态初始化数组动态初始化数组的元素默认值数组的几个注意事项【数组案例1】猜数字游戏【数组案例2】随机排序【数组案例3】冒泡排序（改进版）Java内存分配数组内存分配两个数组变量指向同一个数组对象数组常见异常 前言 该文章为Java基础自学笔记 其他内容：Java基础学习笔记目录 学习用书： 《Java核心技术 卷Ⅰ 基础知识（第10版）》 《Java经典编程300例》 学习视频：https://www.bilibili.com/video/BV1Cv411372m 数组 数组
java学习笔记：数组
weixin_43854404的博客
01-20 900
java学习笔记：数组1.数组(Array)2.数组的常见概念3.数组的特点：4.数组的分类5. 一维数组的使用① 一维数组的声明和初始化1>静态初始化:数组的初始化和数组元素的赋值同时进行**2>动态初始化：数组的初始化数组元素的赋值分开进行② 如何调用数组的指定位置的元素③ 如何获取数组的长度④ 如何遍历数组⑤ 数组元素的默认初始化值⑥ 数组的内存解析 ：见B站 尚硅谷143、144集6.二维数组的使用① 二维数组的声明和初始化1>静态初始化2>动态初始化② 如何调用数组的指
Java学习笔记——数组
Halfway_shen的博客
03-18 538
数组 一、一维数组 1. 定义数组 dataType[] arrayRefVar：类型+[] 变量名(首选方法) dataType arrayRefVar[]：类型 变量名+[] 2. 创建数组 dataType[] arrayRefVar = new dataType[arraySize] arraySize：数值大小 3. 数组初始化 静态初始化、动态初始化、默认初始化 package Practice; public class Prac{ public static void main(S
java基础复习笔记01数组_Java基础复习笔记系列 四 数组
weixin_42513928的博客
02-16 121
Java基础复习笔记系列之数组1、数组初步介绍？Java中的数组是引用类型，不可以直接分配在栈上。不同于C(在Java中，除了基础数据类型外，所有的类型都是引用类型。)Java中的数组在申明时，不能指定其长度。不同于C数组的小标可以是整型常量或整型表达式。.length方法是显示数组的长度；数组.length;String.length();一个是属性，一个是方法。注意区分。2、数组的内存分析？...
java学习笔记之数组比较大小
u014388322的专栏
07-21 1290
代码】java学习笔记之数组比较大小。
java基础复习笔记01数组_Java基础复习笔记01数组,内存形式,父子,内存控制
weixin_39847887的博客
03-08 77
Java基础复习笔记01数组，内存形式，父子，内存控制刘岩Email:suhuanzheng7784877@http://www.doczj.com/doc/4c9ac7bf960590c69ec376bc.html1.前言写这基础复习系列是觉得工作中自己的基础太差了，很多东西都没想透彻，没研究明白。看了《Java基础16课》总结出其中的一些知识点，用于以后自己复习用，以前的一些知识盲点也明白了。...
java笔记 第六章数组
weixin_59335007的博客
06-21 952
数组是一种数据结构，用于存储同一类型的多个元素。数组中的每个元素都有一个固定的位置和索引，索引用于访问数组中的元素。Java 中的数组是对象，数组的大小在创建时确定，且不能改变。Java 提供了可变参数（varargs）机制，允许方法接受不定数量的参数。
自用笔记：java基础语法——数组
xxyxxxqqq的博客
09-12 191
当进行数组内容顺序打乱时有两种方法：1、遍历数组，生成随机索引，将遍历到的数组位置和随机索引的数组位置交换内容。2、遍历数组，生成两个随机索引，把两个随机索引代表的数组内容交换。
java之二维数组
2301_81968528的博客
05-22 507
二维数组和一维数组一样，声明时没有分配空间，必须利用关键字分配空间。先给第一行分配一个一维数组，然后给下面每一列每一行数据赋值。二维数组可以只分配行的长度，不分配列的长度。分配空间有两种方式。java定义二维数组有两种声明方式。数组元素类型 数组名字[][]数组元素类型[][] 数组名字。第二种方式是先分配行，不分配列。如何定义一个二维数组。
Java学习笔记，数组初步
02-06
"Java数组初步" 数组是Java编程语言中的一种基本数据结构，它是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。 1. 数组概述和特点 数组的定义：数组是相同类型...
Java基础学习笔记之数组详解
08-25
总的来说，理解和熟练掌握数组的使用是Java编程的基础，包括如何定义、初始化、遍历以及处理多维数组。这些知识对于编写复杂的程序至关重要。在实际开发中，数组常用于数据的存储和处理，尤其是在算法和数据结构中...
Java-笔记-数组和排序-全
04-19
Java-笔记-数组和排序-全
java关于数组（学习笔记）
12-21
Java中的数组是一种重要的数据结构...总之，数组是Java编程的基础，理解其特性和操作方式对编写高效的代码至关重要。在实际开发中，根据需求选择合适的数据结构，如数组或动态增长的集合类，可以帮助我们优化代码性能。
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。Java以其“一次编写，到处运行”的特性，成为跨平台应用开发的首选语言。Java的基础部分主要包括...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 249
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 563
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Gradle
xiaocaij_icai的博客
09-15 104
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 880
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值