Question

给出一个字符串数组，您将如何在数组中找到第一个唯一的String元素

public static String UniqueString(String[] s) {

    String str ="";

        for(int i=0;i<s.length;i++) {
            for(int j=i+1;j<s.length;j++) {
                System.out.println(s[i]+" "+s[j]);
                str = s[i];
                if(str==s[j]) {
                   break;
                }

                }if(!(str==s[i+1])){
                    return str;
                }

    }

    return str;
    }

所以{Dog，Cat，Dog，Wolf，lion}的String数组将返回为Cat

Answer 1

您非常接近可行的解决方案，您需要一个标志来指示是否在String中再次找到了s（不确定您到了names）。另外，我们将String与.equals（而非==）进行比较。方法名称以小写字母开头。像

public static String uniqueString(String[] s) {
    for (int i = 0; i < s.length; i++) {
        boolean unique = true;
        for (int j = i + 1; j < s.length; j++) {
            if (s[j].equals(s[i])) {
                s[j] = s[s.length - 1]; // <-- handle bug, ensure that dupes aren't
                                        // found again.
                unique = false;
                break;
            }
        }
        if (unique) {
            return s[i];
        }
    }
    return "";
}

Answer 2

您的方法与列表的大小成平方增长。有一种更好的方法，它在列表大小上基本上是线性的，即使用从字符串到出现次数的有序映射。使用一次遍历列表来构建地图，然后一次遍历地图以找到计数为1的第一个元素（如果有）。您可以使用LinkedHashMap来实现。

public static String uniqueString(String[] list) {
    Integer ZERO = 0; // to avoid repeated autoboxing below
    final LinkedHashMap<String, Integer> map = new LinkedHashMap<>(list.size());

    // build the map
    for (String s : list) {
        Integer count = map.getOrDefault(s, ZERO);
        map.put(s, count + 1);
    }

    // find the first unique entry. Note that set order is deterministic here.
    for (Set.Entry<String, Integer> entry : map.entrySet()) {
        if (entry.getValue() == 1) {
            return entry.getKey();
        }
    }

    // if we get this far, there was no unique string in the list
    return "";
}

请注意，您可以使用任何一种Map实现（包括HashMap），并通过将第二个循环替换为原始列表中的循环来放弃LinkedHashMap的有序属性：< / p>

for (String s : list) {
    if (map.get(s) == 1) {
        return s;
    }
}

但是，如果列表中包含很多重复的字符串，则需要遍历映射可能需要更少的迭代次数。因此，不妨使用LinkedHashMap的附加功能，与HashMap相比，您获得的性能损失很少。

Answer 3

也许还有另一种解决方案也可以以Java-8的方式解决您的问题：

使用use of out-of-scope declaration of 'a'记录重复字符串的数量，然后
从头到尾直接遍历数组，
一旦字符串不重复，我们就将其保存在那里。

那可能是这样的：

map

另外，您可以像其他人提到的那样转到public static void main(String... args) { String[] arr = {"Dog", "Cat", "Dog", "Wolf", "lion"}; Map<String, Long> stringCountMap = Arrays.stream(arr) .collect(Collectors.groupingBy(s -> s, Collectors.counting())); for (String s : arr) { if (stringCountMap.get(s) == 1) { System.out.println("The first non-duplicate string: " + s); break; } } }，以保持顺序以避免再次遍历原始数组，如下所示：

LinkedHashMap

输出始终为：

private static void another(String[] arr) {
    Map<String, Long> stringCountMap = Arrays.stream(arr)
            .collect(Collectors.groupingBy(s -> s, LinkedHashMap::new, Collectors.counting()));
    for (String s : stringCountMap.keySet()) {
        if (stringCountMap.get(s) == 1) {
            System.out.println("The first non-duplicate string: " + s);
            break;
        }
    }
}

Answer 4

Java 8

public static String uniqueString(String[] s) {
    StringBuilder result = new StringBuilder();
    Stream.of(s)
            .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()))
            .entrySet()
            .stream()
            .filter(entry -> entry.getValue() == 1)
            .findFirst()
            .ifPresent(entry -> result.append(entry.getKey()));
    return result.toString();
}

Answer 5

以上答案并非在所有情况下都有效。例如{“ Dog”，“ Dog”，Cat}会返回dog。问题是它不检查整个数组是否重复。

private static String getFirstUniqueString(String[] names) {
    for(int x=0;x<names.length;x++)
    {
        if(countOccurences(names[x],names) == 1 )
            return names[x];
    }
    return "No Unique Strings";
}

private static int countOccurences(String string, String[] names) 
{
    int count=0;
    for(int y = 0; y<names.length;y++)
    {
        if(names[y].equals(string))
        {
            count++;
            if(count >1 )
                return count;
        }
    }
    return count;
}

相反，可以将其分为两部分。一种方法是找到唯一的字符串，另一种方法是通过唯一的方式对出现的次数进行计数，我们可以精确地计算出整个数组中单词被提及的次数。如果您只是想了解更多信息，然后又想节省运行时间，请取消注释if语句。

字符串数组中的第一个唯一字符串

5 个答案: