Java 我在这种方法中做错了什么？（使用StringBuilder从4个字符串创建新词）

我应该在我的主方法（s1、s2、s3和s4——主方法在测试后运行良好）中从扫描仪中获取4个字符串，并将其称为：

-->混凝土（s1、s2、s3、s4）

方法名为

concat

，可能有误导性，因为我不仅仅想要

s1+s2+s3+s4

。我真正需要的是从

s1

开始，然后添加

s2

、

s3

和

s4

中尚未出现在结果

字符串中的字符。例如，如果
s1
为“drain”，而
s2
为“dane”，则处理
s2
后的部分结果将为“draine”，因为
d
、
a
和
n
已存在于结果
字符串中

方法如下：

public static void concat(String s1, String s2, String s3, String s4) {

      String str;
      StringBuilder createdWord = new StringBuilder();      

      for (int i = 0; i < s1.length(); i++) {
         char c = s1.charAt(i);
         for (int j = 0; j < createdWord.length(); j++) {
            if (createdWord.charAt(j) != c)
               createdWord.append(c);             
         }                  
      }

      for (int i = 0; i < s2.length(); i++) {
         char c = s2.charAt(i);
         for (int j = 0; j < createdWord.length(); j++) {
            if (createdWord.charAt(j) != c)
               createdWord.append(c);             
         }         
      }

      for (int i = 0; i < s3.length(); i++) {
         char c = s3.charAt(i);
         for (int j = 0; j < createdWord.length(); j++) {
            if (createdWord.charAt(j) != c)
               createdWord.append(c);             
         }         
      }

      for (int i = 0; i < s4.length(); i++) {
         char c = s4.charAt(i);
         for (int j = 0; j < createdWord.length(); j++) {
            if (createdWord.charAt(j) != c)
               createdWord.append(c);             
         }         
      }

      str = createdWord.toString();
      System.out.println(str);

   }

