【Java】【数据结构】数组Array（全）

已于 2023-02-09 21:03:13 修改
阅读量667 收藏
点赞数
分类专栏： 数据结构 文章标签： java 数据结构 算法
于 2022-09-22 16:16:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RiceVan/article/details/126992381
版权

文章目录

Java数组

1、数组初始化

// 数组初始化
public static void initArray() {
    int[] arr0 = {1, 2, 3};
    int[] arr1 = new int[]{};
    int[] arr2 = new int[]{1, 2, 3};
    int[] arr3 = new int[5];
    // 求和
    Arrays.stream(arr).sum();
    // 打印
	System.out.println(Arrays.toString(a));
}

2、数组 / List 转换

区分引用数据类型（String）数组、基本数据类型数组 转List。

2.1 String[] / List转换

1、推荐使用集合工具类Collections的addAll()方法将Array转为List。
2、List的toArray()方法将List转为Array。

// String[]数组与List转换
public static void stringArrConvertList() {
    // 一、String[]数组转List
    String[] strArr = new String[3];

    // 1、Arrays.asList()转换后不能支持增删改修改List，不建议
    List<String> strlist1 = Arrays.asList(strArr);
    // strlist1.add("err"); 编译会报错
    System.out.println(strlist1); // [null, null, null]

    // 2、new ArrayList支持增删改，建议写法
    List<String> strList2 = new ArrayList<>(Arrays.asList(strArr));
    strList2.add("f");
    System.out.println(strList2); // [null, null, null, f]

    // 3、集合工具类最高效，最推荐写法
    List<String> strList3 = new ArrayList<>(strArr.length);
    Collections.addAll(strList3, strArr);
    strList3.add(0, "f");
    System.out.println(strList3);  // [f, null, null, null]

    // 二、List转String[]数组
    strList3.add(0, "RR");
    strList3.add(1, "EE");
    strList3.add(2, "VV");
    System.out.println(strList3); // [RR, EE, VV, f, null, null, null]

    // 推荐用法
    String[] strRet = strList3.toArray(new String[]{});
    String[] strRet2 = strList3.toArray(new String[strlist1.size()]);
    System.out.println(Arrays.toString(strRet));  // [RR, EE, VV, f, null, null, null]
	// list.toArray()返回Object[]对象
    Object[] objRet = strList3.toArray(); 
    // 禁止使用，String[]对结果强转，Object[] 不能转 String[]
    // String[] strErr = (String[])strList3.toArray(); 
    // 一般采用此支持泛型的有参toArray方法：<T> T[] toArray(T[] a);
}
2.2 int[] / List 转换

1、int[]转List步骤：

  • 将原数组转为顺序流 Arrays.stream();
  • 将流的元素装箱到包装类 IntStream.boxed();
  • 将元素添加到新的List中 Collectors.toList();

2、List转int[]步骤：

  • 将List转为流 list.stream();
  • 过滤空对象
  • 映射到int
  • 将元素添加到新Array中
// 基本数据类型数组转List
public static void intArrConvertList() {
    // 一、int[]数组转List，由于装箱机制，基本数据类型数组与List转换需借助stream
    int[] intArr = new int[]{1, 2, 3};
    List<Integer> intList = Arrays.stream(intArr).boxed().collect(Collectors.toList());
    System.out.println(intList); // [1, 2, 3]

    // 二、List转int[]数组
    intList.add(5);
    intList.add(6);
    System.out.println(intList); // [1, 2, 3, 5, 6]

    Object[] objArr = intList.toArray();  // 返回Object[] 对象
    Integer[] integerArr = intList.toArray(new Integer[intList.size()]); // 返回Integer[] 对象
    int[] intRet = intList.stream().mapToInt(Integer::valueOf).toArray(); // 返回int[]

    // 存在null时
    intList.add(null);
    intList.add(8);
    System.out.println(intList); // [1, 2, 3, 5, 6, null, 8]

    // 过滤null对象，建议写法
    int[] intRet1 = intList.stream()
                            .filter(Objects::nonNull)
                            .mapToInt(Integer::valueOf)
                            .toArray();
    System.out.println(Arrays.toString(intRet1)); // [1, 2, 3, 5, 6, 8]
    // 转为默认值
    int[] intRet2 = intList.stream()
                            .mapToInt(i -> (i == null ? 0 : i))
                            .toArray();
    System.out.println(Arrays.toString(intRet2)); // [1, 2, 3, 5, 6, 0, 8]
}

