Java 给定两个包含1个或多个常用字母的字符串，将它们放在一起，例如；ab"+&引用；bc"；=&引用；abc"；

当字符串有两个以上的常用字母时，我感到困惑： “abc”+“bcd”=“abcd”，不重复“abccd”或“ABBCD”

公共静态字符串创建新名称（字符串名称1，字符串名称2）{
字符串结果=”；
对于（int i=0；i

---

但是这个代码不起作用！请帮助。

假设这是一个学习练习，我不会因为编写代码而破坏您的乐趣

下面是一个只需要一个显式循环的简单算法：遍历第一个字符串的所有后缀，并检查它们是否表示第二个字符串的前缀。从最长的后缀开始（这是整个第一个单词），然后用越来越短的后缀继续。找到与第二个单词的前缀匹配的后缀后，删除该后缀，并将第二个字符串附加到结果中

 public static String make_new_name(String name1, String name2) {
     Set<Character> nameSet1 = new HashSet<Character>();
     for(char c : name1.toCharArray())
     {
         nameSet1.add(c);
     }

     Set<Character> nameSet2 = new HashSet<Character>();
     for(char c : name2.toCharArray())
     {
         nameSet2.add(c);
     }

     nameSet1.removeAll(nameSet2); // Set Difference

     StringBuilder sb = new StringBuilder(nameSet1.size() + nameSet2.size());

     for(Character c : nameSet1)
     {
         sb.append(c);
     }
     for(Character c : nameSet2)
     {
         sb.append(c);
     }

     return sb.toString();

 }

---

在Java中，通过使用一个参数调用substring来获得单词的后缀。要检查一个字符串是否是另一个字符串的前缀，请使用startsWith方法。

假设这是一个学习练习，我不会因为编写代码而破坏您的乐趣

下面是一个只需要一个显式循环的简单算法：遍历第一个字符串的所有后缀，并检查它们是否表示第二个字符串的前缀。从最长的后缀开始（这是整个第一个单词），然后用越来越短的后缀继续。找到与第二个单词的前缀匹配的后缀后，删除该后缀，并将第二个字符串附加到结果中

 public static String make_new_name(String name1, String name2) {
     Set<Character> nameSet1 = new HashSet<Character>();
     for(char c : name1.toCharArray())
     {
         nameSet1.add(c);
     }

     Set<Character> nameSet2 = new HashSet<Character>();
     for(char c : name2.toCharArray())
     {
         nameSet2.add(c);
     }

     nameSet1.removeAll(nameSet2); // Set Difference

     StringBuilder sb = new StringBuilder(nameSet1.size() + nameSet2.size());

     for(Character c : nameSet1)
     {
         sb.append(c);
     }
     for(Character c : nameSet2)
     {
         sb.append(c);
     }

     return sb.toString();

 }

---

在Java中，通过使用一个参数调用substring来获得单词的后缀。要检查一个字符串是否是另一个字符串的前缀，请使用startsWith方法。

假设这是一个学习练习，我不会因为编写代码而破坏您的乐趣

下面是一个只需要一个显式循环的简单算法：遍历第一个字符串的所有后缀，并检查它们是否表示第二个字符串的前缀。从最长的后缀开始（这是整个第一个单词），然后用越来越短的后缀继续。找到与第二个单词的前缀匹配的后缀后，删除该后缀，并将第二个字符串附加到结果中

 public static String make_new_name(String name1, String name2) {
     Set<Character> nameSet1 = new HashSet<Character>();
     for(char c : name1.toCharArray())
     {
         nameSet1.add(c);
     }

     Set<Character> nameSet2 = new HashSet<Character>();
     for(char c : name2.toCharArray())
     {
         nameSet2.add(c);
     }

     nameSet1.removeAll(nameSet2); // Set Difference

     StringBuilder sb = new StringBuilder(nameSet1.size() + nameSet2.size());

     for(Character c : nameSet1)
     {
         sb.append(c);
     }
     for(Character c : nameSet2)
     {
         sb.append(c);
     }

     return sb.toString();

 }

---

在Java中，通过使用一个参数调用substring来获得单词的后缀。要检查一个字符串是否是另一个字符串的前缀，请使用startsWith方法。

假设这是一个学习练习，我不会因为编写代码而破坏您的乐趣

下面是一个只需要一个显式循环的简单算法：遍历第一个字符串的所有后缀，并检查它们是否表示第二个字符串的前缀。从最长的后缀开始（这是整个第一个单词），然后用越来越短的后缀继续。找到与第二个单词的前缀匹配的后缀后，删除该后缀，并将第二个字符串附加到结果中

 public static String make_new_name(String name1, String name2) {
     Set<Character> nameSet1 = new HashSet<Character>();
     for(char c : name1.toCharArray())
     {
         nameSet1.add(c);
     }

     Set<Character> nameSet2 = new HashSet<Character>();
     for(char c : name2.toCharArray())
     {
         nameSet2.add(c);
     }

     nameSet1.removeAll(nameSet2); // Set Difference

     StringBuilder sb = new StringBuilder(nameSet1.size() + nameSet2.size());

     for(Character c : nameSet1)
     {
         sb.append(c);
     }
     for(Character c : nameSet2)
     {
         sb.append(c);
     }

     return sb.toString();

 }

---

在Java中，通过使用一个参数调用substring来获得单词的后缀。要检查一个字符串是否是另一个字符串的前缀，请使用startsWith方法。

您可以设置两个字符串之间的差异，然后将它们合并以获得结果

 public static String make_new_name(String name1, String name2) {
     Set<Character> nameSet1 = new HashSet<Character>();
     for(char c : name1.toCharArray())
     {
         nameSet1.add(c);
     }

     Set<Character> nameSet2 = new HashSet<Character>();
     for(char c : name2.toCharArray())
     {
         nameSet2.add(c);
     }

     nameSet1.removeAll(nameSet2); // Set Difference

     StringBuilder sb = new StringBuilder(nameSet1.size() + nameSet2.size());

     for(Character c : nameSet1)
     {
         sb.append(c);
     }
     for(Character c : nameSet2)
     {
         sb.append(c);
     }

     return sb.toString();

 }

公共静态字符串创建新名称（字符串名称1，字符串名称2）{
Set nameSet1=新的HashSet（）；
for（char c:name1.toCharArray（））
{
名称集1。添加（c）；
}
Set nameSet2=新的HashSet（）；
for（char c:name2.toCharArray（））
{
名称集2.添加（c）；
}
nameSet1.removeAll（nameSet2）；//设置差异
StringBuilder sb=新的StringBuilder（名称集1.size（）+名称集2.size（））；
for（字符c:名称集1）
{
sb.附加（c）；
}
for（字符c:名称集2）
{
sb.附加（c）；
}
使某人返回字符串（）；
}

您可以设置两个字符串的差值，然后对它们进行合并以获得结果

 public static String make_new_name(String name1, String name2) {
     Set<Character> nameSet1 = new HashSet<Character>();
     for(char c : name1.toCharArray())
     {
         nameSet1.add(c);
     }

     Set<Character> nameSet2 = new HashSet<Character>();
     for(char c : name2.toCharArray())
     {
         nameSet2.add(c);
     }

     nameSet1.removeAll(nameSet2); // Set Difference

     StringBuilder sb = new StringBuilder(nameSet1.size() + nameSet2.size());

     for(Character c : nameSet1)
     {
         sb.append(c);
     }
     for(Character c : nameSet2)
     {
         sb.append(c);
     }

     return sb.toString();

 }

公共静态字符串创建新名称（字符串名称1，字符串名称2）{
Set nameSet1=新的HashSet（）；
for（char c:name1.toCharArray（））
{
名称集1。添加（c）；
}
Set nameSet2=新的HashSet（）；
for（char c:name2.toCharArray（））
{
名称集2.添加（c）；
}
nameSet1.removeAll（nameSet2）；//设置差异
StringBuilder sb=新的StringBuilder（名称集1.size（）+名称集2.size（））；
for（字符c:名称集1）
{
sb.附加（c）；
}
for（字符c:名称集2）
{
sb.附加（c）；
}
使某人返回字符串（）；
}

您可以设置两个字符串的差值，然后对它们进行合并以获得结果

 public static String make_new_name(String name1, String name2) {
     Set<Character> nameSet1 = new HashSet<Character>();
     for(char c : name1.toCharArray())
     {
         nameSet1.add(c);
     }

     Set<Character> nameSet2 = new HashSet<Character>();
     for(char c : name2.toCharArray())
     {
         nameSet2.add(c);
     }

     nameSet1.removeAll(nameSet2); // Set Difference

     StringBuilder sb = new StringBuilder(nameSet1.size() + nameSet2.size());

     for(Character c : nameSet1)
     {
         sb.append(c);
     }
     for(Character c : nameSet2)
     {
         sb.append(c);
     }

     return sb.toString();

 }

公共静态字符串创建新名称（字符串名称1，字符串名称2）{
Set nameSet1=新的HashSet（）；
for（char c:name1.toCharArray（））
{
名称集1。添加（c）；
}
Set nameSet2=新的HashSet（）；
for（char c:name2.toCharArray（））
{
名称集2.添加（c）；
}
nameSet1.removeAll（nameSet2）；//设置差异
StringBuilder sb=新的StringBuilder（名称集1.size（）+名称集2.size（））；
for（字符c:名称集1）
{
sb.附加（c）；
}
for（字符c:名称集2）
{
sb.附加（c）；
}
使某人返回字符串（）；
}

您可以设置两个字符串的差值，然后对它们进行合并以获得结果

 public static String make_new_name(String name1, String name2) {
     Set<Character> nameSet1 = new HashSet<Character>();
     for(char c : name1.toCharArray())
     {
         nameSet1.add(c);
     }

     Set<Character> nameSet2 = new HashSet<Character>();
     for(char c : name2.toCharArray())
     {
         nameSet2.add(c);
     }

     nameSet1.removeAll(nameSet2); // Set Difference

     StringBuilder sb = new StringBuilder(nameSet1.size() + nameSet2.size());

     for(Character c : nameSet1)
     {
         sb.append(c);
     }
     for(Character c : nameSet2)
     {
         sb.append(c);
     }

     return sb.toString();

 }

公共静态字符串创建新名称（字符串名称1，字符串名称2）{
Set nameSet1=新的HashSet（）；
for（char c:name1.toCharArray（））
{
名称集1。添加（c）；
}
Set nameSet2=新的HashSet（）；
对于（ch