Java中的多行字符串连接

我在找人帮忙。在Java中连接多行字符串并在之后打印的最简单方法是什么

例如：我有两个字符串：

String turtle1 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r";
String turtle2 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r";

我想在Java Eclipse控制台中得到这个结果：

         _            _
     .-./*)       .-./*)
   _/___\/      _/___\/
     U U          U U

我已经尝试了一些算法，将字符串分成不同的部分，然后重新连接。但没有成功。 我知道有StringBuffer类和StringBuilder类，但经过一些研究，我没有找到符合我需要的东西

---

提前感谢您的帮助。

请参阅我下面的示例，应该是自我解释的

public class Turtle {

    private static final String returnpattern = "\r\n";

    public static void main(String[] args) {

        // the data to run through
        String turtle1 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r\n";
        String turtle2 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r\n";

        // split the data into individual parts
        String[] one = turtle1.split(returnpattern);
        String[] two = turtle2.split(returnpattern);

        // find out the longest String in data set one
        int longestString = 0;
        for (String s : one) {
            if (longestString < s.length()) {
                longestString = s.length();
            }
        }

        // loop through parts and build new string
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < one.length; i++) {
            String stringTwo = String.format("%1$" + longestString + "s", two[i]); // left pad the dataset two to match
                                                                                   // length
            b.append(one[i]).append(stringTwo).append(returnpattern);
        }

        // output
        System.out.println(b);
    }
}

公共类海龟{
私有静态最终字符串returnpattern=“\r\n”；
公共静态void main（字符串[]args）{
//要运行的数据
字符串turtle1=“\r\n.-./*）\r\n\r\n\U\U\\/\r\n U\r\n”；
字符串turtle2=“\r\n.-./*）\r\n\r\n\U\U\\/\r\n U\r\n”；
//将数据拆分为各个部分
String[]one=turtle1.拆分（返回模式）；
String[]two=turtle2.分割（返回模式）；
//找出数据集1中最长的字符串
int longestString=0；
for（字符串s:1）{
if（最长字符串

不是很漂亮，但很管用：

String turtle1 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r\n";
String turtle2 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r\n";
String[] turtle1Lines = turtle1.split("\r\n");
String[] turtle2Lines = turtle2.split("\r\n");
StringBuilder sb = new StringBuilder();
int turtle1Width = 0;
for (int i = 0; i < 4; i++) {
    if (turtle1Lines[i].length() > turtle1Width) {
        turtle1Width = turtle1Lines[i].length();
    }
}
for (int i = 0; i < 4; i++) {
    sb.append(turtle1Lines[i]);
    for (int j = turtle1Width - turtle1Lines[i].length(); j > 0; j--) {
        sb.append(' ');
    }
    sb.append(turtle2Lines[i]);
    sb.append("\r\n");
}
String turtles = sb.toString();

String-turtle1=“\r\n.-./*）\r\n\r\n\r\n\r\n”；
字符串turtle2=“\r\n.-./*）\r\n\r\n\U\U\\/\r\n U\r\n”；
字符串[]turtle1Lines=turtle1.split（“\r\n”）；
字符串[]turtle2Lines=turtle2.split（“\r\n”）；
StringBuilder sb=新的StringBuilder（）；
int turtle1Width=0；
对于（int i=0；i<4；i++）{
if（turtle1Lines[i].length（）>turtle1Width）{
turtle1Width=turtle1Lines[i]。长度（）；
}
}
对于（int i=0；i<4；i++）{
某人附加（套头衫）；
对于（int j=turtle1Width-turtle1Lines[i].length（）；j>0；j--）{
某人附加（“”）；
}
某人附加（套头衫线[i]）；
sb.追加（“\r\n”）；
}
String turtles=sb.toString（）；

我也在这里；）

公共类测试{
静态字符串turtle1=“\r\n.-./*）\r\n\r\n\U\\/\r\n U\r”。替换（“\r”，”）；
静态字符串turtle2=“\r\n.-./*）\r\n \\\/\r\n U\r”。替换（“\r”，”）；
公共静态int countRows（字符串）{
返回string.length（）-string.replace（“\n”，”）.length（）+1；
}
公共静态int getMaxLength（字符串）{
int maxLength=0；
int currentLength=0；
char[]data=string.toCharArray（）；
for（字符c：数据）{
如果（c！='\n'）{
如果（++currentLength>maxLength）{
maxLength=当前长度；
}
}否则{
currentLength=0；
}
}
返回最大长度；
}
公共静态字符串[]ToStringAray（字符串）{
int length=getMaxLength（字符串）；
int rows=countRows（字符串）；
字符串[]结果=新字符串[行]；
int last=0；
对于（int i=0；i

为了好玩，这里有另一个使用流的解决方案，为两只以上的海龟并排展示而准备：

public static void main(String[] args) {
    String turtle1 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r";
    String turtle2 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r";

    // split lines into fragments
    List<List<String>> fragments = Stream.of(turtle1, turtle2)
            .map(x -> Stream.of(x.split("\\r\\n?|\\n")).collect(Collectors.toList()))
            .collect(Collectors.toList());

    // make all lists same length by adding empty lines as needed
    int lines = fragments.stream().mapToInt(List::size).max().orElse(0);
    fragments.forEach(x -> x.addAll(Collections.nCopies(lines - x.size(), "")));

    // pad all fragments to maximum width (per list)
    List<List<String>> padded = fragments.stream().map(x -> {
        int width = x.stream().mapToInt(String::length).max().orElse(0);
        return x.stream().map(y -> String.format("%-" + width + "s", y)).collect(Collectors.toList());
    }).collect(Collectors.toList());

    // join corresponding fragments to result lines, and join result lines
    String result = IntStream.range(0, lines)
            .mapToObj(i -> padded.stream().map(x -> x.get(i)).collect(Collectors.joining()))
            .collect(Collectors.joining(System.lineSeparator()));

    System.out.println(result);
}

publicstaticvoidmain（字符串[]args）{
字符串turtle1=“\r\n.-./*）\r\n\U/\U\U\\/\r\n U\r”；
字符串turtle2=“\r\n.-./*）\r\n\U/\U\U\\/\r\n U\r”；
//把线分割成碎片
列表片段=流（turtle1，turtle2）
.map（x->Stream.of（x.split（\\r\\n？|\\n”））.collect（Collectors.toList（））
.collect（Collectors.toList（））；
//根据需要添加空行，使所有列表长度相同
int lines=fragments.stream（）.mapToInt（List:：size）.max（）.orElse（0）；
fragments.forEach（x->x.addAll（Collections.nCopies（lines-x.size（），“”））；
//将所有碎片填充到最大宽度（每个列表）
List padded=fragments.stream（）.map（x->{
int width=x.stream（）.mapToInt（字符串：：长度）.max（）.orElse（0）；
返回x.stream（）；
}).collect（Collectors.toList（））；
//将相应的片段连接到结果行，并连接结果行
字符串结果=IntStream.range（0行）
.mapToObj（i->padded.stream（）.map（x->x.get（i
public static void main(String[] args) {
    String turtle1 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r";
    String turtle2 = "         _\r\n     .-./*)\r\n   _/___\\/\r\n     U U\r";

    // split lines into fragments
    List<List<String>> fragments = Stream.of(turtle1, turtle2)
            .map(x -> Stream.of(x.split("\\r\\n?|\\n")).collect(Collectors.toList()))
            .collect(Collectors.toList());

    // make all lists same length by adding empty lines as needed
    int lines = fragments.stream().mapToInt(List::size).max().orElse(0);
    fragments.forEach(x -> x.addAll(Collections.nCopies(lines - x.size(), "")));

    // pad all fragments to maximum width (per list)
    List<List<String>> padded = fragments.stream().map(x -> {
        int width = x.stream().mapToInt(String::length).max().orElse(0);
        return x.stream().map(y -> String.format("%-" + width + "s", y)).collect(Collectors.toList());
    }).collect(Collectors.toList());

    // join corresponding fragments to result lines, and join result lines
    String result = IntStream.range(0, lines)
            .mapToObj(i -> padded.stream().map(x -> x.get(i)).collect(Collectors.joining()))
            .collect(Collectors.joining(System.lineSeparator()));

    System.out.println(result);
}