如何为java字符串创建特定的if

例如，我有一个数据：

A

B

C

最后数据A与B

我想为everyline创建一个附加注释，如

A |这是一个

B |这是B

C |这是C

最后数据A和B |这是A和B

现在我试着手动操作，如果这样的话

 if(line.contains( "A")){
                updatedLines.add(line + "|" + "this is A");
            }

但是当我想使用“A with B”时，我不能使用contains方法，因为它会自动使用“this is A”注释，那么我应该如何创建这样的特定注释呢

---

注意：我使用的实际数据有5000k行++，因此如果有人知道，而不是像这样手动操作，那么它真的很有帮助

如果只有一行以“lastdata”开头，您可以简单地将此条件放在第一位

 If(line.startsWith("lastdata")
     updatedLines.add(line + "|" + line.replace("lastdata", "this is"));
 else
     updatedLines.add(line + "|" + "this is "+line);

你可以这样做

if (line.contains("A") && !line.contains("B")) {
    updatedLines.add(line + "|" + "this is A");
}

if (line.contains("B") && !line.contains("A")) {
    updatedLines.add(line + "|" + "this is B");
}

if (line.contains("A") && line.contains("B")) {
    updatedLines.add(line + "|" + "this is A with B");
}

再举一个例子

String result = line + " | this is " + Stream.of("A", "B", "C")
        .filter(line::contains)
        .collect(Collectors.joining(" with "));
updatedLines.add(result);

---

我认为解决这个问题的一种方法是使用一个你可以做的事情，比如：

StringJoiner sj = new StringJoiner(" and ");

if (line.contains("A")) {
    sj.add("A");
}
if (line.contains("B")) {
    sj.add("B");
}
...
if (sj.length() > 0) {
    updatedLines.add(line + " | this is " + sj.toString());
}

---

您可以将字符串转换为字符数组，然后对字符串中的每个字符执行所需操作

public static void main(String[] args) {
    String testStr = "ABC";
    StringBuilder sb = new StringBuilder();
    char[] arrStr = testStr.toCharArray();
    for (int i = 0; i < arrStr.length; i++) {
        if(i == 0){
            sb.append(testStr + "| This is " + arrStr[i]);
        } else {
            sb.append(" And " + arrStr[i]);
        }
    }
    System.out.println(sb.toString());
}

publicstaticvoidmain（字符串[]args）{
字符串testStr=“ABC”；
StringBuilder sb=新的StringBuilder（）；
char[]arrStr=testStr.toCharArray（）；
for（int i=0；i

我有点过时，但我尝试过的方法奏效了：

public class TestPattern
{
  public static void main(String[] args)
  {
    try
    {
      Scanner scanner;
      String  line;
      scanner = new Scanner(System.in);
      for (;;)
      {
        System.out.print("Enter line: ");
        System.out.flush();
        line = scanner.nextLine();
        if (line.isEmpty())
          break;
        check(line);
      }
      scanner.close();
    }
    catch (Exception exception_ipar)
    {
      exception_ipar.printStackTrace();
    }

  } // main

  public static void check(String line)
  {
    // ----------------------------------
    // Determine patterns present in line
    // ----------------------------------
    List<String>     found;
    Iterator<String> it;
    String           pattern;
    found = new ArrayList<String>();
    it = patterns.iterator();
    while (it.hasNext())
    {
      pattern = it.next();
      if (line.contains(pattern))
        found.add(pattern);
    }

    // -------------------
    // Maybe nothing found
    // -------------------
    if (found.isEmpty())
    {
      System.out.println("No pattern found");
      return;
    }

    // --------------
    // Compose result
    // --------------
    StringBuilder result;
    int           counter;
    result = new StringBuilder();
    result.append(line + " | ");
    for (counter = 0; counter < found.size(); counter++)
    {
      if (counter == 0)
        result.append("this is ");
      else if (counter == (found.size() - 1))
        result.append(" and ");
      else
        result.append(", ");
      result.append(found.get(counter));
    }

    // -----------
    // Show result
    // -----------
    System.out.println(result);

  } // check

  private static Set<String> patterns;

  static
  {
    patterns = new TreeSet<String>();
    patterns.add("A");
    patterns.add("B");
    patterns.add("C");
  }

} // class TestPattern

公共类测试模式
{
公共静态void main（字符串[]args）
{
尝试
{
扫描仪；
弦线；
扫描仪=新扫描仪（System.in）；
对于（；；）
{
系统输出打印（“输入行：”）；
System.out.flush（）；
line=scanner.nextLine（）；
if（line.isEmpty（））
打破
检查（线路）；
}
scanner.close（）；
}
捕获（异常\u ipar）
{
异常_ipar.printStackTrace（）；
}
}//主要
公共静态无效检查（字符串行）
{
// ----------------------------------
//确定行中存在的模式
// ----------------------------------
找到的列表；
迭代器；
字符串模式；
found=新的ArrayList（）；
it=patterns.iterator（）；
while（it.hasNext（））
{
pattern=it.next（）；
if（行包含（模式））
找到。添加（模式）；
}
// -------------------
//也许什么也没找到
// -------------------
if（find.isEmpty（））
{
System.out.println（“未找到模式”）；
回来
}
// --------------
//合成结果
// --------------
结果；
整数计数器；
结果=新的StringBuilder（）；
结果。追加（第+“|”行）；
用于（计数器=0；计数器

使用助手类，您可以在其中注册要检查的内容，并让它为您生成注释

public class CommentAppender
{
    private ArrayList<String> tokens;
    private boolean orderMatters = false;

    public CommentAppender()
    {
        this(false);
    }

    public CommentAppender(bool orderMatters)
    {
        tokens = new ArrayList<>();
        this.orderMatters = orderMatters;
    }

    public void registerToken(String tok)
    {
        tokens.add(tok);
    }

    public String generateCommentForInput(String input)
    {
        ArrayList<String> matchedTokens = new ArrayList<>();

        int offset = 0;

        for(String tok : tokens)
        {
            int io = input.indexOf(tok, offset);
            if(io != -1)
            {
                matchedTokens.add(tok);
                offset = orderMatters? io + 1 : 0;
            }
        }

        // Build the comment
        StringBuilder sb = new StringBuilder();
        if(matchedTokens.size() > 0)
        {
            sb.append("this is ");
            sb.append(matchedTokens.get(0));
            for(int i = 1; i < matchedTokens.size(); i++)
            {   
                sb.append(" and ");
                sb.append(matchedTokens.get(1));
            }
        }

        return sb.toString();
    }
}

CommentAppender ca = new CommentAppender();
ca.registerToken("A");
ca.registerToken("B");
ca.registerToken("C");

公共类注释器
{
私有ArrayList令牌；
private boolean orderMatters=false；
公共评论员（）
{
这个（假）；
}
公共评论员（bool orderMatters）
{
令牌=新的ArrayList（）；
this.orderMatters=orderMatters；
}
公共无效寄存器TOKEN（字符串tok）
{
代币。添加（tok）；
}
公共字符串generateCommentForInput（字符串输入）
{
ArrayList matchedTokens=新的ArrayList（）；
整数偏移=0；
for（字符串tok：令牌）
{
int io=input.indexOf（tok，偏移量）；
如果（io！=-1）
{
匹配托克斯。添加（托克）；
offset=orderMatters？io+1:0；
}
}
//建立评论
StringBuilder sb=新的StringBuilder（）；
如果（matchedTokens.size（）>0）
{
某人附加（“这是”）；
sb.append（matchedTokens.get（0））；
对于（int i=1；i

如果（line.equals（“A”））呢？

如果（line.contains（“A”）&&line.contains（“B”）

你只有A、B和C，最终组合成X和Y，还是有其他表达式？我有另一个表达式，这只是一个示例，我不能使用equals方法，因为有时我需要为不同的数据添加相同的注释，例如：A，1_A_1，R-A将得到“this is A”注释如果我理解得很好，您想检查表达式是否包含A、B和/或C？有可能三个人都在场吗？如果是这样的话，期望的输出是什么？这实际上是可行的，但还有其他选择吗？ofc，您有很多选择添加了另一个示例如何做到这一点