Java中对Array数组的常用操作，交集并集合集！

最新推荐文章于 2025-07-10 10:18:36 发布
转载 最新推荐文章于 2025-07-10 10:18:36 发布 · 2.6k 阅读 · 12
文章标签：

#java #arraylist

本文详细介绍Java中数组的各种操作，包括声明、初始化、遍历、排序等，并提供了实用的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

看到好的转来留着，随时学习。

目录：

  1. 声明数组；
  2. 初始化数组；
  3. 查看数组长度；
  4. 遍历数组；
  5. int数组转成string数组；
  6. 从array中创建arraylist；
  7. 数组中是否包含某一个值；
  8. 将数组转成set集合；
  9. 将数组转成list集合；
  10. Arrays.fill()填充数组；
  11. 数组排序；
  12. 复制数组；
  13. 比较两个数组；
  14. 去重复；
  15. 查询数组中的最大值和最小值；
  16. list的交集并集合集

备注：文内代码具有关联性。

1.声明数组；

1
2
3
4
String [] arr;
int arr1[];
String[] array=new String[5];
int score[]=new int[3];

 

2.初始化数组；

1
2
3
4
5
6
7
8
9
10
//静态初始化
int arr2[]=new int[]{1,2,3,4,5};
String[] array1={"马超","马云","关羽","刘备","张飞"};
String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};
int score[]=new int[3];
//动态初始化
for(int i=0;i<score.length;i++)
{   
　　score[i]=i+1; 
}

 

 

3.查看数组长度；

1
2
int length=array1.length;
System.out.println("length：  "+array1.length);

 

4.遍历数组；

1
2
3
for (int i = 0; i < array1.length; i++) {
    System.out.println(array1[i]);
}

 

5.int数组转成string数组；

1
2
3
int[]  array3={1,2,3,4,5,6,7,8,9,0};
        String arrStrings=Arrays.toString(array3);
        System.out.println(arrStrings);

 

 6.从array中创建arraylist；

1
2
ArrayList<String> arrayList=new ArrayList<String>(Arrays.asList(array1));
System.out.println(arrayList);

 

7.数组中是否包含某一个值；

1
2
3
4
5
String a="马超";
String[] array1={"马超","马云","关羽","刘备","张飞"};
if (Arrays.asList(array1).contains(a)) {
    System.out.println("马超在这里");
}

 

8.将数组转成set集合；

1
2
3
String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};
    Set<String> set=new HashSet<String>(Arrays.asList(array2));
    System.out.println(set);

 

9.将数组转成list集合；

1
2
3
4
5
6
7
8
9
10
11
String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};
//方法 1.
List<String> list=new ArrayList<String>();
for (int i = 0; i < array2.length; i++) {
    list.add(array2[i]);
}
 
String[] arrStrings2={"1","2","3"};
//方法 2.
List<String > list2=java.util.Arrays.asList(arrStrings2);
System.out.println(list2);

 

10.Arrays.fill()填充数组；

1
2
3
4
5
6
int[] arr3=new int[5];
        Arrays.fill(arr3, 10);  //将数组全部填充10
               //遍历输出
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }

 

11.数组排序；

1
2
3
4
5
6
7
8
9
10
11
12
//方法 1.
int[] arr4 = {3, 7, 2, 1, 9};
Arrays.sort(arr4);         //.sort(int[] a)   放入数组名字
for (int i = 0; i < arr4.length; i++) {
    System.out.println(arr4[i]);
}
//方法 2.        
int[] arr5 = {3, 7, 2, 1, 9,3,45,7,8,8,3,2,65,34,5};
Arrays.sort(arr5, 1, 4);  //.sort(a, fromIndex, toIndex)    从第几个到第几个之间的进行排序
for (int i = 0; i < arr5.length; i++) {
        System.out.println(arr5[i]);
}

 

12.复制数组；

1
2
3
4
5
6
7
8
//方法 1.
int[] arr6 = {3, 7, 2, 1};
int[] arr7=Arrays.copyOf(arr6, 10);  //指定新数组的长度
//方法 2.        
int[] arr8=Arrays.copyOfRange(arr6, 1, 3); //只复制从索引[1]到索引[3]之间的元素（不包括索引[3]的元素）
for (int i = 0; i < arr8.length; i++) {
        System.out.println(arr8[i]);
}

 

13.比较两个数组；

1
2
3
int[] arr9 = {1, 2, 3, 4,5,6,7,8,9,0};
        boolean arr10=Arrays.equals(arr6, arr9);
        System.out.println(arr10);

 

14.去重复；

1
2
3
4
5
6
7
8
9
10
11
12
13
int[] arr11 = {1, 2, 3, 4,5,6,7,8,9,0,3,2,4,5,6,7,4,32,2,1,1,4,6,3};
//利用set的特性
Set<Integer> set2=new HashSet<Integer>();
for (int i = 0; i < arr11.length; i++) {
    set2.add(arr11[i]);
}
System.out.println(set2);
int[] arr12 = new int[set2.size()];
int j=0;
for (Integer i:set2) {
    arr12[j++]=i;
}
System.out.println(Arrays.toString(arr12));

 

15.查询数组中的最大值和最小值；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int[] arr11 = {10, 2, 3, 4,5,6,7,8,9,0,3,2,4,5,6,7,4,32,2,1,1,4,6,3};
 //计算最大值
int max = arr11[0];
for (int i = 1; i < arr11.length; i++) {
     if (arr11[i] > max) {
         max = arr11[i];
    }
  }
  System.out.println("Max is " + max);
  //计算最小值
  int min = arr11[0];
  for (int i = 0; i < arr11.length; i++) {
    if (arr11[i]<min) {
        min = arr11[i];
    }
}
  System.out.println("Min is " + min);

 

附：完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package MyTest01;
  
import java.util.*;
  
public class ArrayTest02 {
  
    public static void main(String[] args) {
        //声明数组
        String [] arr;
        int arr1[];
          
        //初始化数组
        int arr2[]=new int[]{1,2,3,4,5};
        String[] array1={"马超","马云","关羽","刘备","张飞"};
        String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};
          
        String[] array=new String[5];
      
          
        //查看数组的长度
        int length=array1.length;
        System.out.println("length：  "+array1.length);
          
        //输出数组
//      System.out.println(array1);     //结果：[Ljava.lang.String;@32f22097
        System.out.println("arr2:  "+Arrays.toString(arr2));
          
        //遍历数组
        for (int i = 0; i < array1.length; i++) {
//          System.out.println(array1[i]);
        }
        //int数组转成string数组
        int[]  array3={1,2,3,4,5,6,7,8,9,0};
        String arrStrings=Arrays.toString(array3);
//      System.out.println(arrStrings);
          
        //从array中创建arraylist
        ArrayList<String> arrayList=new ArrayList<String>(Arrays.asList(array1));
        System.out.println(arrayList);
          
        //数组中是否包含某一个值
        String a="马超";
        if (Arrays.asList(array1).contains(a)) {
            System.out.println("马超在这里");
        }
          
        //将数组转成set集合
        Set<String> set=new HashSet<String>(Arrays.asList(array2));
        System.out.println(set);
          
        //将数组转成list集合
        List<String> list=new ArrayList<String>();
        for (int i = 0; i < array2.length; i++) {
            list.add(array2[i]);
        }
        String[] arrStrings2={"1","2","3"};
        List<String > list2=java.util.Arrays.asList(arrStrings2);
        System.out.println(list2);
          
          
        //Arrays.fill()填充数组
        int[] arr3=new int[5];
        Arrays.fill(arr3, 10);  //将数组全部填充10
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }
          
        //数组排序
        int[] arr4 = {3, 7, 2, 1, 9};
        Arrays.sort(arr4);
        for (int i = 0; i < arr4.length; i++) {
            System.out.println(arr4[i]);
        }
          
        int[] arr5 = {3, 7, 2, 1, 9,3,45,7,8,8,3,2,65,34,5};
        Arrays.sort(arr5, 1, 4);  //从第几个到第几个之间的进行排序
        for (int i = 0; i < arr5.length; i++) {
            System.out.println(arr5[i]);
        }
          
          
        //复制数组
        int[] arr6 = {3, 7, 2, 1};
        int[] arr7=Arrays.copyOf(arr6, 10);  //指定新数组的长度
          
        int[] arr8=Arrays.copyOfRange(arr6, 1, 3); //只复制从索引[1]到索引[3]之间的元素（不包括索引[3]的元素）
        for (int i = 0; i < arr8.length; i++) {
            System.out.println(arr8[i]);
        }
          
        //比较两个数组
        int[] arr9 = {1, 2, 3, 4,5,6,7,8,9,0};
        boolean arr10=Arrays.equals(arr6, arr9);
        System.out.println(arr10);
      
        //去重复
        //利用set的特性
        int[] arr11 = {1, 2, 3, 4,5,6,7,8,9,0,3,2,4,5,6,7,4,32,2,1,1,4,6,3};
        Set<Integer> set2=new HashSet<Integer>();
        for (int i = 0; i < arr11.length; i++) {
            set2.add(arr11[i]);
        }
            System.out.println(set2);
        int[] arr12 = new int[set2.size()];
        int j=0;
        for (Integer i:set2) {
            arr12[j++]=i;
        }
        System.out.println(Arrays.toString(arr12));
    }
  
}

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package MyTest01;
 
public class ArrayTest03 {
 
    public static void main(String[] args) {
         
        int[] arr11 = {10, 2, 3, 4,5,6,7,8,9,0,3,2,4,5,6,7,4,32,2,1,1,4,6,3};
         //计算最大值
        int max = arr11[0];
        for (int i = 1; i < arr11.length; i++) {
             if (arr11[i] > max) {
                 max = arr11[i];
            }
          }
          System.out.println("Max is " + max);
          //计算最小值
          int min = arr11[0];
          for (int i = 0; i < arr11.length; i++) {
            if (arr11[i]<min) {
                min = arr11[i];
            }
        }
          System.out.println("Min is " + min);
    }
 
}

 

16.list的交集并集合集


package com;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {

 public static void main(String[] args) {
  List list1 =new ArrayList();
  list1.add("1111");
  list1.add("2222");
  list1.add("3333");
  
  List list2 =new ArrayList();
  list2.add("3333");
  list2.add("4444");
  list2.add("5555");
  
  //并集
  //list1.addAll(list2);
  //交集
  //list1.retainAll(list2);
  //差集
  //list1.removeAll(list2);
  //无重复并集
    list2.removeAll(list1);
    list1.addAll(list2);
  
  Iterator<String> it=list1.iterator();
  while (it.hasNext()) {
   System.out.println(it.next());
   
  }
  
  //System.out.println("-----------------------------------\n");
  //printStr(list1);
  
 }
 
 public static void printStr(List list1){
  for (int i = 0; i < list1.size(); i++) {
   System.out.println(list1.get(i));
  }
 }
}

