Java 如何从字符串中获取整数列表

我的字符串包含由空格分隔的

整数

：

String number = "1 2 3 4 5 "

---

如何从该字符串中获取

整数的列表？
使用空格将其拆分，获取一个数组，然后将其转换为列表

String number = "1 2 3 4 5";
String[] s = number.split("\\s+");

然后使用
Integer.parseInt（s[index]）将其添加到列表中

List myList=new List（）；
对于（int index=0；index，您可以将其拆分，然后对其进行迭代，将其转换为数字，如：

    String[] strings = "1 2 3".split("\\ ");
    int[] ints = new int[strings.length];
    for (int i = 0; i < strings.length; i++) {
        ints[i] = Integer.parseInt(strings[i]);
    }
    System.out.println(Arrays.toString(ints));

String[]strings=“1 2 3”。拆分（\\”；
int[]ints=新的int[strings.length]；
for（int i=0；i
您可以使用一次读取一个整数的字符串

Scanner scanner = new Scanner(number);
List<Integer> list = new ArrayList<Integer>();
while (scanner.hasNextInt()) {
    list.add(scanner.nextInt());
}

Scanner Scanner=新扫描仪（编号）；
列表=新的ArrayList（）；
while（scanner.hasNextInt（））{
添加（scanner.nextInt（））；
}
ArrayList lst=new ArrayList（）；
for（字符串字段：number.split（“+”））
lst.add（Integer.parseInt（字段））；

使用Java 8+：

List<Integer> lst = 
    Arrays.stream(number.split(" +")).map(Integer::parseInt).collect(Collectors.toList());

List lst=
stream（number.split（“+”）.map（Integer:：parseInt）.collect（Collectors.toList（））；
首先，使用
split（）
方法将字符串生成字符串数组

其次，使用
getInteger（）
方法将字符串转换为整数。
首先使用正则表达式拆分字符串，然后遍历数组，将每个值转换为所需类型

String[] literalNumbers = [number.split(" ");][1]
int[] numbers = new int[literalNumbers.length];

for(i = 0; i < literalNumbers.length; i++) {
    numbers[i] = Integer.valueOf(literalNumbers[i]).intValue();
}

String[]literalNumbers=[number.split（“”；][1]
int[]number=新的int[literalNumber.length]；
对于（i=0；i
字符串编号=“1 2 3 4 5”；
列表l=新的ArrayList（）；
字符串[]ss=number.split（“”）；
对于（int i=0；i仅使用数组的简单解决方案：

// variables
String nums = "1 2 3 4 5";
// can split by whitespace to store into an array/lits (I used array for preference) - still string
String[] num_arr = nums.split(" ");
int[] nums_iArr = new int[num_arr.length];
// loop over num_arr, converting element at i to an int and add to int array

for (int i = 0; i < num_arr.length; i++) {
    int num_int = Integer.parseInt(num_arr[i])
    nums_iArr[i] = num_int
}

我需要一个更通用的方法从字符串中检索整数列表，所以我编写了自己的方法。
我不确定它是否比上面所有的都好，因为我还没有检查它们。
这是：

public static List<Integer> getAllIntegerNumbersAfterKeyFromString(
        String text, String key) throws Exception {
    text = text.substring(text.indexOf(key) + key.length());
    List<Integer> listOfIntegers = new ArrayList<Integer>();
    String intNumber = "";
    char[] characters = text.toCharArray();
    boolean foundAtLeastOneInteger = false;
    for (char ch : characters) {
        if (Character.isDigit(ch)) {
            intNumber += ch;
        } else {
            if (intNumber != "") {
                foundAtLeastOneInteger = true;
                listOfIntegers.add(Integer.parseInt(intNumber));
                intNumber = "";
            }
        }
    }
    if (!foundAtLeastOneInteger)
        throw new Exception(
                "No matching integer was found in the provided string!");
    return listOfIntegers;
}

或者您可以直接使用“.”
我想引入标记器类，用任何分隔符分割。输入字符串只扫描一次，我们有一个没有额外循环的列表

    String value = "1, 2, 3, 4, 5";
    List<Long> list=new ArrayList<Long>();
    StringTokenizer tokenizer = new StringTokenizer(value, ",");
    while(tokenizer.hasMoreElements()) {
        String val = tokenizer.nextToken().trim();
        if (!val.isEmpty()) list.add( Long.parseLong(val) );
    }

