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

Question

我遇到了这个问题，它应该采用2个字符串并返回最大的一个，按字母顺序排序，无需重复。

like String x = "xbbacd" and String y = "ppacd" 将返回“abcdx”。如果没有System ..... ln（）;如果没有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

你可以（而且很可能应该）提取将你方法的一部分“分离和排序”为一种减少代码重复的新方法。当你命名一个“列表”和一个列表“arr”时，你的变量名称会有些混乱（至少对我而言）。
关于无输出：您目前不使用方法的返回值，你希望你的最后一行是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(); 
} 

用于不同的和排序的方法的替代：

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