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

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 []数组。 使用某种for或foreach会将这些字符添加到基本数组的元素中。

如果您正在寻找它，请给我评论，否则请尝试添加一些更具体的问题。

Answer 2

我认为，最好通过将结果所得的char数组收集在List<char[]> （即使已预先知道分割的数量）。

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

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

Answer 3

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

例如，您可以尝试以下代码：

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进行 救援 混淆！

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;
    }
}

注意： javadoc中提到的与自动装箱/拆箱有关的可能的性能问题。
如果输入较大，则流是好的，尤其是如果生成的顺序无关紧要（流可以是并行的，trySplit的确定性较低，等等）。