Java 检查arraylist是否为子集时如何处理多重性

我有两个

Arraylist

，我想检查其中一个是否是另一个的子集（排序在比较中并不重要）。 问题是：假设

Ar1={e，e，r}

和

Ar2={e，r，b，d}

。在我的代码中，它表示

Ar1

是一个子集。但是我希望它说false，因为

Ar2

只有一个e。怎么做

public static void dostuff(String word1,String word2){
    List<String> list1 = new ArrayList<String>();
    List<String> list2 = new ArrayList<String>();

    for (String character : word1.split("")) {
        list1.add(character);
    }
    for (String character : word2.split("")) {
        list2.add(character);
    }

    boolean sub = list1.containsAll(list2) || list2.containsAll(list1);

    System.out.println(sub);
}

publicstaticvoiddostuff（字符串word1、字符串word2）{
List list1=新的ArrayList（）；
List list2=新的ArrayList（）；
for（字符串：word1.split（“”）{
列表1.添加（字符）；
}
for（字符串：word2.split（“”）{
列表2.添加（字符）；
}
布尔sub=list1.containsAll（list2）| list2.containsAll（list1）；
系统输出打印项次（sub）；
}

这是一个可行的解决方案

检查

publicstaticvoidmain（字符串[]args）抛出java.lang.Exception
{
dostuff（“eer”、“erbd”）；
}
公共静态void dostuff（字符串word1、字符串word2）{
List list1=新的ArrayList（）；
for（字符串：word1.split（“”）{
列表1.添加（字符）；
}
布尔子=真；
for（字符串：word2.split（“”）{
如果（列表1.删除（字符））{
if（list1.isEmpty（））{
打破
}
}否则{
sub=假；
打破
}
}
系统输出打印项次（sub）；
}

请注意，数学和java集合是唯一的，因此请小心使用术语“子集”

您可以使用频率映射来测试一个列表是否“在另一个列表中具有相同或更少出现的每个元素”。i、 e.一旦您有了列表，您可以将其转换为

映射

，以存储每个列表元素的计数。使用映射可以避免改变原始列表（如果在测试中遇到元素时将其从主列表中删除，则可以这样做）：

publicstaticbooleanisublist（列表主列表、列表子列表）{
Map masterMap=newhashmap（）；
对于（T:masterList）masterMap.put（T，1+masterMap.getOrDefault（T，0））；
Map testMap=newhashmap（）；
对于（T:subList）testMap.put（T，1+testMap.getOrDefault（T，0））；
for（Map.Entry:testMap.entrySet（））{
if（masterMap.getOrDefault（entry.getKey（），0）

---

getOrDefault

仅在Java 8中可用，但您可以轻松编写自己的方法来处理相同的操作。

我认为这可能是您想要的。请注意，

list2.remove（elem）

如果元素被删除，则返回

true

，如果元素未被删除，则返回

false

public static boolean dostuff(String word1,String word2){
    List<String> list1 = new ArrayList<>();
    List<String> list2 = new ArrayList<>();
    List<String> list3;

    for (String character : word1.split("")) {
        list1.add(character);
    }

    for (String character : word2.split("")) {
        list2.add(character);
    }

    list3 = new ArrayList<>(list2);

    boolean isSubset = true;

    for (final String elem : list1) {
        if (!list2.remove(elem)) {
            isSubset = false;
            break;
        }
    }

    if (isSubset) {
        return true;
    }

    for (final String elem : list3) {
        if (!list1.remove(elem)) {
            return false;
        }
    }

    return true;
}

publicstaticbooleandostuff（字符串word1，字符串word2）{
List list1=新的ArrayList（）；
List list2=新的ArrayList（）；
清单3；
for（字符串：word1.split（“”）{
列表1.添加（字符）；
}
for（字符串：word2.split（“”）{
列表2.添加（字符）；
}
list3=新的ArrayList（list2）；
布尔值IsubSet=true；
for（最终字符串元素：list1）{
如果（！list2.删除（elem））{
isSubset=false；
打破
}
}
if（isSubset）{
返回true；
}
for（最终字符串元素：list3）{
如果（！list1.删除（elem））{
返回false；
}
}
返回true；
}
@johdee。下面的逻辑可能对您有所帮助。如果需要，您可以进行优化

ArrayList<String> list1 = new ArrayList<String>();
ArrayList<String> list2 = new ArrayList<String>();
list1.add("e");
list1.add("a");
list1.add("r");

list2.add("e");
list2.add("r");
list2.add("b");
list2.add("d");
list2.add("a");
System.out.println("list2 " + list2);
System.out.println("list1 " + list1);

Set<Integer> tempList = new HashSet<Integer>();

System.out.println("  containsAll " + list2.containsAll(list1));
for (int i = 0; i < list2.size(); i++) {
    for (int j = 0; j < list1.size(); j++) {
        if (list2.get(i).equals(list1.get(j))) {
            tempList.add(i);
        }
    }
}
System.out.println(" tempList  " + tempList);
System.out.println("list 1 is subset of list 2  "
        + (tempList.size() == list1.size()));

ArrayList list1=新的ArrayList（）；
ArrayList list2=新的ArrayList（）；
清单1.添加（“e”）；
清单1.添加（“a”）；
清单1.添加（“r”）；
清单2.添加（“e”）；
清单2.添加（“r”）；
清单2.添加（“b”）；
清单2.添加（“d”）；
清单2.添加（“a”）；
System.out.println（“list2”+list2）；
System.out.println（“列表1”+列表1）；
Set templast=new HashSet（）；
System.out.println（“containsAll”+list2.containsAll（list1））；
对于（int i=0；i
现在我明白了内容的顺序并不重要，您只想知道一个字符串的所有字符是否都存在于另一个字符串中（频率相同），反之亦然

尝试此函数，它将检查所有内容，而无需调用该方法两次，也无需使用流：

public static boolean subsetExists(String s1, String s2) {
    String temp = s2.replaceAll(String.format("[^%s]", s1), "");
    char[] arr1 = s1.toCharArray();
    char[] arr2 = temp.toCharArray();
    Arrays.sort(arr1);
    Arrays.sort(arr2);

    boolean isSubset = new String(arr2).contains(new String(arr1));
    if (!isSubset) {
        temp = s1.replaceAll(String.format("[^%s]", s2), "");
        arr1 = temp.toCharArray();
        arr2 = s2.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);

        isSubset = new String(arr1).contains(new String(arr2));
    }
    return isSubset;
}

您不必费心将
字符串
s转换为
列表
s。我们正在检查
s1
中的所有字母是否都存在于
s2
中，反之亦然

我们从
s2
中删除了不在
s1
中的字符，并将其存储在一个临时
字符串中。将临时
字符串
和
s1
转换为
char[]
s。然后我们对两个数组进行排序，并将它们转换回
String
s。然后，我们可以检查新排序的临时
字符串
是否包含（）。如果此结果为false，则我们将相同的逻辑检查从
s2
应用到
s1

用法：

public static void main(String[] args) throws Exception {
    String s1 = "eer";
    String s2 = "bderz";
    String s3 = "bderzzeee";

    System.out.println(subsetExists(s1, s2));
    System.out.println(subsetExists(s1, s3));
}

public static boolean subsetExists(String s1, String s2) {
    String temp = s2.replaceAll(String.format("[^%s]", s1), "");
    char[] arr1 = s1.toCharArray();
    char[] arr2 = temp.toCharArray();
    Arrays.sort(arr1);
    Arrays.sort(arr2);

    boolean isSubset = new String(arr2).contains(new String(arr1));
    if (!isSubset) {
        temp = s1.replaceAll(String.format("[^%s]", s2), "");
        arr1 = temp.toCharArray();
        arr2 = s2.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);

        isSubset = new String(arr1).contains(new String(arr2));
    }
    return isSubset;
}

