删除并标记字符串数组中的重复项

Question

我有这个

String array[] = {"test","testing again", "test"};

我想标记并删除重复项。这是我需要的输出：

2x test

testing again

有人可以帮我做这个吗？我尝试过使用 Set，但它似乎无法识别其中已经存在的字符串。

这是我的代码：

Set addons = new HashSet<String>();
final String[] arr ={"test","testing again", "test"};
            for (int i = 0; i < arr.length; i++) {
                Log.d(TAG, "contains adding " + arr[i]);

                if (addons.contains(arr[i])) {
                    //never enters here
                    Log.d(TAG, "contains " + arr[i]);
                    addons.remove(arr[i]);
                    addons.add("2 x " + arr[i]);
                } else {
                    addons.add("1 x " + arr[i]);
                }
            }

Answer 1

你可以这样做：

String[] arr = { "test", "testing again", "test" };
HashMap<String, Integer> counter = new HashMap<>();
for (int i = 0; i < arr.length; i++) {
    if (counter.containsKey(arr[i])) {
        counter.put(arr[i], counter.get(arr[i]) + 1);
    } else {
        counter.put(arr[i], 1);
    }
}
System.out.println("Occurrences:\n");
for (String key : counter.keySet()) {
    System.out.println(key + " x" + counter.get(key));
}

您的示例不起作用，因为当您发现新出现的单词时，您将其删除并用类似 2x [word] 的内容替换它，当该单词再次出现时 contains(...) 将 return false 因为它已经不在集合中了。

Answer 2

String[] arr ={"test","testing again", "test"};
Map<String, Integer> results = new HashMap<>();
for (int i = 0; i < arr.length; i++) {
  Log.d(TAG, "contains adding " + arr[i]);
  if (results.containsKey(arr[i])) {
      Log.d(TAG, "contains " + arr[i]);
      results.put(arr[i], results.get(arr[i]) + 1);
  } else {
      results.put(arr[i], 1);
  }
}

Answer 3

试试下面的代码。

String[] array ={"test","testing again","test"};
Set<String> uniqueWords = new HashSet<String>(Arrays.asList(array));

Answer 4

问题是你没有直接在你的 Set 中添加 "test"，而是“1 x test”。

所以你最好用一个Map来保存字符串，以及它出现的次数。

    String[] array = { "test", "testing again", "test" };
    Map<String, Integer> addons = new HashMap<>();

    for (String s : array) {
        System.out.println("Dealing with [" + s + "]");
        if (addons.containsKey(s)) {
            System.out.println("\tAlready contains [" + s  + "]");
            addons.put(s, addons.get(s) + 1); // increment count of s
        } else {
            System.out.println("\tFirst time seeing [" + s  + "]");
            addons.put(s, 1); // first time we encounter s
        }
    }

Answer 5

使用这个，其中 Map 的键是字符串元素，值是该元素的计数。

public static void main(String[] args) {
        String array[] = {"test","testing again", "test"};

        Map<String, Integer> myMap = new HashMap<>();

        for (int i = 0; i < array.length; i++) {
            if (myMap.containsKey(array[i])) {
                Integer count = myMap.get(array[i]);
                myMap.put(array[i], ++count);
            } else{
                myMap.put(array[i], 1);
            }
        }

        System.out.println(myMap);
    }

Answer 6

String array[] = {"test","testing again", "test"};
Map<String, Integer> countMap = new HashMap<>();
for (int i = 0; i<array.length; i++) {
    Integer count = countMap.get(array[i]);
    if(count == null) {
        count = 0;
    }
    countMap.put(array[i], (count.intValue()+1));
}
System.out.println(countMap.toString());

输出

{'test'=2, 'testing again'=1}

Answer 7

在java 8:

Stream.of("test", "testing again", "test")
        .collect(groupingBy(Function.identity(), counting()))
        .forEach((str, freq) -> {
            System.out.printf("%20s: %d%n", str, freq);
        });

Answer 8

试试这个：

 public static void main(String[] args) {

        Set<String> addons = new HashSet<>();
        final String[] arr = { "test", "testing again", "test","test","testing again" };
        int count = 0;
        for (int i = 0; i < arr.length; i++) {

            for (int j = 0; j < arr.length; j++) {
                if (arr[i].equals(arr[j])) {
                    count++;
                }
            }

            addons.add(count + " x " + arr[i]);
            count = 0;
        }

        System.out.println(addons);

    }

输出：

[2 x testing again, 3 x test]

Answer 9

您可以使用 Guava 中的 Multiset。

String array[] = {"test","testing again", "test"};
Multiset<String> set = HashMultiset.create(Arrays.asList(array));
System.out.println(set);

输出：

[test x 2, testing again]

Multiset 基本上计算您尝试添加对象的次数。

for (HashMultiset.Entry<String> entry :set.entrySet()) {
    System.out.println(entry.getCount() + "x " + entry.getElement());
}

输出：

2x test 
1x testing again

Answer 10

您可以使用自己的 class 来保存重复项：

class SetWithDuplicates extends HashSet<String> {

   private final Set<String> duplicates = new HashSet<>();

    @Override
    public boolean add(String e) {
       boolean added = super.add(e);
       if(!added) {
           duplicates.add(e);
       }
       return added;
    }

    public Set<String> duplicates() {
        return duplicates;
    }

}

并像@Ganpat Kaliya 一样使用它：

String[] array ={"test","testing again","test"};
SetWithDuplicates <String> uniqueWords = new SetWithDuplicates(Arrays.asList(array));
SetWithDuplicates <String> duplicates = uniqueWords.duplicates();

删除并标记字符串数组中的重复项

Remove and mark duplicates in a string array

java

arrays

string

android

set