Java 如何将字符串解析为数组

我有一个字符串（下面的例子），我想把它解析成一个数组

//只是一个愚蠢的例子
String s=“玛丽·马克{约翰·布朗}蜂蜜棒棒糖獾{天哪}{真蠢}”

我想将该字符串拆分为string[][]或ArrayList，因此如果我调用：

String[][]x=转换

x将包含如下内容：

String[]]x={{“玛丽”}、{“马克”}、{“约翰”、“布朗”}、{“蜂蜜”}、{“棒棒糖”}、{“獾”}、{“哦”、“我的”、“上帝”}、{“这样”、“愚蠢”}

我该怎么做

编辑：更改为2d数组
我猜包含{}方括号的子字符串应该被视为一个

我建议您使用正则表达式来解析给定的字符串。我本人对regex不是很友好，但下面的内容可能会对您有所帮助：

String s = "Mary Mark {John Brown} Honey lollipop Badger {Oh My God} {Such stupid}";
String p = "\\{[A-Za-z ]*\\}|\\w+";
Pattern pattern = Pattern.compile(p);
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
  System.out.println(matcher.group());
}

那么预期的产出是：

Mary
Mark
{John Brown}
Honey
lollipop
Badger
{Oh My God}
{Such stupid}

我猜包含{}方括号的子字符串应该被视为一个

我建议您使用正则表达式来解析给定的字符串。我本人对regex不是很友好，但下面的内容可能会对您有所帮助：

String s = "Mary Mark {John Brown} Honey lollipop Badger {Oh My God} {Such stupid}";
String p = "\\{[A-Za-z ]*\\}|\\w+";
Pattern pattern = Pattern.compile(p);
Matcher matcher = pattern.matcher(s);
while (matcher.find()) {
  System.out.println(matcher.group());
}

那么预期的产出是：

Mary
Mark
{John Brown}
Honey
lollipop
Badger
{Oh My God}
{Such stupid}

这里有一些东西很可能是无效的，但它是有效的，它基于大量的字符串操作和截断字符串的部分：

public class StringSplitter
{
    public static String[] transform(String string)
    {
        String[] splitString = string.split(" ");
        List<String> listOfStrings = new ArrayList<String>();
        int i = 0;
        while(i < splitString.length)
        {
            if(!splitString[i].startsWith("{"))
            {
                listOfStrings.add(splitString[i]);
                i++;
            }
            else
            {
                boolean concatEnd = false;
                StringBuffer sb = new StringBuffer();
                splitString[i] = splitString[i].substring(1);
                sb.append(splitString[i]);
                i++;
                while(!concatEnd) 
                {
                    if(!splitString[i].endsWith("}"))
                    {
                        sb.append(" " + splitString[i]);
                        i++;
                    } 
                    else
                    {
                        splitString[i] = splitString[i].substring(0, splitString[i].length()-1);
                        sb.append(" " + splitString[i]);
                        concatEnd = true;
                        i++;
                    }
                }
                listOfStrings.add(sb.toString());
            }
        }
        return listOfStrings.toArray(new String[listOfStrings.size()]);
    }

    public static void main(String[] args)
    {
        String s = "Mary Mark {John Brown} Honey lollipop Badger {Oh My God} {Such stupid}";
        for(String string : transform(s)) 
        {
            System.out.println(string);
        }
    }
}

这里有一些东西很可能是无效的，但它是有效的，它基于大量的字符串操作和截断字符串的部分：

public class StringSplitter
{
    public static String[] transform(String string)
    {
        String[] splitString = string.split(" ");
        List<String> listOfStrings = new ArrayList<String>();
        int i = 0;
        while(i < splitString.length)
        {
            if(!splitString[i].startsWith("{"))
            {
                listOfStrings.add(splitString[i]);
                i++;
            }
            else
            {
                boolean concatEnd = false;
                StringBuffer sb = new StringBuffer();
                splitString[i] = splitString[i].substring(1);
                sb.append(splitString[i]);
                i++;
                while(!concatEnd) 
                {
                    if(!splitString[i].endsWith("}"))
                    {
                        sb.append(" " + splitString[i]);
                        i++;
                    } 
                    else
                    {
                        splitString[i] = splitString[i].substring(0, splitString[i].length()-1);
                        sb.append(" " + splitString[i]);
                        concatEnd = true;
                        i++;
                    }
                }
                listOfStrings.add(sb.toString());
            }
        }
        return listOfStrings.toArray(new String[listOfStrings.size()]);
    }

    public static void main(String[] args)
    {
        String s = "Mary Mark {John Brown} Honey lollipop Badger {Oh My God} {Such stupid}";
        for(String string : transform(s)) 
        {
            System.out.println(string);
        }
    }
}