3、数组拷贝

  • 使用clone()方法时注意区分深拷贝与浅拷贝概念。
  • System.arraycopy()
  • Arrays.copyOf()和Arrays.copyOfRange() ，推荐使用。
public static void methFor() {
    int[] nums = {2,5,1,3,4,7};
    int len = nums.length;
    int[] ret = new int[len];
    for (int i = 0; i < len; i++) {
        ret[i] = nums[i];
    }
    // Arrays.toString()转为String类型
    System.out.println(Arrays.toString(ret));   // [2, 5, 1, 3, 4, 7]
}

public static void methClone() {
    // 注意区分深拷贝与浅拷贝，此处只以基本数据类型一维数组为例
    int[] nums = {0,1,2,3,4,5};
    int[] ret = nums.clone();
    System.out.println(Arrays.toString(ret)); // [0, 1, 2, 3, 4, 5]
    // 基本数据类型数组的clone是深拷贝，重新开辟内存空间存放新数据
    nums[3] = 10;
    // 原数组修改不影响新数组
    System.out.println(Arrays.toString(ret)); // [0, 1, 2, 3, 4, 5]
}

public static void methSysArraycopy() {
    int[] nums = {1,2,3,4,5};
    // 目标数组必须已经存在，且不会被重构, 拷贝范围[from,to)
    int[] ret = new int[7];
    // 参数：原数组，原数组起始位，目标数组起始位，拷贝长度
    System.arraycopy(nums, 2, ret, 3, 2);
    // 默认补0
    System.out.println(Arrays.toString(ret)); // [0, 0, 0, 3, 4, 0, 0]
}

public static void methArraysCopyOf() {
    int[] nums = {1,2,3,4,5,6,7};
    // 1、参数：原数组，新数组长度
    int[] ret = Arrays.copyOf(nums, nums.length);
    System.out.println(Arrays.toString(ret)); // [1, 2, 3, 4, 5, 6, 7]
    // 长度<原数组长，截断
    ret = Arrays.copyOf(nums, 3);
    System.out.println(Arrays.toString(ret)); // [1, 2, 3]
    // 长度>原数组长，补零
    ret = Arrays.copyOf(nums, 8);
    System.out.println(Arrays.toString(ret)); // [1, 2, 3, 4, 5, 6, 7, 0]

    ///2、参数：原数组，[from, to)
    ret = Arrays.copyOfRange(nums, 2, 2);
    System.out.println(Arrays.toString(ret)); // []
    // 长度>原数组长，补零
    ret = Arrays.copyOfRange(nums, 3, 9);
    System.out.println(Arrays.toString(ret)); // [4, 5, 6, 7, 0, 0]
}

4、完整代码

import java.util.*;
import java.util.stream.Collectors;

public class ArrayNotes {
    public static void main() {
        initArray(); // 数组初始化
        arrConvertList(); // 数组/List转换
        copyArray(); // 数组拷贝
    }

    // 数组初始化
    public static void initArray() {
        int[] arr0 = {1, 2, 3};
        int[] arr1 = new int[]{};
        int[] arr2 = new int[]{1, 2, 3};
        int[] arr3 = new int[5];
    }

    // 数组转list
    public static void arrConvertList() {
        // String[]数组与List转换
        stringArrConvertList();
        // int[]数组与List转换
        intArrConvertList();
    }

    // String[]数组与List转换
    public static void stringArrConvertList() {
        // 一、String[]数组转List
        String[] strArr = new String[3];
        // 1、Arrays.asList()转换后不能支持增删改修改List
        List<String> strlist1 = Arrays.asList(strArr);
        System.out.println(Arrays.toString(strlist1.toArray())); // [null, null, null]

        // 2、new ArrayList支持增删改
        List<String> strList2 = new ArrayList<String>(Arrays.asList(strArr));
        strList2.add("f");
        System.out.println(Arrays.toString(strList2.toArray())); // [null, null, null, f]

        // 3、集合工具类最高效
        List<String> strList3 = new ArrayList<>(strArr.length);
        Collections.addAll(strList3, strArr);
        strList3.add(0, "f");
        System.out.println(Arrays.toString(strList3.toArray())); // [f, null, null, null]

        // 二、List转String[]数组
        strList3.add(0, "RR");
        strList3.add(1, "EE");
        strList3.add(2, "VV");
        System.out.println(Arrays.toString(strList3.toArray())); // [RR, EE, VV, f, null, null, null]

        String[] strRet = strList3.toArray(new String[]{});
        String[] strRet2 = strList3.toArray(new String[strlist1.size()]); // 推荐用法

        Object[] objRet = strList3.toArray(); // list.toArray()返回Object[]对象
        // String[] strErr = (String[])strList3.toArray(); // 禁止使用会报错
        System.out.println(Arrays.toString(strRet));
    }

    // 由于装箱机制，基本数据类型数组与List转换需借助stream
    public static void intArrConvertList() {
        // 一、int[]数组转List
        int[] intArr = new int[]{1, 2, 3};
        List<Integer> intList = Arrays.stream(intArr).boxed().collect(Collectors.toList());

        // 二、List转int[]数组
        intList.add(5);
        intList.add(6);
        System.out.println(Arrays.toString(intList.toArray()));  // [1, 2, 3, 5, 6]

        Object[] objArr = intList.toArray(); // list.toArray()返回Object[] 对象
        Integer[] integerArr = intList.toArray(new Integer[intList.size()]); // 返回Integer[] 对象
        int[] intRet = intList.stream().mapToInt(Integer::valueOf).toArray(); // 推荐写法

        // 存在null时
        intList.add(null);
        intList.add(8);
        System.out.println(Arrays.toString(intList.toArray()));  // [1, 2, 3, 5, 6, null, 8]
        // 过滤null对象
        int[] intRet1 = intList.stream()
                                .filter(Objects::nonNull)
                                .mapToInt(Integer::valueOf)
                                .toArray();
        // 转为默认值
        int[] intRet2 = intList.stream()
                                .mapToInt(i -> (i == null ? 0 : 1))
                                .toArray();
    }

    // 数组拷贝
    public static void copyArray() {
        methFor();  // for循环
        methClone();    // clone()
        methSysArraycopy();   // System.arraycopy()
        methArraysCopyOf();   // Arrays.copyOf()和Arrays.copyOfRange()
    }

    public static void methFor() {
        int[] nums = {2,5,1,3,4,7};
        int len = nums.length;
        int[] ret = new int[len];
        for (int i = 0; i < len; i++) {
            ret[i] = nums[i];
        }
        // Arrays.toString()转为String类型
        System.out.println(Arrays.toString(ret));   //[2, 5, 1, 3, 4, 7]
    }

    public static void methClone() {
        // 注意区分深拷贝与浅拷贝，此处只以基本数据类型一维数组为例
        int[] nums = {0,1,2,3,4,5};
        int[] ret = nums.clone();
        System.out.println(Arrays.toString(ret)); // [0, 1, 2, 3, 4, 5]
        // 基本数据类型数组的clone是深拷贝，重新开辟内存空间存放新数据
        nums[3] = 10;
        // 原数组修改不影响新数组
        System.out.println(Arrays.toString(ret)); // [0, 1, 2, 3, 4, 5]
    }

    public static void methArraysCopyOf() {
        int[] nums = {1,2,3,4,5,6,7};
        // 参数：原数组，新数组长度
        int[] ret = Arrays.copyOf(nums, nums.length);
        System.out.println(Arrays.toString(ret)); // [1, 2, 3, 4, 5, 6, 7]
        // 长度<原数组长，截断
        ret = Arrays.copyOf(nums, 3);
        System.out.println(Arrays.toString(ret)); // [1, 2, 3]
        // 长度>原数组长，补零
        ret = Arrays.copyOf(nums, 8);
        System.out.println(Arrays.toString(ret)); // [1, 2, 3, 4, 5, 6, 7, 0]

        // 参数：原数组，[from, to)
        ret = Arrays.copyOfRange(nums, 2, 2);
        System.out.println(Arrays.toString(ret)); // []
        // 长度>原数组长，补零
        ret = Arrays.copyOfRange(nums, 3, 9);
        System.out.println(Arrays.toString(ret)); // [4, 5, 6, 7, 0, 0]
    }

    public static void methSysArraycopy() {
        int[] nums = {1,2,3,4,5};
        // 目标数组必须已经存在，且不会被重构, 拷贝范围[from,to)
        int[] ret = new int[7];
        // 参数：原数组，原数组起始位，目标数组起始位，拷贝长度
        System.arraycopy(nums, 2, ret, 3, 2);
        // 默认补0
        System.out.println(Arrays.toString(ret)); // [0, 0, 0, 3, 4, 0, 0]
    }
}

参考
https://blog.csdn.net/x541211190/article/details/79597236
https://www.techiedelight.com/zh/convert-int-array-integer-array-java/

RiceVan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-数据结构-数组
weixin_45532984的博客
08-05 797
数组是在程序设计中，把具有相同类型的若干元素按有序的形式组织起来的一种形式。数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素。 数组作为线性表的实现方式之一，数组中的元素在内存中是连续存储的，且每个元素占相同大小的内存。...............
数据结构-数组Array(二维)
weixin_43486332的博客
07-19 2677
二维数组是特殊的一维数组，这个特殊的一维数组(二维数组)当中的每一个元素是一个一维数组。 二维数组里面存的是一维数组，二维数组里面的元素个数是一维数组的元素个数。 二维数组内存图： 二维数组地址计算公式： U：每个元素占的字节数 n：元素总个数 //一维数组 int[] a = {10,20,30}; System.out.println("一维数组："+a.length);3 //二维数组 int[][] b = { {1,2,3}, {4,5},..
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
java数据结构array数组
Jay112011的博客
06-29 388
java数据结构array数组和list的总结 首先是array数组： array数组初始化大小之后长度不可变，所以array数组没有增加和删除元素的方法！！！ array数组的长度一旦改变就是一个新数组 array数组的长度不变，只改变元素时，不会生成新的array数组对象 常用的array数组有：int[]，String[]，char[] array数组常用的方法有： Arrays.fill(); 填充数组 Arrays.sort(); 数组排序 Arrays.toString();
Java里的Arrary详解
最新发布
weixin_65752158的博客
07-07 352
DK 中提供了一个专门用于操作数组的工具类，即Arrays 类，位于java.util 包中。该类提供了一些列方法来操作数组，如排序、复制、比较、填充等，用户直接调用这些方法即可不需要自己编码实现，降低了开发难度。java.util.Arrays 是一个与数组相关的工具类，里面提供了大量静态方法，用来事项数组常见的操作。
java之数组
weixin_30243533的博客
11-04 333
数组概述： 1、数组可以看成是多个相同数据类型数据的组合，对这些数据的统一管理。 2、数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。 3、数组中的元素可以是任何类型，包括基本类型和引用类型。 一维数组的声明： 1、一维数组的声明方式： type var[]; 或type[] var; 例如: int a1[]; int[] a2; ...
Java数据结构—数组（Array）
Rxq_Future的博客
04-16 396
数据结构—数组
Java数组（Array）
Jafe的博客
03-19 7848
数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。 数组相关的概念： 数组名 元素 角标、下标、索引 数组的长度：元素的个数 数组的特点： 数组是按序排列的 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 创建数组对象会在内存中开辟一整块连续的空间 数组的长度一旦确定，就不能修改。 数组...
Java数据结构之数组(动力节点之Java学院整理)
08-30
Java中的数组是一种基础且重要的数据结构，它允许程序员存储固定数量的同类型元素。数组的用处在于其高效地访问和操作元素，特别是在需要对一组数据进行排序、查找或统计时。数组分为基本类型数组（如int、char）和...
Java数据结构实现之Array.zip
06-04
本篇将重点探讨Java中的数组数据结构及其实现。 数组是一种线性数据结构，它在内存中存储固定数量的相同类型元素。数组的基本概念包括数组的声明、初始化、访问和操作。在Java中，数组可以通过以下方式声明： ```...
数据结构-数组Array(一维)
weixin_43486332的博客
07-17 1898
一、数组的概念 java语言中的数组是一种引用数据类型。不属于基本数据类型。数组的父类是Object。 数组实际上是一个容器，可以同时容纳多个元素。（数组是一个个数据的集合）。 数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。 数组是引用数据类型，所以数组对象是在堆内存当中。（数组是存储在堆内存当中的）。 数组当中存储的是"java对象的话"，存储的实际上是对象的引用（内存地址）。 数组一旦创建，在java中规定，数组长度不可变。 数组的分类：一维数组、二维数组、三维数组、多
Java 数组Array
qq_57570052的博客
07-12 4291
数组Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组 的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序 的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合。数组是对象类型（引用类型）数组是固定长度，下标是从0开始，结束下标是，length属性-1。
Java数组Array
m0_63920681的博客
01-22 598
介绍数组: 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。 1.定义数组的格式 格式一： 数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度]; //定义可以存储3个整数的数组容器，代码如下： int[] arr = new int[3]; 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。 [] : 表示数组。 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。 new：关键字，创建数组使用的关键字。 数组存储的数据类
Java中的数组Array
xxyneymar的博客
09-10 2893
1.数组的基本性质： ①java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object。 ②数组实际上是一个容器，可以同时容纳多个元素(数组是一个数据的集合)。数组中每一个元 素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是length-1。下标非常重 要，因为我们对数组中元素进行存取的时候，都需要通过下标来进行。 ③数组中可以存储基本数据类型的数据，也可以存储引用数据类型的数...
Java中的数组（Array）
weixin_58545784的博客
02-06 3260
数组(array)是一种用于存储多个相同类型数据的存储模型第一种：数据类型[] 数组名int[] arr;char[] arr;第二种：数据类型 数组名[]int arr[];char arr[];
Java版-数据结构-数组
weixin_34400525的博客
03-11 155
数组知识点回顾 声明Java数组时，会在内存中开辟一块连续指定大小的空间，用来存储固定大小的同类型元素 在java中定义个名为scores，长度为8，类型为int类型的数组如下： public static void main(String[] args) { int[] scores = new int[8]; } 复制代码为了便于理解，我们看下它在内存的中的分布示意图： 图中的一个个...
【JAVA基础】数组Array
m0_70444867的博客
07-07 3851
数组/冒泡
【Java】数组Array（概念、相关语法、相关算法）
渐若窥宏大的博客
05-11 2510
第四章 数组 文章目录第四章 数组1、数组的相关概念和名词（了解）2 、数组的相关语法2.1、 数组的声明2.2、 数组的初始化2.3、数组的遍历2.4、 数组的内存分析3、 数组的相关算法3.1、 数组找最值3.2、数组统计：求总和、均值、统计偶数个数等3.3、 反转3.4、 复制 1、数组的相关概念和名词（了解） 1、数组(array)： 数组(array)：简单的说，就是一组数, 一组具有相同数据类型的数，是按照一定顺序排列的集合。 当一组数据的数据类型，意义是一样的时候，那么为了方便的统一的管理它们
Java数据结构---Array（数组）
cloud的博客
10-11 367
Java数据结构---Array（数组）1. Array（矩阵）1.1 一维数组1.2 二维数组（矩阵）2. 其他操作 1. Array（矩阵） 1.1 一维数组 声明数组 dataType[] arrayRefVar; // 如 int[] res ，声明一个名为res的数组 创建数组 arrayRefVar = new dataType[arraySize]; // 如 res = new int[5] ，创建一个长度为5的数组 arrayRefVar = int[]{1, 2, 3 ,4
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值