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

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

我有3个数组，比如

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"}

（上面的数组删除了yam和may，仅包括amy）

到目前为止，我使用

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);

String[]name1={“艾米”、“何塞”、“杰里米”、“爱丽丝”、“帕特里克”}；
String[]name2={“Alan”、“mAy”、“Jeremy”、“Helen”、“Alexi”}；
String[]name3={“Adel”、“Aaron”、“Amy”、“James”、“Alice”}；
Set letter=新的HashSet（）；
for（int i=0；i

---

但是，这段代码的问题在于，它只是删除了同一字符串的多个实例。还有其他选择吗？非常感谢您的帮助。

您可以对字符串的字符数组进行排序（

str.tocharray（）

），并从排序后的数组中创建新字符串，以获得字符串的“规范”表示形式

然后可以将这些字符串添加到

集合

，并检查每个字符串的规范表示是否已在集合中

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 letter=new HashSet（）；
for（int i=0；i

编辑：我将

集合

更改为

集合

，因为数组不覆盖

哈希代码

且

等于

，所以

哈希集

不起作用。

允许我们给出一个比较器。看看这是否有帮助。为了保持计数，请使用一个

包为空；
导入java.util.array；
导入java.util.Comparator；
导入java.util.Set；
导入java.util.TreeMap；
导入java.util.TreeSet；
公共类RemovedUpplicateStrings{
公共静态void main（字符串[]args）{
字符串[]名称1={“艾米”、“何塞”、“杰里米”、“爱丽丝”、“帕特里克”}；
String[]name2={“alan”、“may”、“jeremy”、“helen”、“alexi”}；
字符串[]name3={“adel”、“aron”、“amy”、“james”、“yam”}；
比较器比较器=新比较器（）{
@重写公共整数比较（字符串o1、字符串o2）{
System.out.println（“比较（“+o1+”，“+o2+”））；
char[]a1=o1.toCharArray（）；
数组。排序（a1）；
char[]a2=o2.toCharArray（）；
数组。排序（a2）；
返回新字符串（a1）。比较（新字符串（a2））；
}
};
Set=新树集（比较器）；
for（字符串名称：name1）{
设置。添加（名称）；
}
for（字符串名称：name2）{
设置。添加（名称）；
}
for（字符串名称：name3）{
设置。添加（名称）；
}
String[]result=set.toArray（新字符串[set.size（）]）；
System.out.println（Arrays.asList（result））；
//使用TreeMap保持计数。
树映射=新树映射（比较器）；
addAll（name1，map）；
addAll（name2，map）；
addAll（name3，map）；
系统输出打印项次（map）；
}
私有静态void addAll（字符串[]名称，树映射）{
for（字符串名称：名称）{
if（地图容器（名称））{
int n=map.get（名称）；
地图放置（名称，n+1）；
}否则
地图放置（名称，1）；
}
}
}

与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);
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Set；
公共类RemovedUpplicateString{
私有静态布尔添加（设置键集，字符串s）{
char[]sortCharacters=s.tocharray（）；
Arrays.sort（sortCharacters）；
返回keySet.add（新字符串（sortCharacters））；
}
私有静态无效检查（设置键集、字符串[]名称、列表结果）{
for（字符串名称：名称）{
如果（添加（键集、名称））{
结果。添加（名称）；
}
}
}
公共静态void main（字符串[]args）{
字符串[]名称1={“艾米”、“何塞”、“杰里米”、“爱丽丝”、“帕特里克”}；
String[]name2={“alan”、“may”、“jeremy”、“helen”、“alexi”}；
字符串[]name3={“adel”、“aron”、“amy”、“james”、“yam”}；
Set keySet=newhashset（）；
列表结果=新建ArrayList（）；
检查（键集、名称1、结果）；
检查（键集、名称2、结果）；
检查（键集、名称3、结果）；
系统输出打印项次（结果）；
}
}

另一种选择，Java 8，解决方案。

---

1）创建一个

MapGreat:）这是一个很好的解决方案……谢谢……）我会尽快更新你的…还有一个疑问..例如，如果字符串数组的内容是A={“1234”，“56788”，“34221”}，那么这是怎么做到的呢？@Lal实际上，你应该先将char[]转换回字符串，然后再将其放入集合中，因为数组不重写等于和hashCode@Lal这取决于您希望如何处理这些空白。如果要忽略它们，请使用letter.add（新字符串（Arrays.sort（name2[j].tocharray（））.trim（））@最后的结果
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);
    }
}

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]

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

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);