在 Java 中检查一个数组是否是另一个数组的子集
在 Java 中，数组是一个对象。它是一种非原始数据类型，用于存储类似数据类型的值。
根据问题陈述，我们必须检查一个数组是否是另一个数组的子集。如果子数组的所有元素都存在于给定数组中，则数组是另一个数组的子集。
让我们探索这篇文章，看看如何使用 Java 编程语言来实现它。
向您展示一些实例
实例 1
假设原始数组为 array1 {33, 51, 5, 31, 9, 4, 3}
子数组为 array2 {51, 9, 33, 3}
检查原始数组是否包含子数组的所有元素后，结果将是:
array2 是 array1 的子集
实例 2
假设原始数组为 array1 {14, 11, 33, 2, 9, 1}
子数组为 array2 {11, 2, 7, 1}
检查原始数组是否包含子数组的所有元素后，结果将是:
array2 不是 array1 的子集
实例-3
假设原始数组为 array1 {8, 28, 41, 3, 29, 10}
子数组为 array2 {28, 10}
因此 array2 是 array1 的子数组
算法
算法-1(使用 2 个 for 循环)
步骤 1 - 声明并初始化一个整数数组。
步骤 2 - 实现多种方法的逻辑。
步骤 3 - 初始化两个 for 循环并检查内层 for 循环的元素与外层 for 循环匹配。
步骤 4 - 打印结果。
算法 2(使用 HashList)
步骤 1 - 声明并初始化一个整数数组。
步骤 2 - 实现多种方法的逻辑。
步骤 3 - 初始化 hashset 并通过".contains(arr1[i])"检查子数组的元素是否存在于原始数组中。
步骤 4 - 打印结果。
算法 3(使用 List)
步骤 1 - 声明并初始化一个整数数组。
步骤 2 - 实现多种方法的逻辑。
步骤 3 - 初始化数组列表并检查子数组元素是否存在于原始数组中。
步骤 4 - 打印结果。
语法
要获取数组的长度(该数组中的元素数)，数组有一个内置属性，即 length。
下面引用它的语法 -
array.length
其中，"array"指的是数组引用。
多个方法
我们提供了不同方法的解决方案。
使用 2 个 for 循环
使用哈希
使用 List.contains() 方法
让我们逐一查看程序及其输出。
方法 1:使用 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");
}
}
//用户定义方法来检查数组 2 是否存在于数组 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;
/* 当 arr2[i] 不存在于 arr1[] 中时返回 false */
if (j == x)
return false;
}
/* 当 arr2[] 的所有元素都存在于 arr1[] 中时返回 true */
return true;
}
}
输出
array 2 is a subset of array 1
方法 2:使用哈希算法
初始化哈希集，并通过".contains(arr1[i]"检查子数组元素是否存在于原始数组中。然后根据算法检查一个数组是否是另一个数组的子集。
示例
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
//声明并初始化数组
int arr1[] = { 14, 11, 33, 2, 9, 1 };
int arr2[] = { 11, 2, 7, 1 };
//获取数组的长度
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");
}
/* 如果 arr2[] 是 arr1[] 的子集，则返回 true */
static boolean subset(int arr1[], int arr2[], int x, int y) {
//声明 hashset
HashSet<Integer> hashset = new HashSet<>();
// hashset 存储 arr1 的所有值
for (int i = 0; i < x; i++) {
if (!hashset.contains(arr1[i]))
hashset.add(arr1[i]);
}
// for 循环检查 arr2 的所有元素是否也位于 arr1 中
for (int i = 0; i < y; i++) {
if (!hashset.contains(arr2[i]))
/* 如果 arr2[i] 不存在于 arr1[] 中，则返回 false */
return false;
}
/* 当 arr2[] 的所有元素都存在于 arr1[] 中时返回 true */
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) {
//声明和初始化数组
Integer arr1[] = { 8, 28, 41, 3, 29, 10 };
Integer arr2[] = { 28, 10};
//打印数组
System.out.println("原始数组是 " + Arrays.toString(arr1));
System.out.println("子数组是 " + Arrays.toString(arr2));
//将数组转换为数组列表
List<Integer> arr = new ArrayList<Integer>(Arrays.asList(arr1));
// 使用 contains() 检查元素 28 是否存在
boolean ans = arr.contains(28);
//如果存在 28，则打印成功消息
if (ans)
System.out.println("数组 1 包含 28");
else
System.out.println("数组 1 不包含 28");
// 使用 contains() 检查元素 10 是否存在
ans = arr.contains(10);
//如果存在 10，则打印成功消息
if (ans)
System.out.println("数组 1 包含 10");
else
System.out.println("数组 1 不包含 10");
//打印数组 2 的所有元素是否都在数组 1 中
System.out.println("因此数组 2 是数组 1 的子数组");
}
}
输出
原始数组为 [8, 28, 41, 3, 29, 10] 子数组为 [28, 10] 数组 1 包含 28 数组 1 包含 10 因此数组 2 是数组 1 的子数组
在本文中，我们探讨了如何使用 Java 编程语言检查一个数组是否是另一个数组的子集。
相关文章
有用资源
java 参考教程 - 该教程包含有关 java 的更多信息:https://www.cainiaomax.com/java/
