Java 检查一个字符串是否包含另一个字符串的所有字符 stringone=“这是一个测试”； String two=“这是一个简单的测试”；

我想检查

two

是否包含

one

中的所有字符，并忽略它有额外字符的事实。

最快的事情可能是将它们分解为

哈希集，然后应用
containsAll

public static Set<Character> stringToCharacterSet(String s) {
    Set<Character> set = new HashSet<>();
    for (char c : s.toCharArray()) {
        set.add(c);
    }
    return set;
}

public static boolean containsAllChars
    (String container, String containee) {
    return stringToCharacterSet(container).containsAll
               (stringToCharacterSet(containee));
}

public static void main(String[] args) {
    String one = "This is a test";
    String two = "This is a simple test";
    System.out.println (containsAllChars(one, two));
}

公共静态集stringToCharacterSet（字符串s）{
Set=newhashset（）；
for（char c:s.toCharArray（））{
增加（c）；
}
返回集；
}
公共静态布尔字符
（字符串容器，字符串容器）{
返回stringToCharacterSet（容器）.containsAll
（stringToCharacterSet（containee））；
}
公共静态void main（字符串[]args）{
String one=“这是一个测试”；
String two=“这是一个简单的测试”；
System.out.println（包含所有字符（一，二））；
}
在第一个字符串中的字符集上使用简单循环：

String s1 = "This is a test";
String s2 = "This is a simple test";
Set<Character> chars = new HashSet<Character>();
for(int i = 0; i < s1.length(); i++) {
    chars.add(s1.charAt(i));
}


for (Iterator<Character> iterator = chars.iterator(); iterator.hasNext();) {
    Character character = iterator.next();
    if(!s2.contains(character.toString())) {
        // break and mark as not contained
        break;
    }
}

String s1=“这是一个测试”；
String s2=“这是一个简单的测试”；
Set chars=new HashSet（）；
对于（int i=0；i

如果要检查单词，则可以将空格周围的字符串拆分为单词列表：

String[] words1 = s1.split("\\s");
String[] words2 = s2.split("\\s");

List<String> wordList1 = Arrays.asList(words1);
List<String> wordList2 = Arrays.asList(words2);
System.out.println(wordList2.containsAll(wordList1));

String[]words1=s1.split（\\s”）；
字符串[]words2=s2.split（\\s”）；
List wordList1=Arrays.asList（words1）；
List wordList2=Arrays.asList（words2）；
System.out.println（wordList2.containsAll（wordList1））；
静态布尔字符串包含（字符串越长，字符串越短）{
int i=0；
for（char c:shorter.toCharArray（））{
i=更长。指数f（c，i）+1；
如果（我试试这个。我知道它很长，但很有效

public static void main(String[] args) 
{
    String String1,String2;
    int i, j, count1, count2;
    count1 = 0;
    count2 = 0;
    String1 = "This is a test";
    String2 = "This is a simple test";
    char[] list1 = new char[String2.length()];
    char[] list2 = new char[String2.length()];
    char[] list3 = new char[String2.length()];
    for (i = 0; i <= String1.length() - 1; i++)
    {
        list1[i] = String1.charAt(i);
        for (j = 0; j <= String2.length() - 1; j++)
        {
            list2[j] = String2.charAt(j);
            if (list1[i] == list2[j])
            {
                i++;
                count1++;
            }
        }
    }
    for (i = 0; i <= String1.length() - 1; i++)
    {
        list1[i] = String1.charAt(i);
        for (j = 0; j <= String1.length() - 1; j++)
        {
            list3[j] = String1.charAt(j);
            if (list1[i] == list3[j])
            {
                i++;
                count2++;
            }
        }
    }

    if (count1 >= count2)
        System.out.println(true);
    else
        System.out.println(false);
}

publicstaticvoidmain（字符串[]args）
{
字符串String1、String2；
int i，j，count1，count2；
count1=0；
count2=0；
String1=“这是一个测试”；
String2=“这是一个简单的测试”；
char[]list1=新字符[String2.length（）]；
char[]list2=新字符[String2.length（）]；
char[]list3=新字符[String2.length（）]；
对于（i=0；i
如果您不确定起始位置（以上假设为0），请尝试使用以下API

startsWith(String, offset)

当您说“包含所有字符”时，您的意思是：1）string1中的字符以相同的顺序包含在string2中，忽略了额外的字符2）字符串1中的每个字符也会出现在字符串2中，无论出现的次数是多少，或者3）字符串1中的每个字符在字符串2中至少包含了相同的次数？顺序是否重要？如果
two
是
“DOG”
，而
one
是
“GO”，结果应该是什么
？应该是
真的吗
，因为
G
和
O
都在
的“DOG”中
或
错误
因为字母互换？@pbabcdefp阅读本帮助页，了解为什么这个问题不好。我想这就是为什么有些人决定否决投票。@Tom这里隐藏了一个好问题。这个问题只需要更清楚。我认为最好询问更多细节，而不仅仅是道琼斯nvote，什么也不说。@Tom你怎么知道这是一个assignment？@gab06谢谢注意！修复了。如果我们检查字符串“ABCD”和“ACC”，它将不起作用。它将返回“true”，因为C将被比较一次。我同意@korujzadeWell，我有一些问题：如果你只是比较
String1.charAt（I）的结果，为什么要使用数组
和
String2.字符（j）
？如果一个特定字符与另一个字符匹配，为什么要增加外部循环的计数变量？最后：当您检查
String1
是否包含与
String1
相同的字符时，第二个循环块的用途是什么？在第一个循环中，我比较String1和String2。Count1是字符串1和字符串2之间的字符相同。如果以前使用过，我不知道该字符。在第二个循环中，我将String1与自身进行比较，以查看String1中有多少不同的字符。Count2是String2中不同字符的数量。您能帮我一个忙吗？将
String1
更改为
“这是一个测试x”
并查看您的代码是否仍然有效。
i++
的问题在于它跳过了
String1
的字符。是的，这里似乎有一个问题。请注意，结尾的代码可以替换为
System.out.println（count1>=count2）
。这不是OP-what所说的。
one
不需要是
two
的完整子字符串才能包含相同的字符。例如
test；estt
将无法使用您的方法。@Tom我知道原来的问题下面有一个对话。但是，在我回答时，没有这样的对话，因此我这样解释它。它工作正常，但由于O（n*m）的复杂性，速度很慢。
two.startsWith(one) 

startsWith(String, offset)