Java 如何根据条件获取字符串的特定部分？

我需要根据条件获取字符串的子字符串

String str = "ABC::abcdefgh||XYZ::xyz";

如果输入为“ABC”，请检查它是否包含在str中，如果出现，则应打印abcdefgh。 同样，如果输入为“XYZ”，则应打印XYZ

---

java中的字符串操作如何实现这一点？

使用contains方法查看是否有子字符串：

使用contains方法查看是否有子字符串：

使用contains方法查看是否有子字符串：

使用contains方法查看是否有子字符串：

如果我猜到了格式正确地使用

字符串

，然后您可以使用如下内容将其拆分为令牌：

String[] tokens = str.split("||");

for(String token : tokens)
{
    // Cycle through each token.


    String key = token.split("::")[0];
    String value = token.split("::")[1];

    if(key.equals(input))
    {
        // input being the user's typed in value.
        return value;
    }
}

但是让我们想一想。当

HashMap

是解决问题的更干净的方法时，为什么要将其保存在

字符串中？将
字符串
粘贴到配置文件中，然后加载，
有些代码可以执行类似的任务：

Map<String, String> inputMap = new HashMap<String, String>();

String[] tokens = str.split("||");

for(String token : tokens)
{
    // Cycle through each token.


    String key = token.split("::")[0];
    String value = token.split("::")[1];

    inputMap.put(key, value);
}

如果我猜对了您的
字符串的格式，那么您可以将其拆分为如下标记：

String[] tokens = str.split("||");

for(String token : tokens)
{
    // Cycle through each token.


    String key = token.split("::")[0];
    String value = token.split("::")[1];

    if(key.equals(input))
    {
        // input being the user's typed in value.
        return value;
    }
}

但是让我们想一想。当
HashMap
是解决问题的更干净的方法时，为什么要将其保存在
字符串中？将
字符串
粘贴到配置文件中，然后加载，
有些代码可以执行类似的任务：

Map<String, String> inputMap = new HashMap<String, String>();

String[] tokens = str.split("||");

for(String token : tokens)
{
    // Cycle through each token.


    String key = token.split("::")[0];
    String value = token.split("::")[1];

    inputMap.put(key, value);
}

如果我猜对了您的
字符串的格式，那么您可以将其拆分为如下标记：

String[] tokens = str.split("||");

for(String token : tokens)
{
    // Cycle through each token.


    String key = token.split("::")[0];
    String value = token.split("::")[1];

    if(key.equals(input))
    {
        // input being the user's typed in value.
        return value;
    }
}

但是让我们想一想。当
HashMap
是解决问题的更干净的方法时，为什么要将其保存在
字符串中？将
字符串
粘贴到配置文件中，然后加载，
有些代码可以执行类似的任务：

Map<String, String> inputMap = new HashMap<String, String>();

String[] tokens = str.split("||");

for(String token : tokens)
{
    // Cycle through each token.


    String key = token.split("::")[0];
    String value = token.split("::")[1];

    inputMap.put(key, value);
}

如果我猜对了您的
字符串的格式，那么您可以将其拆分为如下标记：

String[] tokens = str.split("||");

for(String token : tokens)
{
    // Cycle through each token.


    String key = token.split("::")[0];
    String value = token.split("::")[1];

    if(key.equals(input))
    {
        // input being the user's typed in value.
        return value;
    }
}

但是让我们想一想。当
HashMap
是解决问题的更干净的方法时，为什么要将其保存在
字符串中？将
字符串
粘贴到配置文件中，然后加载，
有些代码可以执行类似的任务：

Map<String, String> inputMap = new HashMap<String, String>();

String[] tokens = str.split("||");

for(String token : tokens)
{
    // Cycle through each token.


    String key = token.split("::")[0];
    String value = token.split("::")[1];

    inputMap.put(key, value);
}

您可以按如下方式进行操作：

    String[] parts = st.split("||");
    if (parts[0].startsWith("ABC")) {
        String[] values = parts[0].split("::");
        System.out.println(values[1]);
    } else {
        if (parts[1].startsWith("XYZ") {
            String[] values = parts[0].split("::");
            System.out.println(values[1]);
        }
    }

上述代码将首先检查ABC是否存在。如果是，它将打印结果，然后停止。如果不是，它将检查代码的第二部分，查看它是否以XYZ开头，然后打印结果。您可以更改它以满足您的需要。
您可以按如下方式执行：

    String[] parts = st.split("||");
    if (parts[0].startsWith("ABC")) {
        String[] values = parts[0].split("::");
        System.out.println(values[1]);
    } else {
        if (parts[1].startsWith("XYZ") {
            String[] values = parts[0].split("::");
            System.out.println(values[1]);
        }
    }

上述代码将首先检查ABC是否存在。如果是，它将打印结果，然后停止。如果不是，它将检查代码的第二部分，查看它是否以XYZ开头，然后打印结果。您可以更改它以满足您的需要。
您可以按如下方式执行：

    String[] parts = st.split("||");
    if (parts[0].startsWith("ABC")) {
        String[] values = parts[0].split("::");
        System.out.println(values[1]);
    } else {
        if (parts[1].startsWith("XYZ") {
            String[] values = parts[0].split("::");
            System.out.println(values[1]);
        }
    }

上述代码将首先检查ABC是否存在。如果是，它将打印结果，然后停止。如果不是，它将检查代码的第二部分，查看它是否以XYZ开头，然后打印结果。您可以更改它以满足您的需要。
您可以按如下方式执行：

    String[] parts = st.split("||");
    if (parts[0].startsWith("ABC")) {
        String[] values = parts[0].split("::");
        System.out.println(values[1]);
    } else {
        if (parts[1].startsWith("XYZ") {
            String[] values = parts[0].split("::");
            System.out.println(values[1]);
        }
    }

上述代码将首先检查ABC是否存在。如果是，它将打印结果，然后停止。如果不是，它将检查代码的第二部分，查看它是否以XYZ开头，然后打印结果。您可以更改它以满足您的需要。
的想法是，您应该使用分隔符
：“
和
”| |“
，也就是说，无论遇到哪一个，它都将被视为分隔符。因此，我认为实现这一点的最佳方法是使用正则表达式

String str = "ABC::abcdefgh||XYZ::xyz";
String[] parts = str.split("[::]|[/||]");

Map<String, String> map = new HashMap<String, String>();

for (int i = 0; i < parts.length - 2; i += 4) {
    if (!parts[i].equals("")) {
        map.put(parts[i], parts[i + 2]);
    }
}

String str=“ABC:：abcdefgh | | XYZ:：XYZ”；
String[]parts=str.split（“[：：]|[/| |]”；
Map Map=newhashmap（）；
对于（int i=0；i

简洁明了的代码已经准备好了。for循环看起来很奇怪，如果有人提出更好的正则表达式来进行拆分（以消除空字符串），它将变得更干净。我不是正则表达式专家，所以欢迎您提出任何建议。
想法是，您应该使用分隔符
“：”
和
“| |”
，也就是说，无论遇到哪一个，它都将被视为分隔符。因此，我认为实现这一点的最佳方法是使用正则表达式

String str = "ABC::abcdefgh||XYZ::xyz";
String[] parts = str.split("[::]|[/||]");

Map<String, String> map = new HashMap<String, String>();

for (int i = 0; i < parts.length - 2; i += 4) {
    if (!parts[i].equals("")) {
        map.put(parts[i], parts[i + 2]);
    }
}

String str=“ABC:：abcdefgh | | XYZ:：XYZ”；
String[]parts=str.split（“[：：]|[/| |]”；
Map Map=newhashmap（）；
对于（int i=0；i

简洁明了的代码已经准备好了。for循环看起来很奇怪，如果有人提出更好的正则表达式来进行拆分（以消除空字符串），它将变得更干净。我不是正则表达式专家，所以欢迎您提出任何建议。
想法是，您应该使用分隔符
“：”
和
“| |”
，也就是说，无论遇到哪一个，它都将被视为分隔符。因此，我认为实现这一点的最佳方法是使用正则表达式

String str = "ABC::abcdefgh||XYZ::xyz";
String[] parts = str.split("[::]|[/||]");

Map<String, String> map = new HashMap<String, String>();

for (int i = 0; i < parts.length - 2; i += 4) {
    if (!parts[i].equals("")) {
        map.put(parts[i], parts[i + 2]);
    }
}

String str=“ABC:：abcdefgh | | XYZ:：XYZ”；
String[]parts=str.split（“[：：]|[/| |]”；
Map Map=newhashmap（）；
对于（int i=0；i

简洁明了的代码已经准备好了。for循环看起来很奇怪，如果有人提出更好的正则表达式来进行拆分（以消除空字符串），它将变得更干净。我不是正则表达式专家，所以欢迎您提出任何建议。
想法是，您应该使用分隔符
“：”
和
“| |”
，也就是说，无论遇到哪一个，它都将被视为分隔符。因此，我认为实现这一点的最佳方法是使用正则表达式

String str = "ABC::abcdefgh||XYZ::xyz";
String[] parts = str.split("[::]|[/||]");

Map<String, String> map = new HashMap<String, String>();

for (int i = 0; i < parts.length - 2; i += 4) {
    if (!parts[i].equals("")) {
        map.put(parts[i], parts[i + 2]);
    }
}

String str=“ABC:：abcdefgh | | XYZ:：XYZ”；
字符串[]p