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

最新推荐文章于 2024-07-20 15:10:20 发布
最新推荐文章于 2024-07-20 15:10:20 发布
阅读量2.5k 收藏 12
点赞数 2
分类专栏： java基础 文章标签： java arraylist

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

目录：

  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));
  }
 }
}

knight郭志斌
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的常用类Arrays
m0_67474817的博客
03-17 856
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
2021-05-24
qq99734744的博客
05-24 75
Arrays类 数组的工具类java.util.Arrays 由于数组对象本身没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。 查看JDK文档 Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意，是“不用”而不是“不能”） 具有以下常用的功能： 给数组赋值：通过fill方法。 对数组排序：通过sort方法，按升序’ 比较数组：通过equa
Java-两个数组的交集
最新发布
t1750982356的博客
07-20 124
2.怎么把交集结果转化成整数数组并返回（这里不能单纯用一个数组接收，因为容易出现数组大小设置不当，出现末尾多个0的情况）力扣上友友的思路：使用HashSet的contains方法要比用add方法判断要明智一些，这样可以少写一个HashSet。1.输出的结果有重复的元素（解决方法：用HashSet的add方法）输出结果中的每个元素一定是。[4,9] 也是可通过的。
java——Array类的用法
D1573的博客
09-08 1081
【代码】java——Array类的用法。
Java中Array类
carrotluotian的博客
11-21 406
package demo04; import java.util.Arrays; /* java.util.Array是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作 public static String toString(数组)，将参数数组变成字符串（按默认格式，[元素1，元素2，元素3...]） public static void sort(数组)，按照默...
29选7的简单实现
yangdan888的专栏
07-15 723
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;     
实现多个集合的交集，并集
09-02
下面将详细介绍如何在Java中实现多个数组的交集和并集。 首先，让我们从交集开始。假设我们有多个数组，例如`array1`, `array2`, `array3`等，我们想要找出它们共有的元素。一个简单的实现方式是先将这些数组合并为...
java代码-TwoArray
07-15
在Java编程语言中，"TwoArray"可能是指处理或操作两个数组的相关代码示例。从提供的信息来看，我们有一个名为`main.java`的源代码文件和一个`README.txt`的文本文件，后者通常用于提供代码的说明和指南。尽管没有...
Leecode初级算法_数组篇_实例
03-14
本资料中的“Aarray”可能包含了多个关于数组的LeetCode问题的Java实现，每个问题的解题思路和代码都会有所不同，可能是对数组的直接操作，也可能涉及到一些高级技巧，如动态规划、滑动窗口等。通过学习和理解这些...
取两个集合的交集
05-21
通过分析给定的示例代码，我们了解到一种计算字符串数组交集的具体实现方法。在实际开发中，根据具体的业务需求选择合适的算法是非常重要的。希望本文能够帮助读者更好地理解和掌握集合的相关知识。
Java数据结构和算法
06-19
集合不允许重复元素存在，通常用于去除重复项或进行数学运算如交集、并集等。 - **实现类**：`HashSet` (基于哈希表)、`TreeSet` (基于红黑树)。 ### 二、常用算法 #### 1. 排序算法 排序是数据处理中最常见的需求...
java中array用法
01-07
简单的介绍array的基本用法. 注：不是ArrayList！
Java—Array类
weixin_46133760的博客
12-29 322
【代码】Java—Array类。
java反射 数组类型_Java反射—Array类的使用
weixin_32705179的博客
02-12 387
有关Java反射的另外的文章：https://www.jianshu.com/nb/29780510不用说大家也知道java.lang.Array是对Java反射包中数组操作的一个类。JavaSE8的文档中对Array的描述是这样说的：The Array class provides static methods to dynamically create and access Java arra...
Java中的数组类Array
欢迎关注微信公众号：DroidMind
12-07 945
java.lang.reflect.Array里面提供了动态创建和访问数组的静态类。下面我们来看看它拥有哪些静态方法可以使用。1、getXXX函数用来获取指定数组、指定索引的所对应的值。public static Object get(Object array, int index) throws IllegalArgumentException, ArrayIndexOutOfBo
Java Array 数组类
Regino的博客
03-04 314
本文介绍了 Java 中Array（数组类）的相关内容。。。
Java基础~Java的Array类
feizuiku0116的博客
03-01 1013
一、介绍 ArrayList是集合中的一种，它支持索引 二、对象获取方法 构造器 说明 public ArrayList() 创建一个空的集合对象 三、添加元素的方法 方法名 说明 public boolean add(E e) 将指定的元素追加到此集合的末尾 public void add(int index,E element) 在此集合中的指定位置插入指定的元素 四、实例 package com.europeansheik.test; import ja
JAVA基础：JAVA Array 类介绍
一个初学者的博客
03-21 3990
JAVA   Array 类 在java.until类库中可以找到Arrays类,它有一套static方法,提供了操 作数组的实用功能。 其中有四中基本方法: 1.sort()用于对数组排序. 2.equals()用于比较两个数组是否相等. 3.fill()用于以某个值填充整个数组. 4.binarySearch()用于在已经排序的数组中查找元素.
使用Java类库：Array类、Arrays类
人生代码 ---- 公众号
04-01 744
Array类 继承关系 java.lang.Object java.lang.reflect.Array 原型声明 public final class Array extends Object 构造方法 private Array() 方法概览 static Object get(Object array, int index) static boolean getBoolean(...
Java取两个int数组的交集和并集
05-31
Java取两个int数组的交集和并集的代码如下： ```java public class ArrayIntersectionUnion { public static void main(String[] args) { int[] arr1 = { 1, 2, 3, 4, 5 }; int[] arr2 = { 4, 5, 6, 7, 8 }; // 求交集 Set<Integer> intersection = new HashSet<Integer>(); for (int i = 0; i < arr1.length; i++) { for (int j = 0; j < arr2.length; j++) { if (arr1[i] == arr2[j]) { intersection.add(arr1[i]); break; } } } System.out.println("Intersection: " + intersection); // 求并集 Set<Integer> union = new HashSet<Integer>(); for (int i = 0; i < arr1.length; i++) { union.add(arr1[i]); } for (int j = 0; j < arr2.length; j++) { union.add(arr2[j]); } System.out.println("Union: " + union); } } ``` 运行结果如下： ``` Intersection: [4, 5] Union: [1, 2, 3, 4, 5, 6, 7, 8] ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值