Java 将字符串分解为int数组

如果字符串如下所示，将字符串数组分解为int数组的最短、最有效的方法是什么：

4 1 4 2 3
5 1 4 2 -1 6

---

我现在使用的方法是使用stringsplit方法并将字符串数组迭代为int。。有比这更好的方法吗？

没关系-我只需调用

split（“”

），然后对结果元素使用

Integer.parseInt（）

如果INT之间可能有多个空格，则需要类似于

split（\\s+”）

的内容才能正常工作

如果你就是这么做的，我想没有更好的办法了

---

编辑：也许我应该更好地限定这个术语——我的意思是，从所有实际目的来看，除非您真的遇到了性能关键问题，否则我会坚持使用这个方法，因为它是干净的，并且很容易理解发生了什么

那很好-我只需调用

split（“”

），然后对结果元素使用

Integer.parseInt（）

如果INT之间可能有多个空格，则需要类似于

split（\\s+”）

的内容才能正常工作

如果你就是这么做的，我想没有更好的办法了

编辑：也许我应该更好地限定这个术语——我的意思是，从所有实际目的来看，除非您真的遇到了性能关键问题，否则我会坚持使用这个方法，因为它是干净的，并且很容易理解发生了什么

创建新的

String

对象时，使用

split（）

除非性能非常关键，否则我会坚持这种方法。
使用
split（）
创建新的
String
对象时会消耗更多的空间[和时间]，但它比任何其他方法都要优雅[和简单]

除非性能非常关键，否则我会坚持这种方法。
算法比拆分方法快3倍！：）

只是为了好玩，我做了一个比分裂法快得多的算法。
也许你不应该使用任何东西，正如我所说的，拆分是更干净的，而且更干净远比速度重要。唐纳德·克努斯（Donald Knuth）对过早优化的引用也是所有罪恶的根源

输出

1189ms // My algorithm first loop
3305ms // Split algorithm runtime first loop
1173ms // My algorithm second loop
3305ms // Split algorithm second loop

代码

import java.util.ArrayList;

class FarmorsOptimized {

@SuppressWarnings({ "rawtypes", "unchecked" })
private static ArrayList getFarmors(String s) {
    ArrayList intArr = new ArrayList();
    int stopvalue = s.length() ;
    for (int i = 0; i < stopvalue;) {
        int negativ = 0;
        if (s.charAt(i) == '-') {
            negativ = 1;
        }
        intArr.add(Integer.parseInt(s.substring(i, i+1+negativ)));
        i+=2+negativ;
    }
    return intArr;
}

@SuppressWarnings({ "rawtypes", "unchecked" })
private static ArrayList getSplits(String s) {
    ArrayList intArr = new ArrayList();
    for(String str : s.split(" ")){
        intArr.add(Integer.parseInt(str));
    }
    return intArr;
}

public static void main(String[] args) {
    String s = "1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7";
    int times = 1000000;
    //Just to init everything
    for (int i = 0; i < times; i++) {
        getFarmors(s);
        getSplits(s);
    }
    long starttime = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        getFarmors(s);
    }
    System.out.println(System.currentTimeMillis() - starttime);
    starttime = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        getSplits(s);
    }
    System.out.println(System.currentTimeMillis() - starttime);
    starttime = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        getFarmors(s);
    }
    System.out.println(System.currentTimeMillis() - starttime);
    starttime = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        getSplits(s);
    }
    System.out.println(System.currentTimeMillis() - starttime);
}

import java.util.ArrayList；
类FarmorsOptimized{
@SuppressWarnings（{“rawtypes”，“unchecked”}）
私有静态ArrayList getFarmors（字符串s）{
ArrayList intArr=新的ArrayList（）；
int stopvalue=s.length（）；
对于（int i=0；i
算法3倍比拆分方法快！：）

只是为了好玩，我做了一个比分裂法快得多的算法。
也许你不应该像我说的那样使用拆分，拆分比速度更干净，更干净比速度更重要。唐纳德·克努斯（Donald Knuth）引用的过早优化是所有罪恶的根源

输出

1189ms // My algorithm first loop
3305ms // Split algorithm runtime first loop
1173ms // My algorithm second loop
3305ms // Split algorithm second loop

代码

import java.util.ArrayList;

class FarmorsOptimized {

@SuppressWarnings({ "rawtypes", "unchecked" })
private static ArrayList getFarmors(String s) {
    ArrayList intArr = new ArrayList();
    int stopvalue = s.length() ;
    for (int i = 0; i < stopvalue;) {
        int negativ = 0;
        if (s.charAt(i) == '-') {
            negativ = 1;
        }
        intArr.add(Integer.parseInt(s.substring(i, i+1+negativ)));
        i+=2+negativ;
    }
    return intArr;
}

@SuppressWarnings({ "rawtypes", "unchecked" })
private static ArrayList getSplits(String s) {
    ArrayList intArr = new ArrayList();
    for(String str : s.split(" ")){
        intArr.add(Integer.parseInt(str));
    }
    return intArr;
}

public static void main(String[] args) {
    String s = "1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7 1 2 4 -6 7";
    int times = 1000000;
    //Just to init everything
    for (int i = 0; i < times; i++) {
        getFarmors(s);
        getSplits(s);
    }
    long starttime = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        getFarmors(s);
    }
    System.out.println(System.currentTimeMillis() - starttime);
    starttime = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        getSplits(s);
    }
    System.out.println(System.currentTimeMillis() - starttime);
    starttime = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        getFarmors(s);
    }
    System.out.println(System.currentTimeMillis() - starttime);
    starttime = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        getSplits(s);
    }
    System.out.println(System.currentTimeMillis() - starttime);
}

import java.util.ArrayList；
类FarmorsOptimized{
@SuppressWarnings（{“rawtypes”，“unchecked”}）
私有静态ArrayList getFarmors（字符串s）{
ArrayList intArr=新的ArrayList（）；
int stopvalue=s.length（）；
对于（int i=0；i