java 数组工具类 ArrayUtil 高级版 最全数组工具类 数组合并 数组并集 交集 差集
shengguimin的博客
05-30 371
java 数组工具类 ArrayUtil 高级版 数组合并 数组并集 交集 差集
java8获取两个list的交集和差集_java8 stream两个集体交集、差集、并集操作
weixin_39528525的博客
12-18 2864
业务场景：页面左右两个datagrid，双击左边datagrid行，移动到右边datagrid，右边datagrid行双击，移动到左边datagrid点击保存，提交修改的数据到后台后台要把查询到的数据，和这次提交的数据对比，不变的不动，有新添加的，要增加，有去掉的要执行删除操作注：不能统一删除，再全新增，原来已经存在的信息可以做了一些配置，全删除，再全插入，原来的配置会丢了。那就要后台对两个集合进...
Java基础~Java的Array类
feizuiku0116的博客
03-01 1089
一、介绍 ArrayList是集合中的一种，它支持索引 二、对象获取方法 构造器 说明 public ArrayList() 创建一个空的集合对象 三、添加元素的方法 方法名 说明 public boolean add(E e) 将指定的元素追加到此集合的末尾 public void add(int index,E element) 在此集合中的指定位置插入指定的元素 四、实例 package com.europeansheik.test; import ja
2021-05-24
qq99734744的博客
05-24 127
Arrays类 数组的工具类java.util.Arrays 由于数组对象本身没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。 查看JDK文档 Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意，是“不用”而不是“不能”） 具有以下常用的功能： 给数组赋值：通过fill方法。 对数组排序：通过sort方法，按升序’ 比较数组：通过equa
Java中求两个数组交集的算法实现
最新发布
weixin_42360846的博客
07-10 369
在程序设计中，数组交集问题是一个基础且常见的问题。它涉及从两个数组中找出共有的元素，即两个数组的交集。这个问题看似简单，实则蕴含着丰富的算法思想和数据结构的应用。本章将带你走进数组交集的世界，概述这一问题在实际应用中的重要性，以及它在数据处理和分析中所扮演的角色。数组交集问题不仅可以锻炼我们的编程能力，还是理解更复杂数据结构和算法的基石。我们将探讨不同的解题思路和方法，它们包括使用HashSet，利用 Java 8 流(Stream) API，应用双重循环法，以及并查集结构等多种技术路径。
java——Array类的用法
D1573的博客
09-08 1213
【代码】java——Array类的用法。
Java 数组的基本使用【Array】
低调，谦虚，自律，反思，成长！
05-24 1292
Java 数组是一种用于存储多个同类型元素的线性数据结构 ···
Java中Array类
carrotluotian的博客
11-21 451
package demo04; import java.util.Arrays; /* java.util.Array是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作 public static String toString(数组)，将参数数组变成字符串（按默认格式，[元素1，元素2，元素3...]） public static void sort(数组)，按照默...
Java程序输入两个整型数组，输出两个数组的交集和并集
04-17
您可以使用Java的Set集合来实现求两个数组的交集和并集。具体实现可以参考以下代码： ```java import java.util.HashSet; import java.util.Set; public class ArrayIntersectionAndUnion { public static void ...
数组交集、并集与差集的操作方法
数组交集是指两个或多个数组中所有共同的元素组成的集合。例如，数组 A = [1, 2, 3] 和数组 B = [2, 3, 4] 的交集为 [2, 3]。 **1.2 数组并集** 数组并集是指两个或多个数组中所有元素组成的集合，不包含重复元素...
获取两个数组之间的交集，并集和补集
12-05
在Java中，获取两个数组之间的交集、并集和补集可以通过多种方法实现。下面是一个示例代码，展示了如何实现这些操作： ```java import java.util.Arrays; import java.util.HashSet; import java.util.Set; public...
java中array用法
01-07
简单的介绍array的基本用法. 注：不是ArrayList！
29选7的简单实现
yangdan888的专栏
07-15 792
import java.util.Arrays;public class T {  public static void main(String args[]) {    int[] a = new int[7];    int s = 0;    int i;    OUT: while (s       a[s] = (int) (Math.random() * 29) + 1;     
Java—Array类
weixin_46133760的博客
12-29 366
【代码】Java—Array类。
Java中的数组类Array
欢迎关注微信公众号：DroidMind
12-07 1004
java.lang.reflect.Array里面提供了动态创建和访问数组的静态类。下面我们来看看它拥有哪些静态方法可以使用。1、getXXX函数用来获取指定数组、指定索引的所对应的值。public static Object get(Object array, int index) throws IllegalArgumentException, ArrayIndexOutOfBo
Java Array 数组类
Regino的博客
03-04 360
本文介绍了 Java 中Array（数组类）的相关内容。。。
JAVA基础：JAVA Array 类介绍
一个初学者的博客
03-21 4072
JAVA   Array 类 在java.until类库中可以找到Arrays类,它有一套static方法,提供了操 作数组的实用功能。 其中有四中基本方法: 1.sort()用于对数组排序. 2.equals()用于比较两个数组是否相等. 3.fill()用于以某个值填充整个数组. 4.binarySearch()用于在已经排序的数组中查找元素.
深入理解 Java 中的 Arrays 类
yimeixiaolangzai的博客
06-26 543
Arrays排序: 对数组进行升序排序。搜索: 在数组中查找特定元素。比较: 比较两个数组是否相等。填充: 将指定值填充到数组中。转换: 将数组转换为List或字符串表示。
Java中的常用类Arrays
m0_67474817的博客
03-17 921
Arrays 操作数组的工具类（静态工厂） Arrays.toString(arr1)//static String toString(int[] a) 返回指定数组内容的字符串表示形式。 Arrays.equals(arr1,arr2)//static boolean equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true Arrays.equals(arr1,1,3,arr2,1,3)//static boolean equals(int[] a
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值