Question

我在Java中有一种情况，我希望将char []拆分为单独的char []，其中|为分隔符。示例：

char[] input = { 'a', 'r', '|','t', 'i', '|','s', 't' };

给定输入字符数组应分为3个不同的字符数组，如： -

result1 = {'a','r'}
result2 = {'t','i'}
result3 = {'s','t'}

注意：分隔符的出现是固定的，出于安全考虑，我不允许在这里使用字符串。

我怎样才能在java中做到这一点？

Answer 1

好吧，如果你不知道这个新的char []会有多少，我认为这很难做到。您的编译器需要知道您需要多少char []（我认为是命名和可访问的）。

我的第一个想法是将其连接到字符串，然后使用分隔符char将其拆分。但你写道，你不能/不想使用字符串。

这是相当的解决方法但你可以创建一个char []数组的数组。使用某种类型或foreach将这些字符添加到基本数组的元素中。

如果您正在寻找的话，请给我评论，如果没有尝试添加更具体的问题。

Answer 2

我认为最好通过在List<char[]>中收集生成的char数组来解决这个问题（即使事先知道了拆分的数量）。

可以通过单步执行输入数组并将字符与分隔符进行比较来执行拆分本身。如果找到分隔符，则将当前位置和最后找到的分隔符的位置之间的字符序列提取到新的char[]中，并将其添加到列表中。重复，直到到达输入数组的末尾。

如果预先知道分割数量，您可以使用预先分配给该数字的char[][]，但是您必须跟踪自己在哪里插入下一个提取的char[]。

Answer 3

您可能只需要跟踪分隔符的索引，然后就可以将相应的字符分配给新的结果字符数组。

例如，您可以尝试这样的代码：

import java.util.Arrays;
import java.util.ArrayList;;
public class Test {
public static void main(String[] args) {
    char[] input = { 'a','i', '|','s', 'r','d', '|','t', 'c','i', '|','s', 't' };

    int[] indexOfDelimiter=new int[input.length];
    indexOfDelimiter[0]=-1;
    int j=1; //track of delimiter index
    for (int i=0;i<input.length;i++){
        if (input[i]=='|'){
            indexOfDelimiter[j++]=i; // get the position of the delimiter
        }
    }
    indexOfDelimiter[j]=input.length;

    //now you can get the result char arrays like:
    ArrayList<char[]> results=new ArrayList<>();
    for(int i=0;i<j;i++){
        char[] chars=Arrays.copyOfRange(input,indexOfDelimiter[i]+1, indexOfDelimiter[i+1]);
        results.add(chars);
    }

    //for retrieving the char arrays, you can do like this:
    for(int i=0;i<results.size();i++){
        System.out.println(results.get(i));
    }
    // the output is :
    // ai
    // srd
    // tci
    // st
   }
}

Answer 4

Java 8到 ~~rescue~~ 混淆！

import java.util.ArrayList;
import java.util.List;
import java.util.Spliterator;
import java.util.function.Consumer;

public class Test {
    public static void main(String[] args) {
        char[] input = { 'a', 'r', '|','t', 'i', '|','s', 't' };

        List<Spliterator<Character>> spliterators= new DelimiterSpliterator(input, '|').tryAllSplits();

        List<char[]> splits= spliterators.stream().collect(ArrayList<char[]>::new, (result, element) -> result.add(((DelimiterSpliterator) element).toCharArray()), ArrayList<char[]>::addAll);

        for (char[] split : splits) {
            System.out.println(split);
        }
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Spliterator;

public class DelimiterSpliterator implements Spliterator<Character> {
    private final char[] array;
    private final char delimiter;
    private int start;
    private final int end;

    public DelimiterSpliterator(char[] array, char delimiter) {
        this(array, delimiter, 0, array.length);
    }

    private DelimiterSpliterator(char[] array, char delimiter, int start, int end) {
        this.array = array;
        this.delimiter = delimiter;
        this.start = start;
        this.end = end;
    }

    public char[] toCharArray() {
        return Arrays.copyOfRange(array, start, end);
    }

    public List<Spliterator<Character>> tryAllSplits() {
        // Collects all splits.
        List<Spliterator<Character>> result = new ArrayList<>();            
        Spliterator<Character> s = trySplit();
        while (s != null) {
            result.add(s);
            s = trySplit();
        }
        result.add(this);
        return result;
    }

    @Override
    public int characteristics() {
        return IMMUTABLE | ORDERED | SIZED | SUBSIZED;
    }

    @Override
    public long estimateSize() {
        return end-start;
    }

    @Override
    public boolean tryAdvance(Consumer<? super Character> action) {
        if (start < end) {
            action.accept(array[start++]);
            return true;
        } else {
            return false;
        }
    }

    @Override
    public Spliterator<Character> trySplit() {
        // Returns a new Spliterator that cannot be split further, from left to right.
        for (int i = start; i < end - 1; i++) {
            if (array[i] == delimiter) {
                final int origStart = start;
                start = i + 1;
                return new DelimiterSpliterator(array, delimiter, origStart, i);
            }
        }
        return null;
    }
}

注意：与in the javadoc提及的自动装箱/拆箱相关的可能性能问题如果输入很大，特别是如果结果顺序无关紧要（流可以是并行的，trySplit可以更不确定等等），则流很好。

使用java中的分隔符将char []拆分为单独的char []

4 个答案: