Question

我对此有问题，它应该采用2个字符串并返回最大的字符串，按字母顺序排序，不重复。

赞String x = "xbbacd"和String y = "ppacd" 将返回＆＃34; abcdx＆＃34;。

如果没有System ..... ln（）;

，它也会输出无输出

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Collections;

public class MyClass {
    public static String longest(String s1, String s2) {
        // your code

        HashSet<String> list1 = new HashSet<String>();
        HashSet<String> list2 = new HashSet<String>();

        for (char x : s1.toCharArray()) {
            String y = Character.toString(x);
            list1.add(y);
        }

        for (char q : s2.toCharArray()) {
            String y = Character.toString(q);
            list2.add(y);
        }

        ArrayList<String> arr1 = new ArrayList<String>();
        ArrayList<String> arr2 = new ArrayList<String>();

        for (String t : list1) {
            arr1.add(t);
        }
        for (String z : list2) {
            arr2.add(z);
        }

        Collections.sort(arr1);
        Collections.sort(arr2);

        String one = "";

        if (arr1.size() > arr2.size()) {
            for (String i : arr1) {
                one = one + i;
            }
        } else {
            for (String i : arr2) {
                one = one + i;
            }
        }

        // System.out.print(one);

        return one;
    }

    public static void main(String[] args) {
        DeleteMe a = new DeleteMe();
        a.longest("adfafasf", "xvsdvwv");
    }
}

Answer 1

如果在开头检查字符串长度，则不需要处理两个字符串，只需处理较长的字符串。只需处理较长的字符串，就可以节省大量的编码工作量。您还应该检查如何处理两个字符串长度相等，空，空字符串等的边缘情况。

试试这个：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Collections;

public class MyClass {

    public static String longest (String s1, String s2) {
    // your code
    if (len1 == null) return "String 1 is null";
    if (len2 == null) return "String 2 is null";

    // first determine which string is longer
    int len1 = s1.length();
    int len2 = s2.length();
    String longerString = null;
    if (len1 >= len2) {
        longerString = len1;
    } else {
        longerString = len2;
    }
    HashSet<String> stringHash = new HashSet<String>();

    for(char x : longerString.toCharArray() )
    {
        String y = Character.toString(x);
        stringHash.add(y);
    }

    ArrayList<String> arr1 = new ArrayList<String>();

   for(String t : list1){    arr1.add(t);    }
   Collections.sort(arr1);

   String one = new String();
   for(String i : arr1){       one = one + i;     }

   // System.out.print(one);

   return one;

}

public static void main(String[ ] args) {
    MyClass a = new MyClass();
    System.out.println(a.longest("adfafasf","xvsdvwv"));

}

Answer 2

您可以（并且很可能应该）提取“不同”并排序＆＃39;将您的方法的一部分转换为新方法以减少代码重复。你的变量名称有些令人困惑（至少对我来说），因为你命名一个列表＆＃39;和列表＆＃39; arr＆＃39; 关于无输出：您当前不使用方法的返回值，您希望最后一行为System.out.println(longest("adfafasf", "xvsdvwv");

在你的版本的重构版本之下（可以避免创建较短的字符串，但这个问题的性能似乎可以忽略不计）：

public static String longest(
        final String s1,
        final String s2) {
    ////
    final String ds1 = distinctSorted(s1);
    final String ds2 = distinctSorted(s2);
    return ds1.length() >= ds2.length() ? ds1 : ds2;
}

private static String distinctSorted(
        final String s) {
    ////
    final Set<Character> set = new HashSet<>();
    for (final char c : s.toCharArray()) {
        set.add(c);
    }

    final List<Character> list = new ArrayList<>(set);
    Collections.sort(list);

    final StringBuilder sb = new StringBuilder(list.size());
    for (final char c : list) {
        sb.append(c);
    }
    return sb.toString();
}

distinct和sort方法的替代方法：

private static String distinctSorted(
        final String s) {
    ////
    return s.chars().sorted().distinct()
            .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
            .toString();
}

如何删除字符串中的重复并对其进行排序？

2 个答案: