当前位置：首页 » 《资源分享》 » 正文

【 JavaSE 】 深入数组_CS_z_jun的博客

2 人参与  2021年09月13日 07:43  分类 : 《资源分享》  评论

点击全文阅读


目录

前言

一维数组

创建一维数组

一维数组的使用

数组作参数

认识 JVM 内存区域划分

数组做参数基本用法

理解引用类型

认识 null

数组作为方法的返回值

二维数组

二维数组的长度

二维数组的遍历

数组练习

前言

本章主要讲解：

  1. 一维数组的定义和使用
  2. 数组在内存的基本存储知识
  3. 二维数组的定义和使用
  4. 数组练习

一维数组

  • 什么是数组：

数组本质上就是让我们能 "批量" 创建相同类型的变量（相同的类型）

注：特别是表示大量的数据，用数组非常便捷

创建一维数组

  • 基本语法：
// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };
  • 示例：
int[] arr = new int[]{1, 2, 3};
int[] arr = new int[3];	// 默认元素为0
int[] arr = {1, 2, 3};

注：静态初始化的时候, 数组元素个数和初始化数据的格式要一致

一维数组的使用

  • 示例：
int[] arr = {1, 2, 3};
// 获取数组长度（本身属性）
System.out.println("length: " + arr.length); // 执行结果: 3
// 访问数组中的元素
System.out.println(arr[1]); // 执行结果: 2
System.out.println(arr[0]); // 执行结果: 1
arr[2] = 100;
System.out.println(arr[2]); // 执行结果: 100
  • 注意：
  1. 使用arr.length能够获取到数组的长度：. 这个操作为成员访问操作符（进行修改和读取）
  2. 使用[ ]按下标取数组元素, 下标从0开始计数（[]写在变量名前后都行）
  3. 下标访问操作不能超出有效范围 [0, length - 1] ，否则会出现下标越界
  4. 数组类型中 [] 内不能写数值
  • 示例：遍历数组
//循环遍历
int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}
//用 for-each 遍历
int[] arr = {1, 2, 3};
for (int x : arr) {
    System.out.println(x);
}
//使用 Arrays 类中的 toString 方法(toString的功能就是将当前的数组转换成字符串的形式返回)
// 使用 Arrays 类前先导入它的包
import java.util.Arrays;
public class TestDemo{
    public static void main(Strings[] args){
        int[] array = {1, 2, 3};
        String ret = Arrays.toString(array);
        System.out.println(ret);
    }
}
// 输出结果：[1, 2, 3]

数组作参数

认识 JVM 内存区域划分

一个 Java 文件的执行需要先通过编译变成字节码文件，字节码文件再通过 Java 虚拟机运行

  •  JVM 内存划分：

  • 各区域作用：
  1. 程序计数器：是一个很小的空间，保存下一条执行的指令地址
  2. Java 虚拟机栈：这就是我们平常说的栈，它重点是存储局部变量（如创建的数组的存储地址的引用就存在这里）
  3. 本地方法栈：本地方法栈与虚拟机栈的作用类似，只不过保存的内容是 Native 方法（ Java 中调用的一些 C++ 实现的函数）的局部变量
  4. 堆：这就是我们平常说的堆，是 JVM 所管理的最大的内存区，使用 new 创建的对象都是在堆上保存
  5. 方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据（方法编译出的字节码就是保存在这里）
  6. 运行时常量池：这个是方法区的一部分用来存放字面量（字符串常量）与符号引用（注意：从 JDK 1.8 开始，运行时常量池在堆上）

数组做参数基本用法

结论：数组为引用类型，数组做参数传递的是地址

  • 示例：打印数组内容
public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    printArray(arr);
}
public static void printArray(int[] a) {
    for (int x : a) {
        System.out.println(x);
    }
}
//int[] a 是函数的形参, int[] arr 是函数实参

理解引用类型

  • 示例：参数传内置类型
public static void main(String[] args) {
    int num = 0;
    func(num);
    System.out.println("num = " + num);
}
public static void func(int x) {
    x = 10;
    System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0

注：修改形参 x 的值, 不影响实参的 num 值（形参是实参的一份临时拷贝：开辟另一个空间来存实参的内容，修改形参与实参无关）

  • 示例：参数传数组类型
public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    func(arr);
    System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
    a[0] = 10;
    System.out.println("a[0] = " + a[0]);
}
// 执行结果
a[0] = 10
arr[0] = 10

注：此时数组名 arr 是一个 "引用" ：当传参的时候, 是按照引用传参（找到对应元素空间，直接对元素内容）

简单类比：引用相当于一个 "别名", 也可以理解成一个指针

创建一个引用只是相当于创建变量来保存一个整数, 这个整数表示内存中的一个地址

  • 图解：对于上述例题

而修改 a[0]是根据 0x100 这样的地址找到对应的内存位置, 将内容改成 100

注：传地址可以避免对整个数组的拷贝(特别是长数组, 拷贝开销会很大）

认识 null

null 在 Java 中表示 "空引用" , 也就是一个无效的引用(不能进行访问)

作用类似C语言中NULL (空指针), 都是表示一个无效的内存位置，但Java并没有约定 null 和 0 号地址的内存有任何关联

  • 示例：
int[] arr = null;
System.out.println(arr[0]);//err

数组作为方法的返回值

  • 示例：写一个方法, 将数组中的每个元素都 * 2
// 直接修改原数组
class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        transform(arr);
        printArray(arr);
    }
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void transform(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] = arr[i] * 2;
        }
    }
}
//破坏原有数组

// 返回一个新的数组
class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] output = transform(arr);
        printArray(output);
    }
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static int[] transform(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i] * 2;
        }
    return ret;
    }
}
//返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效

二维数组

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

  • 基本语法：
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
  • 示例：
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("");
}
// 执行结果
1 2 3 4
5 6 7 8
9 10 11 12

注意：在 Java 当中的二维数组不能省略行，但可以省略列

  • 示例：
int[][] array = new int[2][];

注意：但需要正常打印前，需要初始化，不然二维数组元素都为 null

//不规则二维数组(列是不确定)
int[][] array = new int[2][];
array[0] = new int[4];
array[1] = new int[2];
System.out.println(Arrays.deepToString(array));
//打印结果为：[[0, 0, 0, 0], [0, 0]]

二维数组的长度

  • 示例：
int[][] array = {{1, 2, 3}, {4, 5, 6}};
System.out.println(array.length);//array为整个二维数组
//输出结果：2（两个元素）
System.out.println(array[0].length);//array[0]为二维数组第一个元素，即一维数组
System.out.println(array[1].length);
// 输出结果：3 3

注：对于不规则二维数组求长度同样适用

二维数组的遍历

//使用 for 循环遍历打印
int[][] array = {{1, 2, 3}, {4, 5, 6}};
for(int i = 0; i < array.length; i++){
    for(int j = 0; j < array[0].length; j++){
        System.out.println(arrat[i][j] + " ");
    }
}
//使用 for-each 遍历打印
int[][] array = {{1, 2, 3}, {4, 5, 6}};
for(int[] arr : array){//二维数组的元素为一维数组，即int[] arr
    for(int x : arr){//一维数组的元素为int元素，即int x
        System.out.println(x);
    }
}
//使用 Arrays.deepToString 打印
int[][] array = {{1, 2, 3}, {4, 5, 6}};
System.out.println(Arrays.deepToString(array));

数组练习

  • 例题1：数组转字符串（模拟实现 toString ）

示例：

public static String myToString(int[] array){
    String str = "[";
    for(int i = 0; i < array.length; i++){
        if(i == 0){
            str +=array[i];
        }else{
            str +=", " + array[i];
        }
    }
    str += "]";
    return str;
}
//如果还想完善的话，注意数组长度为0或者数组为 null 的情况
  • 例题2：数组拷贝

示例1：

// for 循环拷贝
public static int[] copyArray(int[] array){
    int[] newArray = new int[array.length];
    for(int i = 0; i < array.length; i++){
        newArray[i] = array[i];
    }
    return newArray;
}

示例2：

//使用 Array 包的工具类
//copyOf(原数组，要返回的副本的长度)方法
int[] array = {1, 2, 3};
int[] ret1 = Arrays.copyOf(array ,array.length);
System.out.println(Arrays.toString(ret1));
//copyOfRange(原数组，起始索引值，终点索引值的后一个值)方法
//这里的起点和终点(下标)范围是一个左闭右开区间，如下示例范围为：[1,3) （java中大部分都是如此）
int[] ret2 = Arrays.copyOfRange(array ,1, 3);
System.out.println(Arrays.toString(ret2));
// 输出结果：[2, 3]

示例3：

//本地方法（native） arraycopy(原数组（src）,原数组的起始位置（srcPos）,目的数组（dest）,目的数组（dest）的起始位置（destPos）)
int[] array = {1, 2, 3};
int[] ret3 = new int[array.length];// length 不能超过原数组的长度,否则越界
System.arraycopy(array, 0, ret5, 0, array.length);
System.out.println(Arrays.toString(ret3));
// 输出结果：[1, 2, 3]

示例4：

//调用对象的 clone() 方法
int[] array = {1, 2, 3};
int[] ret4 = array.clone();
System.out.println(Arrays.toString(ret4));
// 输出结果：[1, 2, 3]
  • 对于拷贝有深浅之分：

深拷贝：拷贝数组的数据（基本数据类型），修改拷贝数组不改变原数组数据

浅拷贝：拷贝数组的地址（引用类型），修改拷贝数组改变原数组数据

  • 例题3：找数组中的最大元素

示例：

public static void main(String[] args){
    int[] array = {1,4,5,9,2};
    System.out.println(maxNum(array));
}
public static int maxNum(int[] array){
    int max = array[0];
    for(int i = 1; i < array.length; i++){
        if(array[i] > max){
            max = array[i];
        }
    }
    return max;
}
  • 例题4：查找数组中指定元素（顺序查找）

示例：

public static int findNum(int[] array, int x){
    for(int i = 0; i < array.length; i++){
        if(array[i] == x){
            return i;
        }
    }
    return -1;
}
  • 例题5：检查数组的有序性（升序数组）

示例：

public static boolean isSorted(int[] array){
    for(int i = 0; i < array.length - 1; i++){
        if(array[i] > array[i+1]){
            return false;
        }
    }
    return true;
}
  • 例题6：数组排序（冒泡排序）

示例：

public static void dubbleSort(int[] array){
    for(int i = 0; i < array.length - 1; i++){
        boolean flg = false;
        for(int j = 0; j < array.length - i - 1; j++){
            if(array[j] > array[j + 1]){
                int tmp = array[j];
                array[j] = array[ j + 1];
                array[j  + 1] = tmp;
                flg = true;
            }
        }
        if(flg == true){
            break;
        }
    }
}
  • 例题7：数组数字排序（偶数放在数组前半部分，将所有的奇数放在后半部分）

示例：

public static void sort(int[] array){
    int left = 0;
    int right = array.length - 1;
    while(left < right){
        while(left < right && array[left] % 2 == 0){
            left++;
        }
        while(left < right && array[right] % 2 != 0){
            right--;
        }
        if(left < right){
            int tmp =array[left];
            array[left] = array[right];
            array[right] =tmp;   
        }
    }
}


点击全文阅读


本文链接：http://zhangshiyu.com/post/27688.html

数组  示例  拷贝  
<< 上一篇 下一篇 >>

  • 评论（0）
  • 赞助本站

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

最新文章

  • 小说《绝世师尊：孽徒太放肆》在线阅读
  • 错爱这本小说怎么样？免费在线阅读试试
  • 绝世师尊：孽徒太放肆姜宁，绝世师尊：孽徒太放肆在线阅读
  • 《特种兵：曝光后拒绝何志军特招》小说好看吗 孟南何志军最后结局如何
  • 小说《解锁美食系统，亲戚都馋哭了》全文免费阅读
  • 解锁美食系统，亲戚都馋哭了小说无删减免费阅读
  • 完整版的我和冤种闺蜜一起穿越了小说在哪里可以免费读到？
  • 在线寻找我死后夫君悔不当初小说的无删减版本
  • 我被装行李箱送人，我爸知道后杀疯了杨维小说在线章节目录阅读最新章节
  • 笨蛋女记者闺蜜弄坏了我的网球拍小说的免费电子版在哪里可以下载或阅读？
  • 已完结小说《我被装行李箱送人，我爸知道后杀疯了》在线章节阅读
  • 攻略你你不理，撩了别人你别急免费阅读全文，主角苏北栀陆闻小说完整版最新章节

    关于我们 | 我要投稿 | 免责申明

    Copyright © 2020-2022 ZhangShiYu.com Rights Reserved.豫ICP备2022013469号-1