Java 检测不匹配字符串

我试图找出如何将逗号分隔的字符串作为输入，并检测其中是否有与以下集合不匹配的字符串

{FF，SF，FB，SB，暂停}

因此，当我解析字符串（可以是上述任意组合）时，如果它检测到“FfdsG”，例如，它应该抛出一个错误。我假设我可以使用某种正则表达式来完成这个或一系列ifs

编辑

我的实现糟糕吗？我将字符串转换为所有较低值，然后进行比较。无论我输入什么（FB或FB、FF或其他），它似乎都在标记一切都不好

    `public static String check(String modes) {
     String s = modes;
     String lower = s.toLowerCase();

       HashSet<String> legalVals = new HashSet<String>();

        legalVals.add("ff");
        legalVals.add("sf");
        legalVals.add("fb");
        legalVals.add("sb");
        legalVals.add("pause");

        String valToCheck = lower;

        if (legalVals.contains(valToCheck)) { //False
            String str = modes;
        } else {
            return "Bad value: " + modes;
        }

       return modes;
      }

公共静态字符串检查（字符串模式）{ 字符串s=模式； String lower=s.toLowerCase（）； HashSet legalVals=新HashSet（）； 法律文件。添加（“ff”）； 法律文件。添加（“sf”）； 法律文件。添加（“fb”）； 法律条文增补（“sb”）； 添加（“暂停”）； 字符串valToCheck=较低； if（legalVals.contains（valToCheck））{//False 字符串str=模式； }否则{ 返回“坏值：”+模式； } 返回模式； } 需要说明的是，输入字符串可以是我列出的5个有效值的任意组合。可能是其中一个，也可能是全部5个。我只是想检测是否在任何时候检测到一个值，该值不在列出的5中。我希望这是有道理的

---

最后，我选择了下面的方法

      String[] words = {"ff", "sf", "fb", "sb", "pause"};
       List<String> validList = Arrays.asList(words); 
       String checkInput = lower;

       for (String value : checkInput.split( "," ))
       {    
        if( !validList.contains( value ) )
        {
            throw new Exception("Invalid mode specified: " + modes);
        }
       }

String[]words={“ff”、“sf”、“fb”、“sb”、“pause”}；
List validList=Arrays.asList（单词）；
字符串检查输入=较低；
for（字符串值：checkInput.split（“，”））
{    
如果（！validList.contains（value））
{
抛出新异常（“指定的模式无效：“+模式”）；
}
}

例如，您可以将合法值存储在中，并使用该方法检查特定值是否在列表中：

HashSet<String> legalVals = new HashSet<String>();

legalVals.add("FF");
legalVals.add("SF");
//etc

String valToCheck = "FfdsG";

if (legalVals.contains(valToCheck)) { //False
  print "Value found: " + valToCheck;
} else {
  print "Bad value: " + valToCheck;
}

HashSet legalVals=new HashSet（）；
法律文件。添加（“FF”）；
法律文件。添加（“SF”）；
//等
字符串valToCheck=“FfdsG”；
if（legalVals.contains（valToCheck））{//False
打印“找到值：”+valToCheck；
}否则{
打印“坏值：”+valToCheck；
}

例如，您可以将合法值存储在中，并使用该方法检查特定值是否在列表中：

HashSet<String> legalVals = new HashSet<String>();

legalVals.add("FF");
legalVals.add("SF");
//etc

String valToCheck = "FfdsG";

if (legalVals.contains(valToCheck)) { //False
  print "Value found: " + valToCheck;
} else {
  print "Bad value: " + valToCheck;
}

HashSet legalVals=new HashSet（）；
法律文件。添加（“FF”）；
法律文件。添加（“SF”）；
//等
字符串valToCheck=“FfdsG”；
if（legalVals.contains（valToCheck））{//False
打印“找到值：”+valToCheck；
}否则{
打印“坏值：”+valToCheck；
}

假设您已经拆分了逗号分隔的字符串输入，并且inputString是该拆分数组中的一个元素

---

假设您已经拆分了逗号分隔的字符串输入，并且inputString是拆分数组中的一个元素。

不确定您想要什么。对于下面的正则表达式，如果所有字符串都是好字符串，matches（）将返回true；如果有一个或多个坏字符串，matches（）将返回false。这个正则表达式允许在字符串的开头或结尾使用任意数量的空格。此外，还会忽略多个逗号。例如，“FF，SF，，，，，，，，Pause”是一个匹配项。从正则表达式中删除“\s*”以禁止空白

(\s*(FF|FB|SF|SB|Pause)\s*,*)+

---

查看此

不确定您想要什么。对于下面的正则表达式，如果所有字符串都是好字符串，matches（）将返回true；如果有一个或多个坏字符串，matches（）将返回false。这个正则表达式允许在字符串的开头或结尾使用任意数量的空格。此外，还会忽略多个逗号。例如，“FF，SF，，，，，，，，Pause”是一个匹配项。从正则表达式中删除“\s*”以禁止空白

(\s*(FF|FB|SF|SB|Pause)\s*,*)+

---

检查一下这个

我不是regex wiz，但是如果您单独查看每个值，它可以让您更好地控制如何报告错误，并让您决定拒绝整个输入或删除无效条目

public class InputCleaner
{
    private final static List<String> allowedEntries = Arrays.asList( new String[] { "FF", "SF", "FB", "SB", "Pause" } );

    public static void main( String[] args ) throws Exception
    {
        String input = "FF,SF,FB,SB,FF,Pause";
        String input2 = "FF,SF,FB,SB,FfdsG,FF,Pause";

        validateInput( input );
        validateInput( input2 );
    }

    private static void validateInput( String input ) throws Exception
    {
        for (String value : input.split( "," ))
        {    
            if( !allowedEntries.contains( value ) )
            {
                throw new Exception( "Found a bad input value! " + value );
            }
        }

        System.out.println( "Input string clean:" + input );
    }
}

公共类InputCleaner
{
private final static List allowedEntries=Arrays.asList（新字符串[]{“FF”、“SF”、“FB”、“SB”、“Pause”}）；
公共静态void main（字符串[]args）引发异常
{
字符串输入=“FF、SF、FB、SB、FF、暂停”；
字符串input2=“FF，SF，FB，SB，FfdsG，FF，Pause”；
验证输入（输入）；
验证输入（输入2）；
}
私有静态void validateInput（字符串输入）引发异常
{
for（字符串值：input.split（“，”））
{    
如果（！allowedEntries.contains（值））
{
抛出新异常（“发现错误的输入值！”+值）；
}
}
System.out.println（“输入字符串清除：+Input”）；
}
}

我不是regex-wiz，但如果您单独查看每个值，它可以让您更好地控制如何报告错误，并让您决定拒绝整个输入或删除无效条目

public class InputCleaner
{
    private final static List<String> allowedEntries = Arrays.asList( new String[] { "FF", "SF", "FB", "SB", "Pause" } );

    public static void main( String[] args ) throws Exception
    {
        String input = "FF,SF,FB,SB,FF,Pause";
        String input2 = "FF,SF,FB,SB,FfdsG,FF,Pause";

        validateInput( input );
        validateInput( input2 );
    }

    private static void validateInput( String input ) throws Exception
    {
        for (String value : input.split( "," ))
        {    
            if( !allowedEntries.contains( value ) )
            {
                throw new Exception( "Found a bad input value! " + value );
            }
        }

        System.out.println( "Input string clean:" + input );
    }
}

公共类InputCleaner
{
private final static List allowedEntries=Arrays.asList（新字符串[]{“FF”、“SF”、“FB”、“SB”、“Pause”}）；
公共静态void main（字符串[]args）引发异常
{
字符串输入=“FF、SF、FB、SB、FF、暂停”；
字符串input2=“FF，SF，FB，SB，FfdsG，FF，Pause”；
验证输入（输入）；
验证输入（输入2）；
}
私有静态void validateInput（字符串输入）引发异常
{
for（字符串值：input.split（“，”））
{    
如果（！allowedEntries.contains（值））
{
抛出新异常（“发现错误的输入值！”+值）；
}
}
System.out.println（“输入字符串清除：+Input”）；
}
}

（？
（？是的，Java有很好的正则表达式支持，在正则表达式中使用“OR”操作符可以很容易地完成您想做的事情。类似这样的内容应该可以说明这一点：

package exp;

import java.io.Console;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class RegexTestHarness {

  public static void main(String[] args){

    Pattern pattern = Pattern.compile("FF|SF|FB|SB|Pause");

    Matcher matcher =  pattern.matcher( "FfdsG" );

    if (matcher.matches()) {
        System.out.printf("I found the text \"%s\" starting at " +
           "index %d and ending at index %d.%n",
            matcher.group(), matcher.start(), matcher.end());
    }
    else {
        System.out.printf("No match found.%n");
    }
    
    
    matcher = 
        pattern.matcher( "FF" );
    
        if (matcher.matches()) {
            System.out.printf("I found the text \"%s\" starting at " +
               "index %d and ending at index %d.%n",
                matcher.group(), matcher.start(), matcher.end());
        }
        else {
            System.out.printf("No match found.%n");
        }       
    

    matcher = 
        pattern.matcher( "Pause" );
    
        if (matcher.matches()) {
            System.out.printf("I found the text \"%s\" starting at " +
               "index %d and ending at index %d.%n",
                matcher.group(), matcher.start(), matcher.end());
        }
        else {
            System.out.printf("No match found.%n");
        }           
    
}

}

运行此操作时，您将获得以下输出：

没有找到匹配项

我发现文本“FF”从索引0开始，在索引2结束

我找到了