集合和数组的相关操作

于 2024-03-10 20:39:45 发布
阅读量986 收藏 22
点赞数 22
分类专栏： java常用 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72167535/article/details/136596005
版权
本文详细介绍了Java中如何将数组转换为集合（包括引用类型和基础类型），以及集合之间的相交操作、获取交集的方法，还涵盖了集合转为字符串的示例。重点展示了Arrays.asList、newArrayList<>(Arrays.asList)和Collections.addAll等转换方法的异同。
摘要由CSDN通过智能技术生成

目录

1.数组转集合(引用类型数组)

2.数组转集合(基础类型数组)

3.集合转数组

4.集合之间是否相交

5.获取两个集合的交集

6.集合转为字符串

1.数组转集合(引用类型数组)

(1)Arrays.asList

示例：

String[] colArr = new String[6];
        colArr[0] = "1";
        colArr[1] = "2";
        colArr[2] = "3";
        colArr[3] = "4";
        colArr[4] = "5";
        List<String> strings1 = Arrays.asList(colArr);
        // 集合大小
        System.out.println("集合大小："+strings1.size());
        System.out.println("集合1修改前："+strings1);
        colArr[5] = "6";
        colArr[4] = "44";
        // 数组修改集合也会修改，是浅拷贝的方式，底层共用一个内存地址
        System.out.println("集合1修改后："+strings1);
        // 集合改变数组也会改变
        // 修改前的数组
        System.out.println("修改前的数组："+colArr[0]);
        strings1.set(0,"11");
        System.out.println("修改后的数组："+colArr[0]);
        // 转换后的集合不能进行删除
        strings1.remove(0);
        // Exception in thread "main" java.lang.UnsupportedOperationException
        // at java.util.AbstractList.remove(AbstractList.java:161)
        // at com.kingagroot.info.em.Test1.main(Test1.java:28)

        // 转换后的集合不能进行添加
        strings1.add("77");
        // 报错如下：
        // Exception in thread "main" java.lang.UnsupportedOperationException
        // at java.util.AbstractList.add(AbstractList.java:148)
        // at java.util.AbstractList.add(AbstractList.java:108)
        // at com.kingagroot.info.em.Test1.main(Test1.java:28)

执行结果：

集合大小：6
集合1修改前：[1, 2, 3, 4, 5, null]
集合1修改后：[1, 2, 3, 4, 44, 6]
修改前的数组：1
修改后的数组：11

说明：

①使用Arrays.asList方法将数组转为集合

②转换前的数组和转换后的集合共用一个内存地址，数组中的元素改变，集合中的元素也会同时发生变化；反之，集合中元素改变，数组也同时发生变化。

③转换后的集合不能进行删除和增加，阅读源码可以发现，执行asList方法，会new一个ArrayList，这是Arrays的一个静态内部类，继承了AbstractList，AbstractList是不支持进行删除和增加的。

(2)new ArrayList<>(Arrays.asList(arr))

示例：

        String[] colArr = new String[6];
        colArr[0] = "1";
        colArr[1] = "2";
        colArr[2] = "3";
        colArr[3] = "4";
        colArr[4] = "5";
        List<String> strings1 = new ArrayList<>(Arrays.asList(colArr));
        // 集合大小
        System.out.println("集合大小："+strings1.size());
        System.out.println("集合1修改前："+strings1);
        colArr[5] = "6";
        colArr[4] = "44";
        // 数组修改集合不会修改
        System.out.println("集合1修改后："+strings1);
        // 集合修改数组不会修改
        // 修改前的数组
        System.out.println("修改前的数组："+colArr[0]);
        strings1.set(0,"11");
        System.out.println("修改后的数组："+colArr[0]);
        // 转换后的集合能进行删除
        strings1.remove(0);
        System.out.println("删除后的集合："+strings1);
        // 转换后的集合能进行添加
        strings1.add("77");
        System.out.println("增加后的集合："+strings1);

执行结果：

集合大小：6
集合1修改前：[1, 2, 3, 4, 5, null]
集合1修改后：[1, 2, 3, 4, 5, null]
修改前的数组：1
修改后的数组：1
删除后的集合：[2, 3, 4, 5, null]
增加后的集合：[2, 3, 4, 5, null, 77]

 说明:

①使用new ArrayList<>(Arrays.asList(arr))将数组转为集合

②通过new的方式，数组修改，转换后的集合不会修改，反之也是如此

③转换后的集合可以进行删除和增加

(3)Collections.addAll

