我愿意这样做，

public static String[] getTwoCharStrings(String in) {
    if (in == null) {
        return null;
    }
    List<String> al = new ArrayList<String>();
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < in.length(); i++) {
        if (sb.length() >= 2) {
            al.add(sb.toString());
            sb.setLength(0);
        }
        sb.append(in.charAt(i));
    }
    if (sb.length() > 0) {
        al.add(sb.toString());
    }
    String [] r = new String[al.size()];
    return al.toArray(r);
}

public static void main(String[] args) {
    String word="believe";
    String[] r = getTwoCharStrings(word);
    System.out.println(Arrays.toString(r));
}

输出为

[be, li, ev, e]

您可以按以下步骤进行：
确定要返回的字符串对的数目
创建要返回的数组
遍历数组，从输入字符串中选取一对新字符
下面是一个可编译的示例，可以打印出有向图。

import java.util.Arrays;

public class Digraph {
    public static void main(final String[] args) {
        final String word = "believe";
        final String[] substrings = digraphs(word);
        System.out.println(Arrays.toString(substrings));
    }

    private static String[] digraphs(final String word) {
        final int returnLength = word.length() / 2 + word.length() % 2;
        final String[] returns = new String[returnLength];

        for (int arrayIndex = 0; arrayIndex < returns.length; arrayIndex++) {
            final int start = arrayIndex * 2;
            int end = start + 2;
            if (end > word.length()) {
                end = word.length();
            }
            final String digraph = word.substring(start, end);
            returns[arrayIndex] = digraph;
        }
        return returns;
    }
}

唯一要注意的是确保处理长度不均匀的字符串。作为 word.length/2+word.length%2 你可以用 Math.ceil(word.length/2d) .

你可以写这个

for(int i = 0; i < new_word.length; ++i) {
    char letter = new_word[i];
    System.out.print(letter);
    if ((i % 2) == 1) {
        System.out.print(" ");
    }
}

这样做的一种方法是按如下方式计数：

for( int i = 0; i < new_word.length; i++) {
    if (i == new_word.length - 1) {
        System.out.print(new_word[i]);
        break;
    }
    System.out.print(new_word[i] + "" + new_word[++i] + " ");
}

我期望的数组应该是：{{be}，{li}，{ev}，{e}
如果您想要一个这样的数组，可以使用2dchar数组。

public static void main(String[] args) throws Exception{
    String word="believe";  
    char[][] arr = getSplittedString(word);
    System.out.println("The array is: "+Arrays.deepToString(arr));
    for(char[] c : arr){
        System.out.print(c);
        System.out.print(' ');
    }
}

public static char[][] getSplittedString(String word){
    char[] new_word = word.toCharArray();
    char[][] word_splitted = new char[word.length()/2 + word.length()%2][];
    int j = 0;
    for(int i = 0; i < word.length()/2; i++){
        word_splitted[i] = new char[] {new_word[j++],new_word[j++]};
    }
    if(word.length()%2 != 0){
        word_splitted[word_splitted.length-1] = new char[]{new_word[j]};
    }
    return word_splitted;
}

输出：

The array is: [[b, e], [l, i], [e, v], [e]]
be li ev e