在Java中检查一个数组是另一个数组的子集

在Java中，数组是一个对象。它是一种非原始数据类型，用于存储类似数据类型的值。

根据问题陈述，我们必须检查一个数组是否是另一个数组的子集。一个数组是另一个数组的子集，如果子数组的所有元素都在给定的数组中。

让我们探讨一下这篇文章，看看如何使用Java编程语言来完成。

向你展示一些实例

实例一

Suppose the original array is array1 {33, 51, 5, 31, 9, 4, 3}
The sub array is array2 {51, 9, 33, 3}
After checking if original array contains all elements of sub array, result will be:
array2 is a subset of array1

实例-2

Suppose the original array is array1 {14, 11, 33, 2, 9, 1}
The sub array is array2 {11, 2, 7, 1}
After checking if original array contains all elements of sub array, result will be:
array2 is not a subset of array1

实例-3

Suppose the original array is array1 {8, 28, 41, 3, 29, 10}
The sub array is array2 {28, 10}
Hence array2 is a sub array of array1

算法

算法-1 (通过使用2个for循环)

第1步 声明并初始化一个整数阵列。
第2步 实现多种方法的逻辑。
第3步 初始化两个for循环，并检查内部for循环的元素是否与外部for循环相匹配。
第4步打印结果。

算法-2 (通过使用HashList)

第1步 声明并初始化一个整数阵列。
第2步 实现多种方法的逻辑。
第3步 初始化hashset并通过ŌĆ£.contains(arr1[i])ŌĆØ检查子数组中的元素是否存在于原始数组中。
第4步 打印结果。

算法-3 (通过使用列表)

第1步声明并初始化一个整数阵列。
第2步 实现多种方法的逻辑。
第3步 初始化数组列表并检查子数组元素是否存在于原始数组中。
第4步 打印结果。

语法

为了获得一个数组的长度（数组中的元素数），数组有一个内置的属性，即 长度。

下面是它的语法:

array.length

其中，array指的是阵列参考。

多种方法

我们以不同的方式提供了解决方案。

通过使用2个for循环
通过使用哈希方法
使用List.contains()方法

让我们来看看这个程序和它的输出，一个接一个。

方法一：通过使用2个for循环

初始化两个for循环，并检查内部for循环的元素是否符合外部for循环。然后按照算法检查一个数组是否是另一个数组的子集。

例子

public class Main {
   public static void main(String args[]) {
      int array1[] = { 33, 51, 5, 31, 9, 4, 3 };
      int array2[] = { 51, 9, 33, 3 };
      int x = array1.length;
      int y = array2.length;subset(array1, array2, x, y);
      if (subset(array1, array2, x, y)) {
         System.out.print("array 2 is a subset of array 1");
      } else {
         System.out.print("array 2 is not a subset of array 1");
      }
   }

   //user defined method to check if array 2 is present in array 1
   static boolean subset(int array1[], int array2[], int x, int y) {
      int i, j = 0;
      for (i = 0; i < y; i++) {
         for (j = 0; j < x; j++)
            if (array2[i] == array1[j])
               break;
         /* return false when arr2[i] is not present in arr1[] */
         if (j == x)
            return false;
      }
      /* return true when all elements of arr2[] are present in arr1[] */
      return true;
   }
}

输出

array 2 is a subset of array 1

方法-2：通过使用哈希方法

初始化hashset并通过contains检查子数组的元素是否存在于原始数组中。然后按照算法检查一个数组是否是另一个数组的子集。

例子

import java.util.HashSet;
public class Main {
   public static void main(String[] args) {

      //declaring and initialising arrays
      int arr1[] = { 14, 11, 33, 2, 9, 1 };
      int arr2[] = { 11, 2, 7, 1 };

      //getting the length of the arrray
      int x = arr1.length;
      int y = arr2.length;
      if (subset(arr1, arr2, x, y))
         System.out.println("array 2 is a subset of array 1 ");
      else
         System.out.println(
      "array 2 is not a subset of array 1");
   }
   /* Return true if arr2[] is a subset of arr1[] */
   static boolean subset(int arr1[], int arr2[], int x, int y) {

      //declaring hashset
      HashSet<Integer> hashset = new HashSet<>();

      // hashset stores all the values of arr1
      for (int i = 0; i < x; i++) {
         if (!hashset.contains(arr1[i]))
            hashset.add(arr1[i]);
      }

      // for loop to check if all elements of arr2 also lies in arr1
      for (int i = 0; i < y; i++) {
         if (!hashset.contains(arr2[i]))
            /* return false when arr2[i] is not present in arr1[] */
         return false;
      }
      /* return true when all elements of arr2[] are present in arr1[] */
      return true;
   }
}

输出

array 2 is not a subset of array 1

方法3：通过使用List.contains()方法

初始化数组列表并检查子数组元素是否存在于原始数组中。然后按照算法检查一个数组是否是另一个数组的子集。

例子

import java.util.*;
public class Main {
   public static void main(String[] args) {

      //declaring and initialising arrays
      Integer arr1[] = { 8, 28, 41, 3, 29, 10 };
      Integer arr2[] = { 28, 10};

      //printing the arrays
      System.out.println("Original array is " + Arrays.toString(arr1));
      System.out.println("The sub array is " + Arrays.toString(arr2));

      //converting array to array list
      List<Integer> arr = new ArrayList<Integer>(Arrays.asList(arr1));

      // use contains() to check if the element 28 is present or not
      boolean ans = arr.contains(28);

      //if 28 is present then print successful message
      if (ans)
         System.out.println("The array 1 contains 28");
      else
         System.out.println("The array 1 does not contains 28");

      // use contains() to check if the element 10 is present or not
      ans = arr.contains(10);

      //if 10 is present then print successful message
      if (ans)
         System.out.println("The array 1 contains 10");
      else
         System.out.println("The array 1 does not contains 10");

      //print all elements of array 2 is in array 1
      System.out.println("Hence array 2 is a sub array of array 1");
   }
}

输出

Original array is [8, 28, 41, 3, 29, 10]
The sub array is [28, 10]
The array 1 contains 28
The array 1 contains 10
Hence array 2 is a sub array of array 1