结果:

false
true

我自己已经找到了解决方案，请检查这是否正确，但我相信它是正确的

public static void dostuff(String word1, String word2) {
    boolean sub = false;

    ArrayList<String> list1 = new ArrayList<String>();
    ArrayList<String> list2 = new ArrayList<String>();
    ArrayList<String> list3 = new ArrayList<String>();
    for (int i = 0; i < word1.length(); i++) {
        list1.add(word1.split("")[i]);
    }
    for (int i = 0; i < word2.length(); i++) {
        list2.add(word2.split("")[i]);
    }

    if (list1.size() >= list2.size()) {
        for (String i : list2) {
            if (list1.contains(i)) {
                list1.remove(i);
                list3.add(i);
            }
        }
        if (list2.containsAll(list3) && list2.size() == list3.size()) {
            sub = true;
        }
    } else if (list2.size() > list1.size()) {
        for (String i : list1) {
            if (list2.contains(i)) {
                list2.remove(i);
                list3.add(i);
            }
            if (list1.containsAll(list3) && list1.size() == list3.size()) {
                sub = true;
            }
        }
    }
    System.out.println(sub);
}

publicstaticvoiddostuff（字符串word1、字符串word2）{
布尔子=假；
ArrayList list1=新的ArrayList（）；
ArrayList list2=新的ArrayList（）；
ArrayList list3=新的ArrayList（）；
for（int i=0；i=list2.size（））{
for（字符串i:list2）{
如果（列表1.包含（i））{
列表1.remo
false
true

public static void dostuff(String word1, String word2) {
    boolean sub = false;

    ArrayList<String> list1 = new ArrayList<String>();
    ArrayList<String> list2 = new ArrayList<String>();
    ArrayList<String> list3 = new ArrayList<String>();
    for (int i = 0; i < word1.length(); i++) {
        list1.add(word1.split("")[i]);
    }
    for (int i = 0; i < word2.length(); i++) {
        list2.add(word2.split("")[i]);
    }

    if (list1.size() >= list2.size()) {
        for (String i : list2) {
            if (list1.contains(i)) {
                list1.remove(i);
                list3.add(i);
            }
        }
        if (list2.containsAll(list3) && list2.size() == list3.size()) {
            sub = true;
        }
    } else if (list2.size() > list1.size()) {
        for (String i : list1) {
            if (list2.contains(i)) {
                list2.remove(i);
                list3.add(i);
            }
            if (list1.containsAll(list3) && list1.size() == list3.size()) {
                sub = true;
            }
        }
    }
    System.out.println(sub);
}

public static void dostuff(String word1, String word2) {
    Map<String, Long> freq1 = Arrays.stream(word1.split("")).collect(
        Collectors.groupingBy(Function.identity(), Collectors.counting()));

    Map<String, Long> freq2 = Arrays.stream(word2.split("")).collect(
        Collectors.groupingBy(Function.identity(), Collectors.counting()));

    System.out.println(contains(freq1, freq2) || contains(freq2, freq1));
}

private static boolean contains(Map<String, Long> freq1, Map<String, Long> freq2) {
    return freq1.entrySet().stream().allMatch(
        e1 -> e1.getValue().equals(freq2.get(e1.getKey())));
}

dostuff("eer", "erbd"); // {r=1, e=2}, {b=1, r=1, d=1, e=1}, false

dostuff("erbed", "eer"); // {b=1, r=1, d=1, e=2}, {r=1, e=2}, true