从字符串数组中删除具有相同字符的字符串

Question

我现在遇到了一个问题。在我的程序中，我需要从数组中删除具有相同字符的字符串。例如，假设：

我有三个数组，如下所示：

String[] name1 = {"amy", "jose", "jeremy", "alice", "patrick"};
String[] name2 = {"alan", "may", "jeremy", "helen", "alexi"};
String[] name3 = {"adel", "aron", "amy", "james", "yam"};

如您所见，name1 数组中有一个字符串 amy。而在接下来的两个数组中，我有像may、amy和yam这样的字符串。我需要的是一个最终数组，它不包含这些重复的字符串。我只需要保留每种名称的一次出现：我需要从最终数组中删除所有排列组合的名称。也就是说，最终数组应该为:

String[] finalArray={"amy", "jose", "alice", "patrick","alan", "jeremy", "helen", "alexi","adel", "aron", "james"}

以上数组已经移除了山药、五月份，并且只包括艾米。

到目前为止，我尝试使用HashSet的方式如下所示：

String[] name1 = {"Amy", "Jose", "Jeremy", "Alice", "Patrick"};
String[] name2 = {"Alan", "mAy", "Jeremy", "Helen", "Alexi"};
String[] name3 = {"Adel", "Aaron", "Amy", "James", "Alice"};
Set<String> letter = new HashSet<String>();
for (int i = 0; i < name1.length; i++) {
    letter.add(name1[i]);
}
for (int j = 0; j < name2.length; j++) {
    letter.add(name2[j]);
}
for (int k = 0; k < name3.length; k++) {
    letter.add(name3[k]);
}
System.out.println(letter.size() + " letters must be sent to: " + letter);

但是，这段代码的问题是它只删除相同字符串的多个出现。是否有其他可选方案？非常感谢您的任何帮助。

- Lal

Answer 1

你可以对字符串的字符数组进行排序(str.toCharArray())，并创建一个新的字符串来获取该字符串的“规范”表示。

然后，你可以将这些字符串添加到一个Set中，并检查每个字符串是否已经在集合中存在其规范表示。

Set<String> letter = new HashSet<String>();
for (int i = 0; i < name1.length; i++) {
    char[] chars = name1[i].toCharArray();
    Arrays.sort(chars);
    letter.add(new String(chars));
}
for (int j = 0; j < name2.length; j++) {
    char[] chars = name2[j].toCharArray();
    Arrays.sort(chars);
    letter.add(new String(chars));
}
for (int k = 0; k < name3.length; k++) {
    char[] chars = name3[k].toCharArray();
    Arrays.sort(chars);
    letter.add(new String(chars));
}

编辑：我将Set<char[]>更改为Set<String>，因为数组不会覆盖hashCode和equals，所以HashSet<char[]>不起作用。

- Eran

---

当我尝试像这样调试它：String a=Arrays.sort(name1[i].toCharArray());，它显示不兼容的类型，无法将void转换为字符串。 - Lal

@Lal 我的错。Arrays.sort 不会返回已排序的数组，所以你需要一个额外的数组变量。我会进行编辑。 - Eran

@Lal，结果中包含“Jeemry”而不是“Jeremy”。可以吗？ - user4910279

这个方法很有效，但是在得到输出后，我又不得不添加空格。对于字符串来说，这个方法非常完美。但对于我来说，实际上这些字符串由用空格分隔的数字组成。而且字符串的顺序也改变了。感谢您的大力支持，我真的非常感激您的支持。 - Lal

@Lal，我不明白你的问题。 - Eran

Answer 2

TreeSet可以使用比较器。看看这是否有帮助。如果要保持计数，请使用TreeMap。

package empty;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class RemoveDuplicateStrings {

    public static void main(String[] args) {
        String[] name1 = { "amy", "jose", "jeremy", "alice", "patrick" };
        String[] name2 = { "alan", "may", "jeremy", "helen", "alexi" };
        String[] name3 = { "adel", "aron", "amy", "james", "yam" };

        Comparator<String> comparator = new Comparator<String>() {
            @Override public int compare(String o1, String o2) {
                System.out.println("Compare(" + o1 + "," + o2 + ")");
                char[] a1 = o1.toCharArray();
                Arrays.sort(a1);
                char[] a2 = o2.toCharArray();
                Arrays.sort(a2);
                return new String(a1).compareTo(new String(a2));
            }
        };
        Set<String> set = new TreeSet<String>(comparator);

        for (String name : name1) {
            set.add(name);
        }
        for (String name : name2) {
            set.add(name);
        }
        for (String name : name3) {
            set.add(name);
        }

        String[] result = set.toArray(new String[set.size()]);
        System.out.println(Arrays.asList(result));

        // Using TreeMap to keep the count.

        TreeMap<String, Integer> map = new TreeMap<String, Integer>(comparator);

        addAll(name1, map);
        addAll(name2, map);
        addAll(name3, map);

        System.out.println(map);
    }

    private static void addAll(String[] names, TreeMap<String, Integer> map) {
        for (String name : names) {
            if (map.containsKey(name)) {
                int n = map.get(name);
                map.put(name, n + 1);
            } else
                map.put(name, 1);
        }
    }
}

- Dakshinamurthy Karra

---

非常好的答案，非常有效，谢谢 :) - Lal

相当缓慢 - 它将针对每个比较对 String 进行排序，并且将有相当多的比较。您应该创建数据的“规范化”集，然后进行组合。 - Boris the Spider

@KDM 你的回答中有没有可能获取每个字符串出现次数的计数？ - Lal

使用TreeMap而不是TreeSet。我正在修改答案并将其添加进去。 - Dakshinamurthy Karra

Answer 3

根据kdm的要求：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class RemoveDuplicateString {

    private static boolean add(Set<String> keySet, String s){
        char[] sortCharacters = s.toCharArray();
        Arrays.sort(sortCharacters);
        return keySet.add(new String(sortCharacters));
    }

    private static void check(Set<String> keySet, String []names, List<String> result){
        for (String name : names) {
            if (add(keySet, name)){
                result.add(name);
            }
        }
    }

    public static void main(String[] args) {
        String[] name1 = {"amy", "jose", "jeremy", "alice", "patrick"};
        String[] name2 = {"alan", "may", "jeremy", "helen", "alexi"};
        String[] name3 = {"adel", "aron", "amy", "james", "yam"};
        Set<String> keySet = new HashSet<String>();
        List<String> result = new ArrayList<String>();
        check(keySet, name1, result);
        check(keySet, name2, result);
        check(keySet, name3, result);
        System.out.println(result);
    }
}

- David Pérez Cabrera

Answer 4

一种替代方案，基于Java 8。

1) 创建一个包含规范化形式和所有已见不同形式的Map<String，List<String>

public static Map<String, List<String>> groupNormalised(final String[]... input) {
    return Arrays.stream(input)
            .flatMap(Arrays::stream)
            .collect(Collectors.groupingBy(s -> {
                char[] c = s.toCharArray();
                Arrays.sort(c);
                return new String(c);
            }));
}

例子：

Map<String, List<String>> grouped = groupNormalised(name1, name2, name3);        
grouped.forEach((k, v) -> System.out.printf("%s appears as %s%n", k, v));

输出：

eejmry appears as [jeremy, jeremy]
aceil appears as [alice]
eehln appears as [helen]
ejos appears as [jose]
adel appears as [adel]
aeilx appears as [alexi]
acikprt appears as [patrick]
aejms appears as [james]
amy appears as [amy, may, amy, yam]
anor appears as [aron]
aaln appears as [alan]

2) 处理 Map 以提取所需数据

现在你有一个选择，可以创建一个标准化形式的 Set：

final Set<String> normalisedForms = grouped.keySet();

或者您可以创建一个Set来存储第一次出现的元素：

final Set<String> first = grouped.values().stream()
        .map(c -> c.iterator().next())
        .collect(toSet());

或者作为数组：

final String[] first = grouped.values().stream()
        .map(c -> c.iterator().next())
        .toArray(String[]::new);

- Boris the Spider

---

可能是一个可行的解决方案..但我正在寻找JDK7中的解决方案..感谢您的回复.. - Lal

@Lal，除非你有坚持使用Java 7的充分理由，否则我建议你开始升级到Java 8。它已经发布一年多了... - Boris the Spider