String value=“1,2,3,4,5”；
列表=新的ArrayList（）；
StringTokenizer tokenizer=新的StringTokenizer（值“，”）；
while（tokenizer.hasMoreElements（））{
String val=tokenizer.nextToken（）.trim（）；
if（！val.isEmpty（））list.add（Long.parseLong（val））；
}
在Java 8中，您可以使用流并以更紧凑的方式获得转换：

    String number = "1 2 3 4 5 ";
    List<Integer> x = Arrays.stream(number.split("\\s"))
            .map(Integer::parseInt)
            .collect(Collectors.toList());

stringnumber=“1 2 3 4 5”；
列表x=Arrays.stream（number.split（“\\s”））
.map（整数：：parseInt）
.collect（Collectors.toList（））；
使用Java8 Stream API map和
mapToInt
函数，您可以轻松地将其存档：

String number = "1 2 3 4 5";
List<Integer> x = Arrays.stream(number.split("\\s"))
        .map(Integer::parseInt)
        .collect(Collectors.toList());

stringnumber=“1 2 3 4 5”；
列表x=Arrays.stream（number.split（“\\s”））
.map（整数：：parseInt）
.collect（Collectors.toList（））；

或

String stringNum=“1 2 3 4 5 6 7 8 9 0”；
List poolList=Arrays.stream（stringNum.split（“\\s”））
.mapToInt（整数：：parseInt）
.boxed（）
.collect（Collectors.toList（））；
当我使用方法asList将数组转换为列表时，搜索是否得到字符串数组Integer@hudi可以使用“integer.parseInt（）将这些字符串转换为整数'方法我不喜欢这个方法，因为当这个字符串中没有数字时，就会出现异常，我正在寻找一些更快的方法来转换它，而不是一个接一个的。一个问题是，这个方法比其他答案中提到的方法快还是慢？所有这些示例都将以O（n）形式运行时间。所以答案是没有真正的性能差异。编辑：实际上，首先像（在另一篇文章中建议的）那样拆分字符串，然后将它们添加到集合中，将包含2xo（n）循环。这个解决方案是better@hudi-我认为我的代码在速度方面比其他答案要好，但这只能通过分析来确定。差异会很小。@TedHopp-字符串“2a11b20c”如何？我想得到结果列表[2，11，20]。谢谢：-）@ Zimmin—你可以调用<代码>扫描器。使用Eclipse（“\d”）；< /Cord>，它会告诉扫描器考虑除数字以外的任何东西作为定界符。然后，将你的示例字符串中的“a”、“b”和“c”与空白一样对待，并且仍然可以使用<代码> HasnExtTeNe（）/<代码>和<代码> nExtTin（）。
如我的回答所示。好的，简单的修改：第一个for循环：为nums\u iArr=Integer派生int num\u int。parseInt（num\u arr[i]）会删除一行代码。这足够了吗，或者你会建议更多的内容吗？第一个和第二个方法之间的区别是什么？
public static List<Integer> getAllIntegerNumbersAfterKeyFromString(
        String text, String key) throws Exception {
    text = text.substring(text.indexOf(key) + key.length());
    List<Integer> listOfIntegers = new ArrayList<Integer>();
    String intNumber = "";
    char[] characters = text.toCharArray();
    boolean foundAtLeastOneInteger = false;
    for (char ch : characters) {
        if (Character.isDigit(ch)) {
            intNumber += ch;
        } else {
            if (intNumber != "") {
                foundAtLeastOneInteger = true;
                listOfIntegers.add(Integer.parseInt(intNumber));
                intNumber = "";
            }
        }
    }
    if (!foundAtLeastOneInteger)
        throw new Exception(
                "No matching integer was found in the provided string!");
    return listOfIntegers;
}

    text = text.substring(text.indexOf(key) + key.length());

    String value = "1, 2, 3, 4, 5";
    List<Long> list=new ArrayList<Long>();
    StringTokenizer tokenizer = new StringTokenizer(value, ",");
    while(tokenizer.hasMoreElements()) {
        String val = tokenizer.nextToken().trim();
        if (!val.isEmpty()) list.add( Long.parseLong(val) );
    }

    String number = "1 2 3 4 5 ";
    List<Integer> x = Arrays.stream(number.split("\\s"))
            .map(Integer::parseInt)
            .collect(Collectors.toList());

String number = "1 2 3 4 5";
List<Integer> x = Arrays.stream(number.split("\\s"))
        .map(Integer::parseInt)
        .collect(Collectors.toList());

String stringNum = "1 2 3 4 5 6 7 8 9 0";

List<Integer> poolList = Arrays.stream(stringNum.split("\\s"))
        .mapToInt(Integer::parseInt)
        .boxed()
        .collect(Collectors.toList());