示例：

        String[] colArr = new String[6];
        colArr[0] = "1";
        colArr[1] = "2";
        colArr[2] = "3";
        colArr[3] = "4";
        colArr[4] = "5";
        List<String> strings1 = new ArrayList<>();
        Collections.addAll(strings1,colArr);
        // 集合大小
        System.out.println("集合大小："+strings1.size());
        System.out.println("集合1修改前："+strings1);
        colArr[5] = "6";
        colArr[4] = "44";
        // 数组修改集合不会修改
        System.out.println("集合1修改后："+strings1);
        // 集合修改数组不会修改
        // 修改前的数组
        System.out.println("修改前的数组："+colArr[0]);
        strings1.set(0,"11");
        System.out.println("修改后的数组："+colArr[0]);
        // 转换后的集合能进行删除
        strings1.remove(0);
        System.out.println("删除后的集合："+strings1);
        // 转换后的集合能进行添加
        strings1.add("77");
        System.out.println("增加后的集合："+strings1);

执行结果：

集合大小：6
集合1修改前：[1, 2, 3, 4, 5, null]
集合1修改后：[1, 2, 3, 4, 5, null]
修改前的数组：1
修改后的数组：1
删除后的集合：[2, 3, 4, 5, null]
增加后的集合：[2, 3, 4, 5, null, 77]

说明：

①其原理就是循环数组，将数组的所有元素添加到集合中。

②通过new的方式创建，所有数组和集合使用不同的内存地址，一方改变，另一方不会发生变化。

③转换后的集合可以进行修改和增加。

2.数组转集合(基础类型数组)

(1)Arrays.asList

示例：

        int[] colArr = new int[6];
        colArr[0] = 1;
        colArr[1] = 2;
        colArr[2] = 3;
        colArr[3] = 4;
        colArr[4] = 5;

        List<int[]> ints = Arrays.asList(colArr);
        System.out.println("数组大小：" + ints.size());
        System.out.println("数组内容：" + ints.get(0));

执行结果：

数组大小：1
数组内容：[I@4361bd48

说明：

①基础数据类型的数组转换后，是基础数据类型数组的集合，集合中只有一个人元素，就是数组。

②基础类型不能用作泛型，源码中的a接收引用类型。

    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

③如果要生成每个数组元素的集合，参照(2)的方式，使用基础数据类型的包装类

(2)Arrays.asList

示例：

        Integer[] colArr = new Integer[6];
        colArr[0] = 1;
        colArr[1] = 2;
        colArr[2] = 3;
        colArr[3] = 4;
        colArr[4] = 5;

        List<Integer> ints = Arrays.asList(colArr);
        System.out.println("数组大小：" + ints.size());
        System.out.println("数组内容：" + ints);

执行结果：

数组大小：6
数组内容：[1, 2, 3, 4, 5, null]

说明：

①使用基础类型的包装类作为数组的类型，可以生成每个数组元素的集合类

3.集合转数组

示例：

        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        String[] strArr = list.toArray(new String[list.size()]);
        System.out.println("修改前数组：" + strArr.length);
        // 集合改变数组不会发生变化
        list.add("7");
        System.out.println("修改后数组：" + strArr.length);
        // 数组中元素的内容可以改变
        strArr[0] = "11";
        System.out.println(strArr[0]);

执行结果：

修改前数组：6
修改后数组：6
11

说明：

①使用list.toArray方法

②集合改变后数组不会随之改变 

参照：https://blog.51cto.com/liuchenyang0515/6422343

4.集合之间是否相交

示例：

List<String> list1 = new ArrayList<>(Arrays.asList("1", "2", "3", "4", "5", "6", "7"));
        List<String> list2 = new ArrayList<>(Arrays.asList("1", "2", "33", "44", "55", "6", "7"));
        List<String> list3 = new ArrayList<>(Arrays.asList("11", "22", "33", "44", "55", "66", "77"));
        // 方法1 使用Collections.disjoint,没有交集返回true，有交集则返回false
        System.out.println("方法1------------------");
        System.out.println(Collections.disjoint(list1, list2));
        System.out.println(Collections.disjoint(list1, list3));
        // 方法2 使用CollectionUtils.containsAny，有交集返回true，没有返回false
        System.out.println("方法2------------------");
        System.out.println(CollectionUtils.containsAny(list1, list2));
        System.out.println(CollectionUtils.containsAny(list1, list3));
        // 方法3 使用CollectionUtil.containsAny，有交集返回true，没有则返回false
        System.out.println("方法3------------------");
        System.out.println(CollectionUtil.containsAny(list1, list2));
        System.out.println(CollectionUtil.containsAny(list1, list3));
        // 方法4 使用java8的新特性
        System.out.println("方法4------------------");
        List<String> coll1 = list1.stream().filter(item -> list2.contains(item)).collect(Collectors.toList());
        if (CollUtil.isNotEmpty(coll1)) {
            System.out.println("有交集");
        } else {
            System.out.println("没有交集");
        }
        List<String> coll2 = list1.stream().filter(item -> list3.contains(item)).collect(Collectors.toList());
        if (CollUtil.isNotEmpty(coll2)) {
            System.out.println("有交集");
        } else {
            System.out.println("没有交集");
        }
        List<String> coll3 = list1.stream().filter(list2::contains).collect(Collectors.toList());
        if (CollUtil.isNotEmpty(coll3)) {
            System.out.println("有交集");
        } else {
            System.out.println("没有交集");
        }
        List<String> coll4 = list1.stream().filter(list3::contains).collect(Collectors.toList());
        if (CollUtil.isNotEmpty(coll4)) {
            System.out.println("有交集");
        } else {
            System.out.println("没有交集");
        }

执行结果：

方法1------------------
false
true
方法2------------------
true
false
方法3------------------
true
false
方法4------------------
有交集
没有交集
有交集
没有交集

说明：

①全限定名为java.util.Collections，在俩个集合没有交集的时候会返回true，否则返回false。

②全限定名为：org.apache.commons.collections.CollectionUtils，两个集合有交集会返回true，否则会返回false，跟Collections.disjoint相反。

③全限定名为：cn.hutool.core.collection.CollectionUtil，两个集合有交集会返回true，否则会返回false，跟Collections.disjoint相反。

④使用Java8的新特性

5.获取两个集合的交集

示例：

        List<String> list1 = new ArrayList<>(Arrays.asList("1", "2", "3", "4", "5", "6", "7"));
        List<String> list2 = new ArrayList<>(Arrays.asList("1", "2", "33", "44", "55", "6", "7"));
        List<String> list3 = new ArrayList<>(Arrays.asList("11", "22", "33", "44", "55", "66", "77"));
        // 方式1
        List<String> result1 = new ArrayList<>();
        for (String data : list1) {
            if (list2.contains(data) && !result1.contains(data)) {
                result1.add(data);
            }
        }
        System.out.println("集合1和集合2的交集:" + result1);
        List<String> result2 = new ArrayList<>();
        for (String data : list1) {
            if (list3.contains(data) && !result1.contains(data)) { // 去重
                result1.add(data);
            }
        }
        System.out.println("集合1和集合3的交集:" + result2);

        // 方式2
        List<String> result3 = new ArrayList<>();
        list1.forEach(item -> {
            if (list2.contains(item) && !result3.contains(item)) {
                result3.add(item);
            }
        });
        System.out.println("集合1和集合2的交集:" + result1);
        List<String> result4 = new ArrayList<>();
        list1.forEach(item -> {
            if (list3.contains(item) && !result3.contains(item)) {
                result3.add(item);
            }
        });
        System.out.println("集合1和集合3的交集:" + result4);
        // 方式3
        List<String> result5 = new ArrayList<>();
        result5 = list1.stream().filter(list2::contains).collect(Collectors.toList());
        System.out.println("集合1和集合2的交集:" + result5);
        List<String> result6 = new ArrayList<>();
        result6 = list1.stream().filter(list3::contains).collect(Collectors.toList());
        System.out.println("集合1和集合3的交集:" + result6);

执行结果：

集合1和集合2的交集:[1, 2, 6, 7]
集合1和集合3的交集:[]
集合1和集合2的交集:[1, 2, 6, 7]
集合1和集合3的交集:[]
集合1和集合2的交集:[1, 2, 6, 7]
集合1和集合3的交集:[]

说明：

①通过循环其中一个集合，判断集合的每个元素是否在另一个集合中存在，如果存在并且在新集合中不存在则将元素添加到新集合中。

②去重也可以使用hashset进行去重。

        List<String> list4 = Arrays.asList("1", "1", "2", "2", "3");
        HashSet<String> set1 = new HashSet<>(list4);
        List<String> list5 = new ArrayList<>(set1);

        System.out.println("去重前:" + list4);
        System.out.println("去重前:" + list5);

参照：Java判断两个集合是否具有交集及如何获得交集详解_java_脚本之家

6.集合转为字符串

示例：

        List<String> list1 = new ArrayList<>(Arrays.asList("1", "2", "3", "4", "5", "6", "7"));
        System.out.println(list1.stream().collect(Collectors.joining(",")));

执行：

1,2,3,4,5,6,7

linab112
关注
  • 22
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组转集合
.
09-16 502
Array->Collection 为什么要把数组转成集合？ 为的是使用集合中的方法（增删方法不能使用，因为会改变数组的长度）。 Arrays:用来操作数组的工具类，方法都是静态的。 1.Arrays.toString()方法，把数组转换成字符串，内部其实是一个StringBuilder 2.asList()方法，把数组转成List集合，返回一个List集合 import j...
CollectionUtils containsAny()方法和intersection()方法
LiLiYuan.的博客
04-20 2407
可以看到，containsAny()方法和intersection()方法虽然都和集合的交集有关，但是它们的作用不同。containsAny()方法：判断两个集合是否有交集，如果存在交集则返回true，否则返回false。intersection()方法：求两个集合的交集，将它们共有的元素放在一个新的集合中返回。containsAny()方法和intersection()方法的作用不同。
数组转成集合
qq_40207976的博客
10-25 1020
import java.util.Arrays; import java.util.List; public class ArraysDemo {     public static void main(String[] args) {         // TODO Auto-generated method stub         /*          * Arrays: 集合框架...
java8新特性 stream流的方式遍历集合和数组操作
08-18
Java 8 新特性 Stream 流的方式遍历集合和数组操作 Java 8 中引入了 Stream 流的概念，旨在提供一种更加优雅的方式来遍历集合和数组。Stream 流可以看作是一种 lazy 的数据结构，它可以对集合和数组进行遍历、过滤...
Java集合和数组的区别
08-31
Java编程语言中，集合和数组是两种常见的数据结构，它们在存储和管理数据时有着显著的区别。理解这些差异对于编写高效、灵活的代码至关重要。 **数组（Array）**： 1. **固定大小**：数组在创建时必须指定长度，...
C#对多个集合和数组的操作方法(合并,去重,判断)
01-20
这里介绍一些常用的集合跟数组的操作函数. 首先举例2个集合A,B. List<int> listA = new List<int> {1,2,3,5,7,9}; List<int> listB = new List<int> {13,4,17,29,2}; listA.AddRange(listB ); 把集合A.B合并 List...
控件操作集合_labview控件操作集合_
10-01
在这个“控件操作集合”中，我们很可能找到一系列与LabVIEW控件相关的资源，包括但不限于用户界面设计、数据交互以及控件功能的实现等。下面将详细介绍LabVIEW中的控件操作和常见应用。 1. **基础控件**：LabVIEW的...
Java 数组转集合
weixin_42149650的博客
10-09 757
// 数组转集合 String[] arr = { "1", "2", "3" }; LinkedList&lt;String&gt; list = new LinkedList&lt;String&gt;(Arrays.asList(arr)); System.out.println(list);  
数组转集合 集合转数组
wanghonhjunking的博客
06-19 642
//数组转集合     //数组转集合虽然不能增加减少 但可以使用其他集合的方法  比如包含     public static void main(String[] args) {     //demo1();    // int [] arr ={11,22,33,44,55};    // List list =Arrays.asList(arr);基本数据类型的数组转换成集合，会
将数组转换成集合
weixin_42453395的博客
08-31 2129
将数组转换成集合 import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class Demo4_AsList { public static void main(String[] args) { demo1(); //demo2(); //集合转数组,加泛型的 /...
数组与集合的相互转换
roamer_nuptgczx的专栏
08-08 1638
在实际开发过程中，为了处理的方便或者接口类型的要求，我们经常需要在集合与数组之间进行相互转换，JDK为我们提供了方便的工具类和相应的方法来完成这个工作。Arrays.asList()方法与Collection.toArray()方法一起充当了基于数组的API与基于 Collection的API之间相互转化的桥梁，但是由于不甚了解其实现的原理，很多同学在使用的过程中经常会被一些问题困扰，在此通过源码解
数组转集合/集合转数组
RzhenDwo的博客
07-13 3630
面试题【数组转集合或者集合转数组】
数组与集合相互转化
wanlin77的博客
08-19 7147
数组Array与集合List相互转化有两种方式，一种是自己手动转化，一种是直接使用集合或数组自带的方法转化 数组转化集合： 方法一：手动转化 List&lt;String&gt; list= new ArrayList&lt;&gt;(); String[] array = new String[] {"hello", "hi", "nihao"}; for (int ...
集合与数组之间相互转化
weixin_30922589的博客
08-27 990
https://blog.csdn.net/zhuwentao2150/article/details/51713565 本文转自上述链接 数组转换成List集合 方法一笨方法就是通过add把数组中的数据循环添加到List集合中 List<String> mlist = new ArrayList<>(); String[] ...
数组与集合的转换
Daniel的博客
12-07 231
数组转集合 数组转集合，我们容易想到可以用Arrays工具类下面的asList()方法，但是在使用时要注意asList()方法返回的ArrayList对象不是常见的java.util.ArrayList类的实例，它不具有add()和remove()方法，具体情况可看如下操作。 public class ListTest2 { public static void main(String[...
那是怎么对集合和数组进行操作的
最新发布
06-12
Java流式API提供了丰富的操作方法，可以用来对集合和数组进行各种操作。常用的操作包括： 1. filter：过滤操作，用于过滤集合或数组中的元素，只保留满足指定条件的元素。 2. map：映射操作，用于对集合或数组中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值