使用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的確定性較低，等等）。