如何在JAVA中从两个集合中获取不匹配的字符串？

如何只获取一次不匹配的元素？ 我的代码如下：

Set<String> hashSet = new HashSet<String>(); //consist 90 elements
Set<Object> hashSet2 = new HashSet<Object>();// consist 9 elements
for (String string : hashSet ) {
                for(Object obj: hashSet2){
                     if(obj.equals(string)){
                         System.out.println(string + "\t is present in tracking     sheet");     
                     }
                     if(!obj.equals(string)){
                          System.out.println(string + "\t is not sheet");

                     }
                    }

         }

---

感谢大家提供的意见和解决方案。我已经选择了一个作为公认的答案（KISS：保持简短）（如果允许的话，我会选择更多：-）），但很多都是有用的。

尝试使用一个布尔值，如果找到它可以设置为true。我假设当您找到

字符串时，您可以
中断

for (String string : hashSet ) {

            boolean found = false;
            for(Object obj: hashSet2){
                 if(obj.equals(string)){
                     found = true;
                     break;
                 }
            }
            if (found) {
               System.out.println(string + "\t is present in tracking sheet");
            } else {
               System.out.println(string + "\t is not sheet");
            }

}

尝试使用一个布尔值，如果找到该布尔值，可以将其设置为true。我假设当您找到
字符串时，您可以
中断

for (String string : hashSet ) {

            boolean found = false;
            for(Object obj: hashSet2){
                 if(obj.equals(string)){
                     found = true;
                     break;
                 }
            }
            if (found) {
               System.out.println(string + "\t is present in tracking sheet");
            } else {
               System.out.println(string + "\t is not sheet");
            }

}

就这么做吧：

Set<String> hashSet = new HashSet<String>(); // consist 90 elements
Set<Object> hashSet2 = new HashSet<Object>(); // consist 9 elements
for (String string : hashSet) {
    if (hashSet2.contains(string)) {
        System.out.println(string + "\t is present in tracking     sheet");
    } else {
        System.out.println(string + "\t is not sheet");
    }
}

Set hashSet=new hashSet（）；//由90个元素组成
Set hashSet2=新HashSet（）；//由9个要素组成
for（字符串：hashSet）{
if（hashSet2.contains（字符串））{
System.out.println（字符串+“\t出现在跟踪表中”）；
}否则{
System.out.println（字符串+“\t不是表”）；
}
}
只需执行以下操作：

Set<String> hashSet = new HashSet<String>(); // consist 90 elements
Set<Object> hashSet2 = new HashSet<Object>(); // consist 9 elements
for (String string : hashSet) {
    if (hashSet2.contains(string)) {
        System.out.println(string + "\t is present in tracking     sheet");
    } else {
        System.out.println(string + "\t is not sheet");
    }
}

Set hashSet=new hashSet（）；//由90个元素组成
Set hashSet2=新HashSet（）；//由9个要素组成
for（字符串：hashSet）{
if（hashSet2.contains（字符串））{
System.out.println（字符串+“\t出现在跟踪表中”）；
}否则{
System.out.println（字符串+“\t不是表”）；
}
}
您可以使用该库进行析取（）。它将返回一个集合，其中包含两个集合之间未共享的元素

Collection nonMatchingSet = CollectionUtils.disjunction(hashSet , hashSet2);

可以将库用于析取（）。它将返回一个集合，其中包含两个集合之间未共享的元素

Collection nonMatchingSet = CollectionUtils.disjunction(hashSet , hashSet2);

尝试此解决方案，在此代码中，hashset中所有在hashset2中具有equals对象的项都将从hashset中删除：

    hashSet.removeAll(hashSet2);
    for (String s : hashSet) {
        System.out.println(s + " is not in sheet !");
    }

尝试此解决方案，在此代码中，hashset中所有在hashset2中具有equals对象的项都将从hashset中删除：

    hashSet.removeAll(hashSet2);
    for (String s : hashSet) {
        System.out.println(s + " is not in sheet !");
    }

您可以使用
Set
轻松完成此操作

  Set<String> hashSet = new HashSet<>();
  Set<Object> hashSet2 = new HashSet<>();
  hashSet.add("1");
  hashSet.add("2");
  hashSet.add("4") ;
  hashSet2.add("1");
  hashSet2.add("3");
  hashSet2.add("5");
  Set<Object> temp=new HashSet<>();
  temp.addAll(hashSet2);
  hashSet2.removeAll(hashSet); // remove common elements
  hashSet.removeAll(temp);// remove common elements 
  hashSet2.addAll(hashSet); // add unique values sets
  System.out.println(hashSet2);

您可以使用
Set
轻松完成此操作

  Set<String> hashSet = new HashSet<>();
  Set<Object> hashSet2 = new HashSet<>();
  hashSet.add("1");
  hashSet.add("2");
  hashSet.add("4") ;
  hashSet2.add("1");
  hashSet2.add("3");
  hashSet2.add("5");
  Set<Object> temp=new HashSet<>();
  temp.addAll(hashSet2);
  hashSet2.removeAll(hashSet); // remove common elements
  hashSet.removeAll(temp);// remove common elements 
  hashSet2.addAll(hashSet); // add unique values sets
  System.out.println(hashSet2);

obj
是
对象
类的实例。您在这里执行的是
obj.equals（string）
意味着您正在调用
对象的equals方法
，这等于方法检查
身份检查
。但是为了找到相似性，您必须检查
相等性检查
obj
是
对象
类的实例。您在这里执行的是
obj.equals（string）
意味着您正在调用
对象的equals方法
，这等于方法检查
身份检查
。但是为了找到相似性，您必须检查
相等性检查
代码

   List<String> list1 = Arrays.asList("1", "2", "3");
    List<String> list2 = Arrays.asList("1", "2", "4", "5");

    Set<String> hashSet = new HashSet<>(list1);
    Set<String> hashSet2 = new HashSet<>(list2);

    hashSet.retainAll(hashSet2);

    Set<String> totallSet =   Stream.of(list1,list2)
                                .flatMap( string -> string.stream())
                                .collect(Collectors.toSet());

    totallSet.removeAll(hashSet);

    totallSet.forEach(i -> System.out.print(" " + i));

代码

hashSet.retainAll
方法还可以帮助您在运行以下语句后，从hashSet2中删除所有不在hasSet中的项：

hashSet.retainAll(hashSet2);

hashSet2将只包含hashSet中存在的元素。它们出现在跟踪表中。
hashSet.retainal
方法还可以帮助您在运行以下语句后，从hashSet2中删除所有不在hasSet中的项目：

hashSet.retainAll(hashSet2);

package Example;

import java.util.*;

public class CopyOfSample2 {


public static void main(String s[]){

        Set<String> set1=new HashSet<String>();
        Set<String> set2=new HashSet<String>();
        Set<String> difference=new HashSet<String>(set1);

        set1.add("1");
        set1.add("5");
        set1.add("2");

        set2.add("3");
        set2.add("2");
        set2.add("1");


        difference.removeAll(set2);
        System.out.println("Difference" +difference);
    }
}

hashSet2将只包含hashSet中存在的元素。它们出现在跟踪表中。
包装示例；
package Example;

import java.util.*;

public class CopyOfSample2 {


public static void main(String s[]){

        Set<String> set1=new HashSet<String>();
        Set<String> set2=new HashSet<String>();
        Set<String> difference=new HashSet<String>(set1);

        set1.add("1");
        set1.add("5");
        set1.add("2");

        set2.add("3");
        set2.add("2");
        set2.add("1");


        difference.removeAll(set2);
        System.out.println("Difference" +difference);
    }
}

导入java.util.*；
样本2的公共类副本{
公共静态void main（字符串s[]{
Set set1=新的HashSet（）；
Set set2=新的HashSet（）；
设置差异=新哈希集（set1）；
set1.添加（“1”）；
第1条增补（“5”）；
set1.添加（“2”）；
第2条增补（“3”）；
第2条增补（“2”）；
第2条增补（“1”）；
差异。移除所有（set2）；
系统输出打印项次（“差异”+差异）；
}
}
包装示例；
导入java.util.*；
样本2的公共类副本{
公共静态void main（字符串s[]{
Set set1=新的HashSet（）；
Set set2=新的HashSet（）；
设置差异=新哈希集（set1）；
set1.添加（“1”）；
第1条增补（“5”）；
set1.添加（“2”）；
第2条增补（“3”）；
第2条增补（“2”）；
第2条增补（“1”）；
差异。移除所有（set2）；
系统输出打印项次（“差异”+差异）；
}
}
在循环内设置任何布尔值，如果该值为
true
，则打印
System.out.println（字符串+“\t不是表”）语句。！！在循环内设置任何布尔值，如果它是
true
，则打印
System.out.println（字符串+“\t不是表”）语句。！！你错过了真正的问题。@Ruchiragayanaranawera你能告诉我它是什么吗？OP的列表像
{1,2,3}
和
{1,2,4,5}
那么答案应该是
{3,4,5}
，而你的答案不是这样。@Ruchiragayanaranawera现在好点了吗？@Lastmind我敢肯定你在拉我的腿：老朋友；）你错过了真正的问题。@Ruchiragayanaranawera你能告诉我它是什么吗？OP的列表像
{1,2,3}
和
{1,2,4,5}
那么答案应该是
{3,4,5}
，而你的答案不是这样。@Ruchiragayanaranawera现在好点了吗？@Lastmind我敢肯定你在拉我的腿：老朋友；）我的答案现在怎么样？@KickButtowski现在很好谢谢你的纠正和帮助我变得更好谢谢你我的答案现在怎么样？@KickButtowski现在很好谢谢你的纠正和帮助我变得更好谢谢you@SugatMankar如果答案对你有帮助，出于对上帝的爱，接受它作为你的答案，表明你关心他人的帮助you@SugatMankar如果这个答案对你有帮助，出于对上帝的爱，接受它作为你的答案，表明你关心他人，努力帮助你。这很简单，也很简短。（吻：-保持简单和简短）对不起，
我在想什么
非常感谢这很简单和简短。（吻：-保持简单和简短）对不起，
我在想什么