Question

我制作了一个配对单词检测器，它给我的输出为true或false。
如果字符串数组中的值包含相同的字符串字母（重复），则将返回true。
我在下面的代码中使用了嵌套循环
现在，我想在不使用任何循环的情况下做同样的概念吗？
我该如何做，需要任何示例或需要什么类型的java collection framework？
谢谢

主要：

public class Main                                       
{                                       
  public static void main(String[] args)                                        
  {                                     
    String[] box = {"Monkey","Lion","Elephant","Zebra","Tiger", "Hippo"};                                       
    String[] box2 = {"Shop","Biscuit","Cake","Cake"};                                       
    String[] box3 = {"Entrance","Gate","Price","Door","Gate"};
    String[] box4 = {"Female","Male"};                                      
    System.out.println(Pairfinder.test(box));        //false                                
    System.out.println(Pairfinder.test(box2));       //true                                 
    System.out.println(Pairfinder.test(box3));       //true  
    System.out.println(Pairfinder.test(box4));       //false                            
  }                                     
}

子：

public class Pairfinder                                     
{                                       
  public static boolean test(String[] value)                                        
  {                                     
    for (int i = 0; i < value.length; i++) {                                        
            for (int j = 0; j < value.length; j++) {                                        
                if (value[i].equals(value[j]) && i != j) {                                      
                    return true;                                        
                }                                       
            }                                       
        }                                       
        return false;                                       
    }                                       
}

Answer 1

您可以将Java Streams与一个衬套一起使用：

public static boolean test(String[] value) {
    return Arrays.stream(value).anyMatch(v -> Collections.frequency(Arrays.asList(value), v) > 1);
}

但这可能不是性能最高的解决方案，因为它的时间复杂度为O（n²）。

或者，您可以使用distinct()：

public static boolean test(String[] value) {
    return Arrays.stream(value).distinct().count() < value.length;
}

如果要获取重复的值，可以将两种方法结合使用：

public static String[] getDuplicates(String[] value) {
    return Arrays.stream(value)
            .filter(v -> Collections.frequency(Arrays.asList(value), v) > 1)
            .distinct()
            .toArray(String[]::new);
}

由于frequency()计数，该版本的时间复杂度也为O（n²）。更好的解决方案是：

public static String[] getDuplicates(String[] value) {
    return Arrays.stream(value)
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
            .entrySet().stream()
            .filter(e -> e.getValue() > 1)
            .map(Map.Entry::getKey)
            .toArray(String[]::new);
}

Answer 2

这是您原因的简单示例

public static void main(String[] args) {
    String[] box = {"Monkey", "Lion", "Elephant", "Zebra", "Tiger", "Hippo"};
    String[] box2 = {"Shop", "Biscuit", "Cake", "Cake"};
    String[] box3 = {"Entrance", "Gate", "Price", "Door", "Gate"};
    String[] box4 = {"Female", "Male"};
    System.out.println(checkIt(box));        //false                                
    System.out.println(checkIt(box2));       //true                                 
    System.out.println(checkIt(box3));       //true  
    System.out.println(checkIt(box4));           //false   

}

public static boolean checkIt(String[] text) {
    return !Arrays.stream(text).allMatch(new HashSet<>()::add);
}

Answer 3

是的，您可以通过在时间复杂度O（n）中使用HashSet来做到这一点
这个想法是
将所有项目放入HashSet
如果array包含重复值
HashSet的长度将不等于array的长度
因为HashSet的添加功能会将指定的元素添加到该集中（如果尚不存在）

public static boolean test(String[] value) {
    Set<String> hashSet = new HashSet<>(Arrays.asList(value));
    return (value.length != hashSet.size());
}

Java检查数组元素重复存在而不使用循环？

3 个答案: