Java 将字符数组转换为多个字符串

我需要将一个字符数组转换成几行特定大小的字符。例如，考虑此阵列：

char[] bases = new char[]{'a', 'c', 'c', 't', 'a', 'c', 'a', 't', 'a', 'c', 'c', 't', 'a', 'c', 'a', 't'};

预期输出的大小为5：

accta
catac
ctaca

我目前正在使用以下代码：

    int ls = 5; 
    String str = ""; 
    for (int i = 1; i < bases.length; i++) {
        str += bases[i - 1];
        if (i%ls == 0) {
            str += '\n';
        }
    }

intls=5；
字符串str=“”；
for（int i=1；i

---

在Java8中是否有一些内置函数来实现这一点？有没有更好的办法解决这个问题

可能会利用substring（）使其更简单。（首先将字符[]转换为字符串）

intls=5；
for（int i=ls；i

您几乎不应该在循环中使用字符串串联来构建字符串

使用

StringBuilder

：

StringBuilder sb = new StringBuilder(bases.length + (4 + bases.length) / 5);
for (int i = 0; i < bases.length; i += 5) {
  sb.append(bases, i, Math.min(5, bases.length - i));
  sb.append("\n");
}
String str = sb.toString();

StringBuilder sb=新的StringBuilder（bases.length+（4+bases.length）/5）；
对于（int i=0；i

您可以将

字符[]

转换为字符串，然后您可以将split与一些正则表达式一起使用，如：

String s = String.valueOf(bases);//result = acctacatacctacat
System.out.println(Arrays.toString(s.split("(?<=\\G.{5})")));

---

因为在这种情况下，您对所需的顺序有了非常清楚的了解，所以编写自定义代码来创建相应的

char[]

可能是最有效的：

   final int ls = 5;
   final char[] result = new char[bases.length + (bases.length + ls - 1) / ls]
   int nextIndex = 0;
   for (int i = 0; i < bases.length; i += ls) {
      final int size = bases.length - i >= ls ? ls : bases.length - i;
      System.arraycopy(bases, i, result, nextIndex, size);
      nextIndex += size;
      result[nextIndex++] = '\n'; 
   }
   final String resultAsString = new String(result);

final int ls=5；
最终字符[]结果=新字符[bases.length+（bases.length+ls-1）/ls]
int-nextIndex=0；
对于（int i=0；i=ls？ls:bases.length-i；
System.arraycopy（基数、i、结果、nextIndex、大小）；
nextIndex+=大小；
结果[nextIndex++]='\n'；
}
最终字符串resultAsString=新字符串（结果）；

这可能是使用java8 Stream power解决您的问题的另一种方法：（为了理解起见，我将一步一步地留下答案，但很多问题可以在以后进行浓缩和简化/收集）

int charsPerChunk=5；
字符[]myCharArray={'H'，'e'，'l'，'l'，'o'，'+'，'X'，'o'，'c'，'e'，'！'}；
//将字符数组转换为字符流
Stream myStreamOfCharacters=IntStream.range（0，myCharArray.length）.mapToObj（i->myCharArray[i]）；
//将其收集到字符列表中
List myListOfCharacters=mystreamfcharacters.collect（Collectors.toList（））；
int size=myListOfCharacters.size（）；
int fullChunks=（大小-1）/charsPerChunk；
//获取字符列表的流
流结果=IntStream
.范围（0，完整块+1）
.mapToObj（x->myListOfCharacters.subList（x*charsPerChunk，x==fullChunks？size:（x+1）*charsPerChunk））；
//打印出来
result.forEach（System.out:：println）；

HTML元素？这看起来更像是DNA。我不明白HTML与此有什么关系。

新字符串（基数，0，5）

，

新字符串（基数，5，10）

等等。对不起，忘了更新标题，现在应该更好了几个字符串？还是每5个字符插入一个换行符的单个字符串？请注意，这将在

bases[0]

之后插入第一个换行符，而不是在

bases[ls-1]

@AndyTurner-upps之后！您说得对，谢谢。我已更改代码以使用自定义解决方案，该解决方案可能比StringBuiler更高效。请小心：如果

base.length%ls！=0

。我相信它仍然可以工作，只是不会得到字符串末尾的剩余字符——这在如何处理这些字符的问题中没有指定——但他的示例只是删除了结尾字符。如果

ls==5

和

base.length设置了这些条件，for循环将不会进入第一次迭代，因为
5<4
将返回false。啊，好的。所以，你没有得到一个例外，你只是错过了最后一个子字符串：）我认为在这种情况下，使用流是过分的。同意，特别是这一部分。。。。myStreamOfCharacters@YCF_L啊，第三个参数是长度，不是结束索引。谢谢（令人困惑的是，
append（CharSequence，int，int）
中的第三个参数是结束索引，而不是长度）。
String[] spl = String.valueOf(bases).split("(?<=\\G.{5})");

[accta, catac, ctaca, t]

   final int ls = 5;
   final char[] result = new char[bases.length + (bases.length + ls - 1) / ls]
   int nextIndex = 0;
   for (int i = 0; i < bases.length; i += ls) {
      final int size = bases.length - i >= ls ? ls : bases.length - i;
      System.arraycopy(bases, i, result, nextIndex, size);
      nextIndex += size;
      result[nextIndex++] = '\n'; 
   }
   final String resultAsString = new String(result);

int charsPerChunk = 5;
char[] myCharArray = { 'H', 'e', 'l', 'l', 'o', '+', 'X', 'o', 'c', 'e', '!' };
// turn the char array into a Stream of Characters
Stream<Character> myStreamOfCharacters = IntStream.range(0, myCharArray.length).mapToObj(i -> myCharArray[i]);
// collect that into a list of characters
List<Character> myListOfCharacters = myStreamOfCharacters.collect(Collectors.toList());

int size = myListOfCharacters.size();
int fullChunks = (size - 1) / charsPerChunk;
// get a stream of list of characters
Stream<List<Character>> result = IntStream
          .range(0, fullChunks + 1)
          .mapToObj( x -> myListOfCharacters.subList(x * charsPerChunk, x == fullChunks ? size : (x + 1) * charsPerChunk));

// print it
result.forEach(System.out::println);