Java 拆分以空格分隔的列表

这是我面临的一项常见任务：将一个空格分隔的列表拆分为一个head元素和一个包含tail元素的数组。例如，给定以下字符串：

the quick brown fox

我们希望：

"the"
["quick","brown","fox"]

。。在两个不同的变量中。第一个变量应该是字符串，第二个变量应该是数组。我正在寻找一种优雅的方法（最好是Java）。

使用while循环逐步遍历每个元素。在循环内部，您可以获取第一个元素并将其余元素放入数组中

编辑：哦，我想StringTokenizer是一个“遗留”类（尽管它仍然有效）

---

推荐的方法是现在使用。这将为您提供一个包含元素的字符串[]。从那里获取第一个元素并从其余元素中创建一个数组应该很简单。

对于某些值：

str= "the quick brown fox"
  pqr = str.split(" ")

String input = "The quick brown fox";
String[] elements = input.split(" ");
String first = elements[0];
String[] trailing = Arrays.copyOfRange(elements,1,elements.length);

---

我想不出用更少的代码来完成它的方法…

好吧，你可以用它获得你想要的大部分

String[] pieces = "how now brown cow".split("\\s") 

大概吧。您的结果将是一个字符串数组

如果您真的非常希望第一项与其他项分开，那么您可以执行以下操作：

String head = pieces[0];
String[] tail = new String[pieces.length - 1];
System.arraycopy(pieces, 1, tail, 0, tail.length);

…完成。

您可以利用将限制作为第二个参数

String text = "the quick brown fox";
String[] parts = text.split(" ", 2);
String headPart = parts[0];
String[] bodyParts = parts[1].split(" ");

System.out.println(headPart); // the
System.out.println(Arrays.toString(bodyParts)); // [quick, brown, fox]

---

最优雅的方法可能是使用

String.split

获取

String[]

，然后使用

数组.asList

将其转换为

列表。如果你真的需要一个不包含标题的单独列表，只需使用
list.subList

    String text = "the quick brown fox";
    List<String> tokens = Arrays.asList(text.split("\\s+"));

    String head = tokens.get(0);
    List<String> body = tokens.subList(1, tokens.size());

    System.out.println(head); // "the"
    System.out.println(body); // "[quick, brown, fox]"

    System.out.println(body.contains("fox")); // "true"
    System.out.println(body.contains("chicken")); // "false"

String text=“快速棕色狐狸”；
列表标记=Arrays.asList（text.split（\\s+））；
字符串头=tokens.get（0）；
List body=tokens.subList（1，tokens.size（））；
系统输出打印项数（头）；//“这个”
系统输出打印项次（正文）；//“[快，布朗，狐狸]”
System.out.println（body.contains（“fox”）；//“对”
System.out.println（body.contains（“chicken”）；//“假”

使用
列表
可以利用Java集合框架提供的丰富功能

另见

有效Java第二版，第25项：首选列表而非数组

包装操场；
导入junit.framework.TestCase；
公共类TokenizerTest扩展了TestCase{
public void testTokenize（）引发异常{
String s=“敏捷的棕色狐狸”；
神话t=新的神话；
资产质量（“t.head”）；
String[]rest={“quick”、“brown”、“fox”}；
AsserteQualarray（rest，t.rest）；
}
私有静态void assertEqualArrays（字符串[]a，字符串[]b）{
资产质量（a.长度，b.长度）；
for（int i=0；i

在Haskell中会容易得多：）
嗯。问题是，除了调用nextToken之外，您不可能真正知道有多少令牌，直到没有更多令牌为止。所以你不能真的分配一个数组并把它放进去？这是正确的，因为数组是不可变的，所以你必须使用System.arraycopy。但这是一个没有实际意义的观点，因为最好像其他人所描述的那样使用split（）。
Arrays.copyOfRange（）
-哇，谢谢，我每天都从其他人的答案中学到一些新东西！如果用户打算从字符串[]数组中“弹出”一项，那么列表会更好，对吗？（我在想，在他们实现上述解决方案后，他们可能会意识到这一点）。尽管这比我的
Arrays.copyOfRange（）
解决方案略多一些代码，但我认为你的解决方案可能会赢得优雅，除非询问者需要极快的速度，或者处于非常低的内存环境中（在这种情况下，他/她究竟为什么要使用Java？）
package playground;

import junit.framework.TestCase;

public class TokenizerTest extends TestCase {

    public void testTokenize() throws Exception {
        String s = "the quick brown fox";
        MyThing t = new MyThing(s);
        assertEquals("the", t.head);
        String[] rest = {"quick", "brown", "fox"};
        assertEqualArrays(rest, t.rest);
    }

    private static void assertEqualArrays(String[] a, String[] b) {
        assertEquals(a.length, b.length);
        for (int i = 0; i < a.length; i++) 
            assertEquals(a[i], b[i]);
    }

    private static class MyThing {
        private final String head;
        private final String[] rest;

        public MyThing(String s) {
            String[] array = s.split(" ");
            head = array[0];
            rest = new String[array.length - 1];
            System.arraycopy(array, 1, rest, 0, array.length - 1);
        }

    }
}

public static void main(String[] args) {
        String s = "the quick brown fox";
        int indexOf = s.indexOf(' ');
        String head = s.substring(0, indexOf);
        String[] tail = s.substring(indexOf + 1).split(" +");
        System.out.println(head + " : " + Arrays.asList(tail));
    }