公共静态void concat（字符串s1、字符串s2、字符串s3、字符串s4）{
字符串str；
StringBuilder createdWord=新建StringBuilder（）；
对于（int i=0；i

当我尝试打印（str）时，我得到一个空白输出。我确信有一种方法可以使这更简单

基于清晰、简单和/或更简单的解决方案，我会接受答案。提前谢谢
 问题出在有for循环的行中：

for (int j = 0; j < createdWord.length(); j++)

for（int j=0；j

由于createdWord刚刚初始化，它的长度为零（0），因此createdWord.length（）=0，并且永远不会到达for循环中的代码。
你应该设法解决这个问题

编辑
这就是我重构concat方法的简单方法。我还为测试提供了一个main和4个字符串。根据OP评论，预期系统输出为“drainemv”

publicstaticvoidmain（字符串[]args）{
字符串str1=“排放”；
字符串str2=“丹麦”；
字符串str3=“main”；
字符串str4=“vain”；
concat（str1、str2、str3、str4）；
}
公共静态void concat（字符串s1、字符串s2、字符串s3、字符串s4）{
字符串str；
StringBuilder createdWord=新建StringBuilder（）；
对于（int i=0；i
我相信问题已经确定，但这里有一个更简单的方法：

    String s1 = "bla";
    String s2 = "yata";
    String s3 = "test";
    String s4 = "moretest";

    String[] sr = new String[]{s1, s2, s3, s4};

    StringBuilder sbNewWord = new StringBuilder();

    sbNewWord.append(sr[0]);

    for(int ndx=1; ndx<sr.length; ndx++) {
        for(char c : sr[ndx].toCharArray()) {
            if(sbNewWord.toString().indexOf(c) == -1) {
                sbNewWord.append(c);
            }
        }
    }

String s1=“bla”；
字符串s2=“yata”；
字符串s3=“测试”；
字符串s4=“moretest”；
String[]sr=新字符串[]{s1、s2、s3、s4}；
StringBuilder sbNewWord=新StringBuilder（）；
sbNewWord.append（sr[0]）；
对于（int ndx=1；ndx使用一些Java8特性，这里是您可以做到的方法。

LinkedHashSet保留插入顺序

import java.util.*;

class Test003 {
    public static void main(String[] args) throws java.lang.Exception {
        String s1 = "test";
        String s2 = "test24m";
        String s3 = "test1";
        String s4 = "test3";

        LinkedHashSet<Character> hs = new LinkedHashSet<Character>();
        hs.addAll(Arrays.asList(s1.chars().mapToObj(c -> (char) c).toArray(Character[]::new)));
        hs.addAll(Arrays.asList(s2.chars().mapToObj(c -> (char) c).toArray(Character[]::new)));
        hs.addAll(Arrays.asList(s3.chars().mapToObj(c -> (char) c).toArray(Character[]::new)));
        hs.addAll(Arrays.asList(s4.chars().mapToObj(c -> (char) c).toArray(Character[]::new)));

        StringBuilder b = new StringBuilder();
        hs.forEach(b::append);
        System.out.println(b);
    }
}

import java.util.*；
类Test003{
公共静态void main（字符串[]args）引发java.lang.Exception{
字符串s1=“测试”；
字符串s2=“test24m”；
字符串s3=“test1”；
字符串s4=“test3”；
LinkedHashSet hs=新LinkedHashSet（）；
addAll（Arrays.asList（s1.chars（）.mapToObj（c->（char）c）.toArray（Character[]：：new））；
addAll（Arrays.asList（s2.chars（）.mapToObj（c->（char）c）.toArray（Character[]：：new））；
addAll（Arrays.asList（s3.chars（）.mapToObj（c->（char）c）.toArray（Character[]：：new））；
addAll（Arrays.asList（s4.chars（）.mapToObj（c->（char）c）.toArray（Character[]：：new））；
StringBuilder b=新的StringBuilder（）；
hs.forEach（b：：追加）；
系统输出打印ln（b）；
}
}

下面是如何在没有Java8特性的情况下实现它

import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashSet;

public class Test004 {

    public static void main(String[] args) throws java.lang.Exception {
        String s1 = "test";
        String s2 = "test24m";
        String s3 = "test1";
        String s4 = "test3";

        LinkedHashSet<Character> hs = new LinkedHashSet<Character>();
        hs.addAll(Arrays.asList(toCharacterArray(s1.toCharArray())));
        hs.addAll(Arrays.asList(toCharacterArray(s2.toCharArray())));
        hs.addAll(Arrays.asList(toCharacterArray(s3.toCharArray())));
        hs.addAll(Arrays.asList(toCharacterArray(s4.toCharArray())));

        StringBuilder b = new StringBuilder();
        Iterator<Character> it = hs.iterator();
        while (it.hasNext()){
            b.append(it.next());
        }
        System.out.println(b);
    }

    private static Character[] toCharacterArray(char[] c){
        Character[] result = new Character[c.length];
        for (int i=0; i<c.length; i++){
            result[i] = c[i];
        }
        return result;
    }
}

导入java.util.array；
导入java.util.Iterator；
导入java.util.LinkedHashSet；
公共类Test004{
公共静态void main（字符串[]args）引发java.lang.Exception{
字符串s1=“测试”；
字符串s2=“test24m”；
字符串s3=“test1”；
字符串s4=“t
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashSet;

public class Test004 {

    public static void main(String[] args) throws java.lang.Exception {
        String s1 = "test";
        String s2 = "test24m";
        String s3 = "test1";
        String s4 = "test3";

        LinkedHashSet<Character> hs = new LinkedHashSet<Character>();
        hs.addAll(Arrays.asList(toCharacterArray(s1.toCharArray())));
        hs.addAll(Arrays.asList(toCharacterArray(s2.toCharArray())));
        hs.addAll(Arrays.asList(toCharacterArray(s3.toCharArray())));
        hs.addAll(Arrays.asList(toCharacterArray(s4.toCharArray())));

        StringBuilder b = new StringBuilder();
        Iterator<Character> it = hs.iterator();
        while (it.hasNext()){
            b.append(it.next());
        }
        System.out.println(b);
    }

    private static Character[] toCharacterArray(char[] c){
        Character[] result = new Character[c.length];
        for (int i=0; i<c.length; i++){
            result[i] = c[i];
        }
        return result;
    }
}