在 Java 中排序单个字符串

有没有一种本地化的方法可以根据字符串在 java 中的内容对它进行排序。

String s = "edcba"  ->  "abcde"
351539 次浏览
小开

toCharArray后面跟着 Arrays.sort，后面跟着 String 构造函数调用:

import java.util.Arrays;


public class Test
{
public static void main(String[] args)
{
String original = "edcba";
char[] chars = original.toCharArray();
Arrays.sort(chars);
String sorted = new String(chars);
System.out.println(sorted);
}
}

编辑: 正如 tackline 指出的那样，如果字符串包含代理对或者确实包含复合字符(重音 + e 作为单独的字符)等等，那么这将会失败。在这一点上它变得很难... 希望你不需要这个:)此外，这只是顺序排序，没有考虑到大写，口音或其他任何东西。

小开

不，没有内置的 String 方法。您可以将其转换为一个字符数组，使用 Arrays.sort 对其进行排序，然后将其转换回 String。

String test= "edcba";
char[] ar = test.toCharArray();
Arrays.sort(ar);
String sorted = String.valueOf(ar);

或者，当您想要正确处理特定于语言环境的东西，如大写字母和重音字符:

import java.text.Collator;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Locale;


public class Test
{
public static void main(String[] args)
{
Collator collator = Collator.getInstance(new Locale("fr", "FR"));
String original = "éDedCBcbAàa";
String[] split = original.split("");
Arrays.sort(split, collator);
String sorted = "";
for (int i = 0; i < split.length; i++)
{
sorted += split[i];
}
System.out.println(sorted); // "aAàbBcCdDeé"
}
}
小开 
    String a ="dgfa";
char [] c = a.toCharArray();
Arrays.sort(c);
return new String(c);

注意，如果它是一个混合大小写的 String (它将大写放在小写之前) ，那么它不会像预期的那样工作。您可以将比较器传递给 Sort 方法来更改它。

小开

不使用 sort Arrays.sort 方法的更原始的方法。 这是使用插入排序。

public static void main(String[] args){
String wordSt="watch";
char[] word=wordSt.toCharArray();


for(int i=0;i<(word.length-1);i++){
for(int j=i+1;j>0;j--){
if(word[j]<word[j-1]){
char temp=word[j-1];
word[j-1]=word[j];
word[j]=temp;
}
}
}
wordSt=String.valueOf(word);
System.out.println(wordSt);
}
小开

转换为字符数组 → 排序→ 转换回 String:

String s = "edcba";
char[] c = s.toCharArray();        // convert to array of chars
java.util.Arrays.sort(c);          // sort
String newString = new String(c);  // convert back to String
System.out.println(newString);     // "abcde"
小开

在 Java8中，它可以通过以下方式完成:

String s = "edcba".chars()
.sorted()
.collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
.toString();

使用长度为1的 Stream of String (未排序的 String 中的每个字符都被转换为 Stream 中的 String)的一个稍短的替代方法是:

import java.util.stream.Collectors;
import java.util.stream.Stream;


String sorted =
Stream.of("edcba".split(""))
.sorted()
.collect(Collectors.joining());
小开

程序:

  1. 首先将字符串转换为字符数组
  2. 然后对字符数组进行排序
  3. 将字符数组转换为字符串
  4. 打印字符串

代码片段:

    String input = "world";
char[] arr = input.toCharArray();
Arrays.sort(arr);
String sorted = new String(arr);
System.out.println(sorted);
小开 
public static void main(String[] args) {
String str = "helloword";
char[] arr;
List<Character> l = new ArrayList<Character>();
for (int i = 0; i < str.length(); i++) {
arr = str.toCharArray();
l.add(arr[i]);


}
Collections.sort(l);
str = l.toString();
System.out.println(str);
str = str.replaceAll("\\[", "").replaceAll("\\]", "")
.replaceAll("[,]", "");
System.out.println(str);


}
小开

不使用 Java 集合:

import java.util.Scanner;


public class SortingaString {
public static String Sort(String s1)
{
char ch[]=s1.toCharArray();
String res=" ";
        

for(int i=0; i<ch.length ; i++)
{
for(int j=i+1;j<ch.length; j++)
{
if(ch[i]>=ch[j])
{
char m=ch[i];
ch[i]=ch[j];
ch[j]=m;
}
}
            

res=res+ch[i];
            

}


return res;
}


public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("enter the string");
        

String s1=sc.next();
String ans=Sort( s1);
        

System.out.println("after sorting=="+ans);
}
}

产出:

输入字符串 = =

分类

经过分类后 = = ginorst

小开

问题: 在 java 中对字符串进行排序

public class SortAStringInJava {
public static void main(String[] args) {


String str = "Protijayi";
// Method 1
str = str.chars() // IntStream
.sorted().collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append).toString();


System.out.println(str);
// Method 2
str = Stream.of(str.split(" ")).sorted().collect(Collectors.joining());
System.out.println(str);
}
}
小开 
str.chars().boxed().map(Character::toString).sorted().collect(Collectors.joining())

或者

s.chars().mapToObj(Character::toString).sorted().collect(Collectors.joining())

或者

Arrays.stream(str.split("")).sorted().collect(Collectors.joining())
小开

使用 Stream API 并处理 Unicode 补充字符的解决方案:

public static String sort(final String s) {
return s.codePoints()
.sorted()
.collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
.toString();
}
小开

如果希望将最坏情况下的时间复杂度从 nlogn降低到 n，还可以编写一个计数排序算法来对数组中的所有字符进行排序


提交答案