将单词转换为2个字母的数组

Question

我正在尝试弄清楚如何将表示单词的字符串转换为包含 2 个字母元素的数组。

例如，我有一句话：相信

然后，我将其转换为 2 个字母的数组。

我期望的数组应该是：{{be},{li},{ev},{e }}或活着

我尝试了 char 数组 (toCharArray())。我试过的代码：

String word="believe";
char[] new_word = word.toCharArray();
for(char letter:new_word){
   System.out.print(letter+" ");
}

但是，它的结果并不是我所期望的。

结果：b e l i e v e

我应该怎么做才能解决这个问题？

Answer 1

我会这样做，

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]

Answer 2

我期望的数组应该是：{{be},{li},{ev},{e}}

如果你想要一个看起来像这样的数组，你可以使用 2D 字符数组。

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 

Answer 3

你可以这样做：

1. 确定要返回的字符串对数
2. 创建要返回的数组
3. 遍历数组，从输入字符串中挑选一对新字符

这是一个打印出二合字母的可编译示例。

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)。

Answer 4

你可以这样写

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(" ");
    }
}

Answer 5

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

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] + " ");
}