Question

我正在试图找出如何将表示单词的String转换为2个字母元素的数组。

例如，我有话：相信

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

我期望的阵列应该是：{{是}，{ 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 e 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 char数组。

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

您可以按照以下方式执行此操作：

确定要返回的字符串对的数量
创建一个返回的数组
迭代数组从输入字符串中选择一对新字符

这是一个可编辑的例子，用于打印出有向图。

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++) {
    if (i == new_word.length - 1) {
        System.out.print(new_word[i]);
        break;
    }
    System.out.print(new_word[i] + "" + new_word[++i] + " ");
}

Answer 5

你可以写这个

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

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

5 个答案: