Question

我搜索得很高，最后不得不问。

我有一个数组，例如[[123456“，”132457“，”468591“，...]。

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

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

我最初的想法是将字符串拆分为自己的数字数组（即[“4”，“6”，“8”，“9”，“1”]），然后在数组中搜索对象包含数字，从中创建一个新数组，并保持缩小，直到我剩下一个。

Answer 1

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

首先定义一个带两个字符串的函数，如果第一个按任意顺序包含第二个字符，则返回true，否则返回false。它应该是这样的：

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

在函数内部设置一个循环，逐个从ch字符串中选择字符chars，然后使用str.indexOf(ch)查看该字符是否存在于字符串中。如果指数为非负数，则继续;否则，返回false。

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

掌握了这个功能，在主函数中设置另一个循环来遍历数组的元素，并依次调用每个元素上的containsAllCharsInAnyOrder。

Answer 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将被视为正匹配）。如果想要考虑重复的字符，并且您希望确保它们存在于其他字符串中，则可以使用List代替Set：< / p>

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

Answer 3

你最初的想法是一个良好的开端，所以你可以做的是创建一个数组而不是设置，然后使用Guava Sets#powerSet方法创建所有可能的子集，只过滤那些有“46891”.length mebers，convert每个都设置为String并查看原始数组中的字符串：）

Answer 4

您可以使用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!");
    }
}

Answer 5

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

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

Answer 6

这比直接解决方案更棘手这是更好的算法，但这里很容易实现和理解。

解决方法：

浏览您给定字符串的每个字符，并检查它是否在给予arrray。
收集所选字符串中每个字符串的列表包含给定char的数组。
检查是否有其他字符要检查。
如果有，请再次执行A但在收集的列表（结果列表）上否则，请返回所有可能的比赛。

Answer 7

试试这个

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

Answer 8

这会对搜索字符串的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

搜索数组以获取包含所有字符（按任何顺序）和返回值的值

8 个答案: