什麼是比較的Java兩套來獲取在一組中的元素以最快的方式，而不是其他

Question

我有2個Hashsets這裏用戶和docbaseuser

我的代碼：

Iterator iterator = user.iterator(); 

     while (iterator.hasNext()) 
     { 
      String isid = (String)iterator.next(); 
      flag = getCount(isid, Docbaseuser); 
      if(flag == 0) 
      { 
       count++; 
       System.out.println("Unique user found!"); 
      } 

     } 



private int getCount(String isid, Set<String> docbaseuser) 
    { 
     // TODO Auto-generated method stub 

     int flag = 0; 
     System.out.println("execution reached getcount"); 
     Iterator iterator = docbaseuser.iterator(); 
     while(iterator.hasNext()) 
     { 
      String id = (String) iterator.next(); 
      if(isid.equalsIgnoreCase(id)) 
      { 
       System.out.println("MATCH !!!"); 
       flag++; 
       break; 
      } 
     } 
     return flag; 
    } 

有沒有更好的方法比較hashset用戶和hashset docbaseuser並從用戶hashset中獲取docbaseuser中不存在的元素？ 提前謝謝！

Answer 1

boolean flag=false; 
for(String files:user){ 
    for(String dbu:docbaseuser){ 
     if(files.equalsIgnoreCase(dbu)){ 
      flag=true; 
     } 
    } 
    if(flag){ 
     //user already exists 
     flag=false; 
    } 

Answer 2

我覺得你能做到這樣說：

public Set<String> fetch (Set<String> here, Set<String> notHere) { 
    return here.stream() 
      .filter(h -> !isIn(h, notHere)) 
      .collect(Collectors.toCollection(HashSet::new)); 
} 

private boolean isIn (String s, Set<String> set) { 
    for (String str : set) { 
     if (str.equalsIgnoreCase(s)) return true; 
    } 
    return false; 
} 

編輯：如果您不需要equalsIgnoreCase，那麼你可以這樣做：

public Set<String> fetch (Set<String> here, Set<String> notHere) { 
    return here.stream() 
      .filter(h -> !notHere.contains(h)) 
      .collect(Collectors.toCollection(HashSet::new)); 
} 

Answer 3

如果您需要一組user中的所有字符串，它們在docbaseuser中不存在，就像您使用String.equalsIgnoreCase()一一比較但希望HashSet或O（log n）複雜度爲TreeSet的查找元素的複雜性要小心，不要簡單地通過使用String.toUpperCase()或類似的方法將所有字符串轉換爲大寫或小寫字母。例如。有人可能會使用new TreeSet<>(String.CASE_INSENSITIVE_ORDER)。

這裏是方法類似於使用String.equalsIgnoreCase()與O（1）複雜性在建築物被用作索引的HashSet的初始成本比較字符串的溶液。但取決於上下文，這可以保持在其他地方並保持與docuserbase內容的更改同步。

@FunctionalInterface 
private static interface CharUnaryOperator { 
    char applyAsChar(char operand); 
} 

private static String mapCharacters(String s, CharUnaryOperator mapper) { 
    char[] chars = s.toCharArray(); 
    for (int i = 0; i < chars.length; i++) 
     chars[i] = mapper.applyAsChar(chars[i]); 
    return String.valueOf(chars); 
} 

private static Set<String> stringsNotPresentInOtherSetIgnoreCase(Set<String> set, Set<String> otherSet) { 
    Set<String> index = otherSet.stream() 
      .flatMap(s -> Stream.of(
        mapCharacters(s, Character::toUpperCase), 
        mapCharacters(s, Character::toLowerCase) 
        )) 
      .collect(Collectors.toCollection(HashSet::new)); 
    return set.stream() 
      .filter(s -> !index.contains(mapCharacters(s, Character::toUpperCase))) 
      .filter(s -> !index.contains(mapCharacters(s, Character::toLowerCase))) 
      .collect(Collectors.toCollection(HashSet::new)); 
} 

private static void test() { 
    Set<String> user = Stream.of("max", "John", "PETERSSON", "Tommy", "Strauß").collect(Collectors.toSet()); 
    Set<String> docbaseuser = Stream.of("Max", "Petersson", "Steve", "Brad", "Strauss").collect(Collectors.toSet()); 

    Set<String> usersNotInDocbaseuser = stringsNotPresentInOtherSetIgnoreCase(user, docbaseuser); 

    if (!usersNotInDocbaseuser.equals(Stream.of("John", "Tommy", "Strauß").collect(Collectors.toSet()))) { 
     System.out.println("Wrong result"); 
    } 
} 

代碼粘貼到一些類，以確保該stringsNotPresentInOtherSetIgnoreCase()方法適用正確調用test()。要特別注意使用前String.toUpperCase()轉化時被認爲相同的字符串Strauß和Strauss：

System.out.println("Strauß".toLowerCase().equals("strauss".toLowerCase())); 
System.out.println("Strauß".toUpperCase().equals("strauss".toUpperCase())); 
System.out.println("Strauß".equalsIgnoreCase("strauss")); 

結果：

false 
true 
false