如何在没有任何内置函数的情况下从java中的两个字符串中删除重复的字母表？

这里有两条线。由此，我如何删除常用字母/字符并存储在结果（第三个）字符串中

预期结果为：

---

gle o u t s c k v f w

获取唯一字母的最快方法是：

String firstString = "google out";
String secondString = "stack overflow";

Set<String> output = new HashSet<String>();
Collections.addAll(output, (firstString + secondString).split(""));

---

以下是另一种方法：

private String getUnicChars(String first, String second) {
            String result = "";
            for (int i = 0; i < first.length(); i++) {
                if (!second.contains(String.valueOf(first.charAt(i)))) {
                    result = result + first.charAt(i);
                }
            }

            return result;
        }


  public String yourMethod(String firstString, String secondString) {            
        return getUnicChars(firstString, secondString) + getUnicChars(secondString, firstString);
  }

私有字符串getUnicChars（字符串第一，字符串第二）{
字符串结果=”；
对于（int i=0；i

然后调用

yourMethod（“googleout”、“堆栈溢出”）

[实现]我假设您只是要求检查两个字符串之间的redondant char，而不是一个字符串内的redondant char。在我的解决方案中，“g”字符将被赋予两次。[/implementation]
这里有一种方法

// Write a static helper method.
public static boolean contains(char[] in, int index, char t) {
    for (int i = 0; i < index; i++) {
        if (in[i] == t) return true;
    }
    return false;
}

public static void main(String[] args) {
    String firstString = "google out"; // String(s) not String arrays
    String secondString = "stack overflow";
    // output cannot be larger then the sum of the inputs.
    char[] out = new char[firstString.length() + secondString.length()];
    int index = 0;
    // Add all unique chars from firstString
    for (char c : firstString.toCharArray()) {
        if (! contains(out, index, c)) {
            out[index++] = c;
        }
    }
    // Add all unique chars from secondString
    for (char c : secondString.toCharArray()) {
        if (! contains(out, index, c)) {
            out[index++] = c;
        }
    }
    // Create a correctly sized output array.
    char[] s = new char[index];
    for (int i = 0; i < index; i++) {
        s[i] = out[i];
    }
    // Just print it.
    System.out.println(Arrays.toString(s));
}

编辑

如果您的预期输出不正确，并且您实际上希望在两个字符串中都显示字符

public static void main(String[] args) {
    String firstString = "google out";
    String secondString = "stack overflow";
    char[] out = new char[firstString.length() + secondString.length()];
    int index = 0;
    for (char c : firstString.toCharArray()) {
        if (contains(secondString.toCharArray(), secondString.length(), c)) {
            out[index++] = c;
        }
    }
    char[] s = new char[index];
    for (int i = 0; i < index; i++) {
        s[i] = out[i];
    }
    System.out.println(Arrays.toString(s));
}

编辑2

如果您确实想要相反的结果，请将调用更改为
contains
，并添加第二个循环（用于反向关系）-

然后输出

[g, g, u, s, a, c, k, v, r, f, w]

公共课堂粗活2{
//函数首先删除重复项
公共静态字符串removeDuplicate（字符串val）{
char[]chars=val.toCharArray（）；
Set charSet=new LinkedHashSet（）；
for（char c:chars）{
添加（c）；
}
StringBuilder sb=新的StringBuilder（）；
for（字符：字符集）{
某人附加（字符）；
}
使某人返回字符串（）；
}
公共布尔排序（字符串a、字符串b）{
字符串arg1=移除的副本（a）；
字符串arg2=移除的副本（b）；
如果（arg1.length（）！=arg2.length（））{
System.out.print（“两个字符串计数不相等”）；
返回false；
}否则{
对于（int x=0；x
为什么使用字符串数组？字符串是一个字符数组，您不需要
string[]
来迭代字符。此外，您需要对“内置函数”是什么设置边界。结果中不应包含“l”、“o”、“t”、“e”。根据OP对“内置函数”的定义，这可能不起作用。当然，除非OP另有说明，否则这是一个很好的解决方案。@user3580294
Collections、Set、HashSet
是
java.util
包中内置的
String
也是内置的
java.lang
包，所以我们应该使用
char
type吗？但是
String
不是一个函数（我假设OP的意思是“方法”…）@hsz但是你的解决方案很好。使用Set'o'、'l'、't'等是个好主意。。。出现在“gOOgLe OuT”和“sTack OverfLOw”中，'l'@lpratlong和OP的预期输出“gle o u t s c k v f w”。@ElliotFrisch因此，最好的解决方案应该是
返回“gle o u t s c k v f w”；）。说真的，我认为他在预期产出或解释上犯了错误。@ElliotFrisch谢谢。但我认为恰恰相反。他想要的是一个词中的字符。抱歉：）@ElliotFrisch你会恨我的，但我认为编辑2是不完整的。您必须检查firstString到secondString以及secondString到firstString。我非常抱歉这么挑剔：）。
[g, o, l, e,  , u, t, s, a, c, k, v, r, f, w]

public static void main(String[] args) {
    String firstString = "google out";
    String secondString = "stack overflow";
    char[] out = new char[firstString.length() + secondString.length()];
    int index = 0;
    for (char c : firstString.toCharArray()) {
        if (contains(secondString.toCharArray(), secondString.length(), c)) {
            out[index++] = c;
        }
    }
    char[] s = new char[index];
    for (int i = 0; i < index; i++) {
        s[i] = out[i];
    }
    System.out.println(Arrays.toString(s));
}

[o, o, l, e,  , o, t]

    for (char c : firstString.toCharArray()) {
        if (! contains(secondString.toCharArray(), secondString.length(), c)) {
            out[index++] = c;
        }
    }
    for (char c : secondString.toCharArray()) {
        if (! contains(firstString.toCharArray(), firstString.length(), c)) {
            out[index++] = c;
        }
    }

[g, g, u, s, a, c, k, v, r, f, w]

public class RoughWork2 {

    // function to remove duplicates first
    public static String removeDuplicate(String val) {

        char[] chars = val.toCharArray();
        Set<Character> charSet = new LinkedHashSet<Character>();
        for (char c : chars) {
            charSet.add(c);
        }

        StringBuilder sb = new StringBuilder();
        for (Character character : charSet) {
            sb.append(character);
        }
        return sb.toString();
    }

    public boolean sort(String a, String b) {

        String arg1 = removeDuplicate(a);
        String arg2 = removeDuplicate(b);
        if (arg1.length() != arg2.length()) {
            System.out.print("two strings count are not equal");

            return false;
        } else {
            for (int x = 0; x < arg1.length(); x++) {
                int c = (int) arg1.charAt(x);
                for (int y = 0; y < arg2.length(); y++) {
                    int d = (int) arg2.charAt(y);
                    if (c == d) {

                        System.out.print(Character.toChars(c));
                    } else {
                        System.out.print("*");
                    }
                }
                System.out.println();
            }
            return true;
        }

    }

    public static void main(String[] args) {

        RoughWork2 rw = new RoughWork2();

        rw.sort("hello", "hallo");

    }
}