使用

构建正则表达式模式

然后打电话

pattern.matcher(input)

获取输入字符串的匹配器

然后使用

matcher.find()

对于每个匹配，添加

match.split("\\s+")

（提供一个或多个单词的数组）到数组或列表。
使用

构建正则表达式模式

然后打电话

pattern.matcher(input)

获取输入字符串的匹配器

然后使用

matcher.find()

对于每个匹配，添加

match.split("\\s+")

（它为您提供一个由一个或多个单词组成的数组）到数组或列表。
您可能正在寻找类似

String s = "Mary Mark {John Brown} Honey lollipop Badger {Oh My God} {Such stupid}";

Pattern p = Pattern.compile("(?<=\\{)[^{}]+(?=\\})|\\w+");
Matcher m = p.matcher(s);
List<String[]> tokens = new ArrayList<String[]>();
while (m.find()) {
    tokens.add(m.group().split("\\s+"));
}

String[][] result = tokens.toArray(new String[tokens.size()][]);

// lets see if it works as planned
System.out.println(Arrays.deepToString(result));

说明：

（？您可能正在寻找类似

String s = "Mary Mark {John Brown} Honey lollipop Badger {Oh My God} {Such stupid}";

Pattern p = Pattern.compile("(?<=\\{)[^{}]+(?=\\})|\\w+");
Matcher m = p.matcher(s);
List<String[]> tokens = new ArrayList<String[]>();
while (m.find()) {
    tokens.add(m.group().split("\\s+"));
}

String[][] result = tokens.toArray(new String[tokens.size()][]);

// lets see if it works as planned
System.out.println(Arrays.deepToString(result));

说明：

“（？是
{”这样的“，”愚蠢的“}
一个字符串吗？但是X只有一个维度你声称你想要一维字符串数组，但是你的输出包含
{”约翰“，”布朗“}
，它没有被
“
包围，所以它看起来不像一个字符串，而是字符串的内部数组。那么
{”约翰“，”布朗“}是什么呢
确切地说，字符串或字符串数组？您的示例在
{“这样”、“愚蠢”}
之后缺少最后一个
。没有。有两个字符串的子数组可能是字符串[][]x={{“玛丽”}、{“马克”}、{“约翰”、“布朗”}、{“蜂蜜”}、{“棒棒糖”}、{“獾”}、{“哦”、“天哪”}、{“这样”、“愚蠢”}；？是
{“这样”{愚蠢的“}
一个字符串？但是X只有一维你声称你想要一维字符串数组，但是你的输出包含
{“John”，“Brown”}
，它没有被
“
包围，所以它看起来不像一个字符串，而是字符串的内部数组。那么
{“John”，“Brown”}是什么呢
确切地说，是字符串还是字符串数组？而且你的例子在
{“这样”，“愚蠢的”}
之后缺少最后一个
。没有。有两个字符串的子数组可能你真正想要的是字符串[][]x={{“玛丽”}，{“马克”}，{“约翰”，“布朗”}，{“蜂蜜”}，{“棒棒糖”}，{“獾？sry，但不在。在
{}
中有单独的字符串。sry，但不在
{}
有单独的字符串。工作，但我的输入，
字符串x
应该与问题中的相同。完成并修复了新输入，尽管它是一个一维数组，正如最初所说的那样…请注意，如果字符串包含
{
或
}，代码将中断
除了作为组指示符之外，比如
“我喜欢{apples}”
将破坏它。工作，但我的输入，
字符串x
应该与所讨论的相同。完成并修复了新输入，尽管它是一个一维数组，正如最初所说的那样…请注意，如果字符串包含
{
或
}，代码将破坏
除了作为组指示符之外，比如
“我喜欢{apples}”
会打破它。正则表达式是一个硬核。这是一个很好的解决方案，尽管我不能完全理解它。关于如何学习正则表达式的复杂性，有什么建议吗？我很好奇，就这些。@Zhuinden正则表达式在学习它的语法和机制时并没有那么复杂。我知道的最好的地方是教程，但如果你想学习的话rn如何在Java中使用正则表达式您可以从开始。类也非常有用。正则表达式是一个硬核。这是一个很好的解决方案，尽管我不能完全理解它。关于如何学习正则表达式的复杂性，有什么建议吗？我很好奇，仅此而已。@Zhuinden正则表达式在学习其语法和机制时并没有那么复杂。我所知道的最好的地方是教程，但若你们想学习如何在Java中使用正则表达式，你们可以从开始。另外，这个课程非常有用。