删除字符串数组中具有相同字符的字符串
Remove Strings with same characters in a String Array
我现在遇到了一个问题。在我的一个程序中，我需要从数组中删除具有相同字符的字符串。例如。假设，
我有 3 个数组，例如，
String[] name1 = {"amy", "jose", "jeremy", "alice", "patrick"};
String[] name2 = {"alan", "may", "jeremy", "helen", "alexi"};
String[] name3 = {"adel", "aron", "amy", "james", "yam"};
可以看到，name1数组中有一个Stringamy。此外，我在接下来的两个数组中有 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);
但是，此代码的问题在于，它只是删除了同一字符串的多次出现。还有其他选择吗？非常感谢任何帮助。
您可以对字符串 (str.toCharArray ()) 的字符数组进行排序，并从排序后的数组创建一个新字符串，以获得字符串的 "canonical" 表示形式。
然后您可以将这些字符串添加到一个 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[]> 不起作用.
TreeSet allows us to give a comparator. See whether this helps. For keeping the count use a 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);
}
}
}
符合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);
}
}
替代方案，Java8，解决方案。
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);
我现在遇到了一个问题。在我的一个程序中，我需要从数组中删除具有相同字符的字符串。例如。假设，
我有 3 个数组，例如，
String[] name1 = {"amy", "jose", "jeremy", "alice", "patrick"};
String[] name2 = {"alan", "may", "jeremy", "helen", "alexi"};
String[] name3 = {"adel", "aron", "amy", "james", "yam"};
可以看到，name1数组中有一个Stringamy。此外，我在接下来的两个数组中有 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);
但是，此代码的问题在于，它只是删除了同一字符串的多次出现。还有其他选择吗？非常感谢任何帮助。
您可以对字符串 (str.toCharArray ()) 的字符数组进行排序，并从排序后的数组创建一个新字符串，以获得字符串的 "canonical" 表示形式。
然后您可以将这些字符串添加到一个 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[]> 不起作用.
TreeSet allows us to give a comparator. See whether this helps. For keeping the count use a 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);
}
}
}
符合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);
}
}
替代方案，Java8，解决方案。
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);