1

我找遍了高低，最后不得不问。

我有一个包含例如 ["123456","132457", "468591", ... ] 的数组。

我有一个值为“46891”的字符串。

如何搜索数组并找到包含字符串值中所有字符的对象？例如，带有“468591”的对象包含我的字符串值中的所有数字，即使它不是完全匹配，因为在“8”和“9”之间添加了“5”。

我最初的想法是将字符串拆分为自己的数字数组（即 ["4","6","8","9","1"] ），然后在数组中搜索包含数字的对象，从中创建一个新数组，并不断削减它，直到我只剩下一个。

4

8 回答 8

3

由于这可能是一项学习任务，我会给你一个想法而不是一个实现。

首先定义一个接受两个字符串的函数，true如果第一个字符串包含第二个字符串的所有字符，则返回，false否则返回。它应该看起来像这样：

boolean containsAllCharsInAnyOrder(String str, String chars) {
    ...
}

在函数内部设置一个循环，ch从chars字符串中一个一个地挑选字符，然后用于str.indexOf(ch)查看该字符是否存在于字符串中。如果索引为非负数，则继续；否则，返回假。

如果循环结束而没有返回，则您知道 中的所有字符chars都存在于 中src，因此您可以返回true。

有了这个函数，在你的主函数中设置另一个循环来遍历数组的元素，然后containsAllCharsInAnyOrder依次调用每个元素。

于 2013-11-07T19:12:34.770 回答
2

我认为您可以为此使用集合。

List<String> result = new ArrayList<>();
Set<String> chars = new HashSet<>(Arrays.asList(str.split(""));
for(String string : stringList) {
    Set<String> stringListChars = new HashSet<>(Arrays.asList(string.split(""));

    if(chars.containsAll(stringListChars)) {
       result.add(string);
    }
}

这里有一个警告；对于重复的字符，它不会像您期望的那样工作，并且您还没有指定要如何处理它（例如，1154比较154将被视为正匹配）。如果您确实要考虑重复字符并且要确保它们存在于另一个字符串中，则可以使用 aList而不是 a Set：

List<String> result = new ArrayList<>();
List<String> chars = Arrays.asList(str.split(""));
for(String string : stringList) {
    List<String> stringListChars = Arrays.asList(string.split("");

    if(chars.containsAll(stringListChars)) {
       result.add(string);
    }
}
于 2013-11-07T19:13:43.250 回答
1

您可以使用 ArrayList containsAll 方法和 asList 来执行此操作：

ArrayList<Character> lookingForChars = new ArrayList<Character>(Arrays.asList(lookingForString.toCharArray()));

for (String toSearchString : array) {

    ArrayList<Character> toSearchChars = new ArrayList<Character>(Arrays.asList(toSearchString.toCharArray));
    if (toSearchChars.containsAll(lookingForChars)) {
        System.out.println("Match Found!");
    }
}
于 2013-11-07T19:19:32.157 回答
1

您最初的想法是一个好的开始，所以您可以做的不是创建数组而是创建集合，然后使用Guava Sets#powerSet方法创建所有可能的子集，仅过滤具有“46891”.length 成员的子集，将每个集合转换为String和查看原始数组中的那些字符串:)

于 2013-11-07T19:14:18.333 回答
0

尝试这个

public static void main(String args[]) {
    String[] array = {"123456", "132457", "468591"};
    String search = "46891";
    for (String element : array) {
        boolean isPresent = true;
        for (int index = 0; index < search.length(); index++) {
            if(element.indexOf(search.charAt(index)) == -1){
                isPresent = false;
                break;
            }
        }

        if(isPresent)
            System.out.println("Element "+ element + " Contains Serach String");
        else
            System.out.println("Element "+ element + " Does not Contains Serach String");
    }
}
于 2013-11-07T19:28:49.360 回答
0

这对搜索字符串的 char[] 和要搜索的字符串进行排序。很确定（？）这是 O(n logn) vs O(n^2) 没有排序。

private static boolean contains(String searchMe, String searchOn){
    char[] sm = searchMe.toCharArray();
    Arrays.sort(sm);
    char[] so = searchOn.toCharArray();
    Arrays.sort(so);
    boolean found = false;
    for(int i = 0; i<so.length; i++){
        found = false; // necessary to reset 'found' on subsequent searches
        for(int j=0; j<sm.length; j++){ 
            if(sm[j] == so[i]){
                // Match! Break to the next char of the search string.
                found = true;
                break;
            }else if(sm[j] > so[i]){ // No need to continue because they are sorted.
                break;
            }
        }
        if(!found){
            // We can quit here because the arrays are sorted.
            // I know if I did not find a match of the current character
            // for so in sm, then no other characters will match because they are
            // sorted. 
            break;
        }
    }
    return found;
}

public static void main(String[] args0){
    String value = "12345";

    String[] testValues = { "34523452346", "1112", "1122009988776655443322",
                              "54321","7172839405","9495929193"};
    System.out.println("\n     Search where order does not matter.");
    for(String s : testValues){
        System.out.println("     Does " + s + " contain " + value + "? " + contains(s , value));
    }
}

和结果

 Search where order does not matter.
 Does 34523452346 contain 12345? false
 Does 1112 contain 12345? false
 Does 1122009988776655443322 contain 12345? true
 Does 54321 contain 12345? true
 Does 7172839405 contain 12345? true
 Does 9495929193 contain 12345? true
于 2013-11-07T19:47:28.530 回答
0

这比直截了当的解决方案更棘手。
这些是更好的算法，但这里一种易于实现和理解。

解决方法：

  1. 遍历给定字符串中的每个字符，并检查它是否在给定的数组中。
  2. 从包含给定字符的选定数组中收集每个字符串的列表。
  3. 检查是否没有其他要检查的字符。
    如果有，再次执行 A，但在收集的列表（结果列表）上。
    否则，返回所有可能的匹配项。
于 2013-11-07T19:08:34.587 回答
0

您可以String#chartAt()在嵌套的 for 循环中使用您的字符串与数组的每个元素进行比较。

此方法将帮助您检查一个字符是否包含在两个字符串中。

于 2013-11-07T19:08:33.793 回答