Question

我需要从字符串数组中找到最大的字符串，还要确保输出的字符串应仅包括在单独的字符串中定义的字符。

例如：如果字符串数组包含{"ABCAD","ABC","ABCFHG","AB"} 另一个字符串S具有字符"ABCD"。

然后返回的最大字符串应为ABCAD，因为它仅包含S中定义的字符。

public String findstring(String a, String[] arr)
{
    String s="";
    for(i=0; i<arr.length; i++)
    {
        //int m=0;

        if(arr[i].length() > s.length())
        {
            s = arr[i];

        }
    }

            for(j=0; j<s.length(); j++)                                                      
            {
                int m=0;
                for(k=0; k<a.length(); k++)
                {
                    if(m>0)
                    {
                        break;  
                    }
                    if((s.charAt(j)==a.charAt(k)))
                    {
                        m++;
                    }
                    else
                    {
                        continue;
                    }
                }
                if(m==0)
                {
                    List<String> list = new ArrayList<String>(Arrays.asList(arr));
                    list.remove(s);
                    arr = list.toArray(new String[0]);
                    findstring("ABCD", arr);
                }

            }
        return s;
}
}

我没有收到任何错误，得到的最大字符串为ABCFABCD，而F需要排除，最大字符串应为ABCAA。它跳过所有检查，不知道为什么吗？

Answer 1

您进行递归调用，但忽略返回的值。

尝试在递归findstring上添加返回值。

   arr = list.toArray(new String[0]);
   return findstring("ABCD", arr);

Answer 2

您可以使用Regex更好地做到这一点：

public String findstring(final String a, final String[] arr) {
    String s = "";
    // Created pattern of the characters available in the String
    final Pattern p = Pattern.compile("^[" + a + "]*$");

    for (int i = 0; i < arr.length; i++) {

      if (p.matcher(arr[i]).matches()) {

        if ("".equals(s)) {
          s = arr[i];
        } else if (arr[i].length() > s.length()) {
          s = arr[i];
        }
      }

    }

    return s;
  }

Answer 3

如果您想拥有功能强大，可读性强，代码少的新功能和更好的Java功能，可以查看以下代码段：

public static void main(String args[]) {
    final String allowedChars = "ABCD";
    final char[] chars = allowedChars.toCharArray();
    String result  = Stream.of("ABCAD","ABC","ABCFHG","AB")
            .filter(s ->{
                for(char c: chars){
                    if(!s.contains(c+""))
                        return false;
                }
                return true;
            })
            .max(Comparator.comparingInt(String::length))
            .orElse("No Such Value Found");
    System.out.println("Longes Valid String : " + result);
}

说明：

该代码仅从有效Stream和String中提取arrays到filter中的Stream（不包含允许字符的字符串将从中删除。（进一步处理）和其余Comparator的长度（<{>使用String）进行比较，最后，将返回最长的有效{{1}}

在某些情况下，数组/流中的所有字符串都将无效，在这种情况下，代码将返回消息“找不到这样的值”作为字符串，但是您可以引发异常，也可以返回自己的自定义逻辑的一些值，或者您可以返回null等。

我有意保留了String消息，并为您提供了学习Java Stream中存在的其他方法的提示，以便您可以进行更多的探索。

保持编码...并体验新JAVA的强大功能。：）

如何在字符串数组中搜索最大的字符串

3 个答案: