Question

我想写一个这样的函数：

- Input: "1" -> return : "1"
- Input: "12" -> return : ["1","2"]

如果我使用split（）函数：String.valueOf("12").split("") -> ["","1","2"] 但是，我只想得到结果：["1","2"].

最好的方法是什么？

事实上，我可以这样做：

private List<String> decomposeQuantity(final int quantity) {
    LinkedList<String> list = new LinkedList<String>();
    int parsedQuantity = quantity;
    while (parsedQuantity > 0) {
        list.push(String.valueOf(parsedQuantity % 10));
        parsedQuantity = parsedQuantity / 10;
    }
    return list;
}

但是，我想使用split（）来获得情感代码

Answer 1

String input = "123";
String regex = "\\d";
Matcher m = Pattern.compile(regex).matcher(input);

String[] output = new String[input.length()];
int index = 0;

while (m.find())
    output[index++] = m.group();

for (String s : output)
    System.out.println(s);

Answer 2

只有拆分才能做到这一点。您要么必须删除第一个元素（从索引1复制到另一个数组），要么只删除s.toCharArray()但它将返回一个字符数组，而不是字符串。

Answer 3

要描述两位数之间的位置，您可以使用look-around机制，例如：

String[] digits= "12".split("(?<=\\d)(?=\\d)"); //->[1, 2]
//(?<=\\d) points place before digit
//(?=\\d) points place after digit
//(?<=\\d)(?=\\d) place that is before one digit and after another

虽然在split中你只能使用后视(?<=\\d)，但它仍然可以使用

String[] digits= "123".split("(?<=\\d)"); //->[1, 2, 3]

Answer 4

public String[] split(String input) {
    if (input.length() == 0) {
        return new String[] { "" };
    }

    String[] output = new String[input.length()];
    int index = 0;
    for (char c : input.toCharArray()) {
        output[index++] = Character.toString(c);
    }

    return output;
}


split("") -> [""]
split("1") - > ["1"]
split("12") - > ["1", "2"]
split("123") - > ["1", "2", "3"]

Answer 5

解决方案取决于您是否需要可读性和可维护性与性能。在测试了所有发布的答案并尝试基本实现之后，最佳性能是基本实现。这是更多代码，但可能对您有用：

public interface IEvaluable {
    void evaluate();
}

public class BasicImplementation implements IEvaluable {

    private String string;

    public BasicImplementation(String string) {
        this.string = string;
    }

    //using the power of shadowing
    public String[] getDigitsAsArray(String string) {
        String[] data = new String[string.length()];
        int j = 0;
        for(int i = 0; i < string.length(); i++) {
            if (Character.isDigit(string.charAt(i))) {
                data[j++] = Character.toString(string.charAt(i));
            }
        }
        String[] realData = new String[j];
        for(int i = 0;i < j ;i++) {
            realData[i] = data[i];
        }
        return realData;
    }

    @Override
    public void evaluate() {
        getDigitsByArray(string);
    }
}

为了测试答案的表现，我实施了一种测试结果的方法：

public final class PerformanceEvaluator {

    private IEvaluable evaluable;

    public PerformanceEvaluator(IEvaluable evaluable) {
        this.evaluable = evaluable;
    }

    public void evaluate() {
        long initialTime;
        long endTime;
        initialTime = System.nanoTime();
        try {
            evaluable.evaluate();
        } catch (Exception e) {
            e.printStackTrace(System.out);
        }
        endTime = System.nanoTime();
        System.out.println("Ellapsed time: " + (endTime - initialTime));
    }
}

主要课程

public class Main {

    public static void main(String[] args) {
        Main oMain = new Main();
        oMain.evaluate("12");
        oMain.evaluate("123456789098_)(56765432145");
        oMain.evaluate("wbfiwyfwbn74g0t3h7t394mhg983hhon504n0er0n");
        oMain.evaluate(
            "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
        oMain.evaluate("no digits");
    }

    public void evaluate(String string) {
        PerformanceEvaluator performanceEvaluator =
            new PerformanceEvaluator(new BasicImplementation(string));
        performanceEvaluator.evaluate();
    }
}

只需创建其他类，使用提供的解决方案实现IEvaluable接口并自行测试。测试是在英特尔®酷睿™i7-2675QM CPU @ 2.20GHz×8上的Java 1.7.0_09 HotSpot 64位服务器VM上完成的，在Ubuntu 12.04 LT上具有8 GB RAM。

在我看来，基于这些测试用例：

如果您想使用正则表达式并选择性能，请选择@BlueBullet answer。
如果您想坚持String#split，请选择@Pshemo answer。

在这种情况下如何使用String.split？

5 个答案: