java第七课——数组

知行&

已于 2023-01-20 23:22:39 修改

阅读量974

点赞数 1

分类专栏： Java语法文章标签： java 开发语言

于 2022-03-30 20:50:04 首次发布

本文链接：https://blog.csdn.net/baijaiyu/article/details/123717291

版权

Java语法专栏收录该内容

15 篇文章 9 订阅

订阅专栏

7.1.2方法2：for-each循环打印（增强for循环）

7.1.3借助Java本身提供的一些方法来实现数组的打印

7.2数组的拷贝

7.2.1使用for循环进行拷贝

7.2.2借助Java本身提供的copyOf方法来实现数组的拷贝

7.2.3借助Java本身提供的System.arraycopy方法来实现数组的拷贝

7.2.4直接调用array.clone()方法

八：二维数组

8.1基本语法

8.2具体实例

一：数组的定义

数组：可以看成是相同类型元素的一个集合。比如：在操场升旗的同学可以构成一个学生数组，在草坪上修沟的修狗可以构成一个汪汪队数组。

二：数组的创建

T[ ] 数组名 = new T[N];
T：表示数组中存放元素的类型；
T[ ]：表示数组的类型；
N：表示数组的长度；

具体实例如下：

int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new String[6]; // 创建一个可以容纳6个字符串元素的数组

三：数组的初始化

3.1动态初始化

在创建数组时，仅指定数组中元素的个数。

int[] array = new int[10];

3.2.静态初始化

在创建数组时，直接指定具体的数据内容。

int[ ] array1 = new int[ ]{0,1,2,3,4,5,6,7,8,9};
double[ ] array2 = new double[ ]{1.0, 2.0, 3.0, 4.0, 5.0};
String[ ] array3 = new String[ ]{"hello", "wahaha", "!!!!!"};

静态初始化也可以简写为：

int[ ] array1 = {0,1,2,3,4,5,6,7,8,9};
double[ ] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[ ] array3 = {"hell", "Java", "!!!"};

注意：静态初始化虽然没有指定数组的长度，编译器在编译时会根据{ }中元素个数来确定数组的长度。

初始化过程也可以分为两步：

int[ ] array1;
array1 = new int[10];
int[ ] array2;
array2 = new int[]{10, 20, 30};

四：遍历数组

4.1for循环遍历数组

注意，我们可以使用array.length获取数组的长度。具体代码如下：

public class Test {

    public static void main(String[] args) {
        int[]array = new int[]{10, 20, 30, 40, 50};
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }
    }
}

运行结果如下：

4.2for-each遍历数组

是for循环的另一种格式，具体代码如下：

public static void main(String[] args) {
    int[] array = {1, 2, 3};
    for (int x : array) {
        System.out.println(x);
    }

运行结果如下：

五：数组是引用类型

5.1初始JVM内存分布

基础须知：内存的概念。

内存是一段连续的存储空间，主要是用来存储程序运行时数据的。如果对内存中存储的数据不加区分的随意存储，内存管理将会非常麻烦。一个比较合适的解决方案，就是对内存进行合理划分，自然结构分明，逻辑清晰。

JVM就对所使用的内存按照功能的不同进行了划分：

这里提到线程的概念，线程其实是操作系统能够进行运算调度的最小单位。坦白讲，线程和我们这课的关系并不大。假设线程就是A,B,C这样的“一些个体”，那么所有蓝色块，即方法区和堆，是所有个体共享的；所有紫色块，即虚拟机栈、本地方法栈和程序计数器，是每个个体所独有的，也就是“线程隔离”。

在本课中，我们只关心堆和虚拟机栈这两块空间。

虚拟机栈(JVM Stack): 与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。
堆(Heap): JVM所管理的最大内存区域。使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2 , 3} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。

5.2基本类型变量和引用类型变量

public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}

在上述代码中，a、b、arr，都是函数内部的变量，因此其空间都在main方法对应的栈帧中分配。

a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。

arr是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。

引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。如下图：

5.3再次理解引用

思考下面代码的输出结果：


    public static void main(String[] args) {
        int[] array1 = new int[3];
        array1[0] = 10;
        array1[1] = 20;
        array1[2] = 30;
        int[] array2 = new int[]{1, 2, 3, 4, 5};
        array2[0] = 100;
        array2[1] = 200;//100 200 3 4 5
        array1 = array2;
        array1[2] = 300;//100 200 300 400 500
        array1[3] = 400;
        array2[4] = 500;
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
    }

运行结果如下：

分析：

一开始，情况是这样的：

此时array2引用的对象可以通过下标进行改变，所以当执行array2[0] = 100；array2[1] = 200;

数组中元素发生改变：

此时执行array1 = array2，意味着array1这个引用引用了array2所引用的对象，其指向发生了变化：

这时两个引用指向同一个对象，通过这两个引用，都可以修改原来array2所引用的对象，执行 array1[2] = 300;array1[3] = 400;array2[4] = 500，最终数组元素变为：

5.4null

null 在 Java 中表示 "空引用" , 也就是一个不指向任何对象的引用。如：

    public static void main(String[] args) {
        int[] arr = null;
        System.out.println(arr[0]);
    }

运行结果如下：

发生了空引用异常，因为这个引用没有指向任何对象，当然无法打印其中的内容。如果你的程序在运行过程中也出现了类似的报错信息，先查看下是否出现空引用。

六：数组的应用场景

6.1保存数据

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

6.2 作为函数的参数

public class Test {

    public static void func(int[] a) {
        a[0] = 10;
        System.out.println("a[0] = " + a[0]);
    }
    
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        func(arr);
        System.out.println("arr[0] = " + arr[0]);
    }
}

运行结果如下：

这里数组作为参数传递给了func()函数，并且对a[0]进行赋值操作。

6.3作为函数的返回值


public class Test {

    public static int[] func5() {
        int[] array = {1,2,3,4};
        return array;
    }

    public static void main(String[] args) {
        int[] ret = func5();
        System.out.println(Arrays.toString(ret));
    }

}

运行结果如下：

七：数组练习

我们会讲解几道习题，在讲解过程中会涉及到Java 中提供了的java.util.Arrays 包, 其中包含了一些操作数组的常用方法。

注意：为简化书写，以下的代码均在类中实现，但不再体现在代码中。

7.1打印数组

7.1.1方法1：for循环打印

    public static void main(String[] args) {
        int[] array = {1,2,3};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }

运行结果如下：

IDEA中，for循环快捷键为：输入itar按Tab

7.1.2方法2：for-each循环打印（增强for循环）

    public static void main(String[] args) {
        int[] array = {1,2,3};
        for (int i : array) {
            System.out.println(i);
        }
    }

运行结果如下：

IDEA中，for循环快捷键为：输入iter按Tab

7.1.3借助Java本身提供的一些方法来实现数组的打印

import java.util.Arrays;
   
public static void main(String[] args) {
        int[] array = {1,2,3};
        String ret = Arrays.toString(array);//把参数的数组  转换为字符串进行输出
        System.out.println(ret);
    }

导入java.util.Arrays包后，利用Arrays.toString方法，将数组名传入，并用字符串类型的变量接受返回值，进行输出。这就是Arrays.toString方法，可以把参数的数组转换为字符串。

查阅文档，所有的toString方法构成了重载，其返回值均为String类型。

7.2数组的拷贝

7.2.1使用for循环进行拷贝

    /**
     * 使用for循环进行拷贝
     * @param args
     */
    public static void main(String[] args) {
        int[] array = {1,2,3,4};

        int[] copy = new int[array.length];

        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }

        System.out.println(Arrays.toString(copy));
    }

运行结果如下：

7.2.2借助Java本身提供的copyOf方法来实现数组的拷贝

    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        int[] copy = Arrays.copyOf(array,array.length);
        System.out.println(Arrays.toString(copy));
    }

运行结果如下：

查阅文档，所有的copyOf()构成了重载，其返回值均为对应的数组类型。

7.2.3借助Java本身提供的System.arraycopy方法来实现数组的拷贝

    /**
     * 第3种拷贝方式 System.arraycopy
     * @param args
     */
    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        int[] copy = new int[array.length];

        System.arraycopy(array,0,copy,0,array.length);

        System.out.println(Arrays.toString(copy));

    }

以下是该方法的官方文档资料，有兴趣的同志可以查看。关键是抓住这五个参数：

注意：java.lang.*下的包由java自动导入，所以这里我们没有进行导入包操作。

7.2.4直接调用array.clone()方法

    /**
     * 第4种拷贝方式 array.clone()
     * @param args
     */
    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        int[] copy = array.clone();
        System.out.println(Arrays.toString(copy));
    }

运行结果如下：

八：二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组。

8.1基本语法

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

8.2具体实例

    public static void main(String[] args) {
        int[][] arr = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12}
        };
        for (int row = 0; row < arr.length; row++) {
            for (int col = 0; col < arr[row].length; col++) {
                System.out.printf("%d\t", arr[row][col]);
            }
            System.out.println("");
        }
    }

运行结果如下：

arr.length——>行数
arr[row].length——>列数

二维数组的用法和一维数组并没有明显差别, 因此我们不再赘述.

同理, 还存在 "三维数组", "四维数组" 等更复杂的数组, 只不过出现频率都很低。

本课内容结束！

知行&

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
java第七课——数组

一：数组的定义数组：可以看成是相同类型元素的一个集合。二：数组的创建T[ ] 数组名 = new T[N];T：表示数组中存放元素的类型；T[]：表示数组的类型；N：表示数组的长度；具体实例如下：int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组String[] array3 = new double[
复制链接

扫一扫