在Java中对字符串数组按字母顺序排序

Question

我的任务是将此代码转换为反向排序，但是对于我来说无法弄清楚如何去做。这些是我的排序，查找最大和交换方法。我有一种感觉，我失去了一些显而易见的东西，任何帮助都会非常感激。

public static void sort(String[] arr) 
    { 
     for (int pass = 1; pass < arr.length; pass++) 
     { 
      int largestPos = findLargest(arr, arr.length - pass); 
      if (largestPos != arr.length - pass) 
      { 
       swap(arr, largestPos, arr.length - pass); 
      } 
     } 
    } 

    public static int findLargest(String[] arr, int num) 
    { 
     int largestPos = 0; 
     for (int i = 1; i <= num; i++) 
     { 
      if (arr[i].compareToIgnoreCase(arr[largestPos]) > 0) 
      { 
       largestPos = i; 
      } 
     } 
     return largestPos; 
    } 

    public static void swap(String[] arr, int first, int second) 
    { 
     String temp = arr[first]; 
     arr[first] = arr[second]; 
     arr[second] = temp; 
    } 
} 

Answer 1

您可以使用Arrays.sort(arr)按字母顺序排序。

然后逆转它。

Answer 2

你能只是把findLargest到findSmallest，像这样的：如果你想

public static void sort(String[] arr) { 
    for (int pass = 1; pass < arr.length; pass++) { 
     int largestPos = findSmallest(arr, arr.length - pass); 
     if (largestPos != arr.length - pass) { 
      swap(arr, largestPos, arr.length - pass); 
     } 
    } 
} 

public static int findSmallest(String[] arr, int num) { 
    int largestPos = 0; 
    for (int i = 1; i <= num; i++) { 
     if (arr[i].compareToIgnoreCase(arr[largestPos]) < 0) { 
      largestPos = i; 
     } 
    } 
    return largestPos; 
} 

public static void swap(String[] arr, int first, int second) { 
    String temp = arr[first]; 
    arr[first] = arr[second]; 
    arr[second] = temp; 
} 

Answer 3

public static void sort(String[] arr) { 
    Arrays.sort(arr); 
    for (int i=0; i<arr.length/2; i++) { 
     swap(arr,i,arr.length-1-i); 
    } 
} 

试试这一个。在您的版本中，您将向阵列的最后移动最大值，从而按字母顺序排列。

就在您坚持原来的做法的情况下，我已经取得了一些小的改动代码：

public static void sort(String[] arr) 
{ 
    for (int pass = 1; pass < arr.length; pass++) 
    { 
     int largestPos = findLargest(arr, pass-1); 
     if (largestPos != pass - 1) 
     { 
      swap(arr, largestPos, pass - 1); 
     } 
    } 
} 

public static int findLargest(String[] arr, int num) 
{ 
    int largestPos = num; 
    for (int i = num+1; i < arr.length; i++) 
    { 
     if (arr[i].compareToIgnoreCase(arr[largestPos]) > 0) 
     { 
      largestPos = i; 
     } 
    } 
    return largestPos; 
} 

最微不足道的一个，虽然，通过Ian Roberts的建议，仅仅是Arrays.sort(arr, Collections.reverseOrder());。

Answer 4

我认为这是你需要的一个（如果你不考虑收集框架）。

public static void main(String args[]) { 


    String [] arr ={"abc","bac","cbc"}; 
      String temp=""; 

    for(int i=0;i<arr.length;i++){ 

     for(int j=i+1;j<arr.length;j++){ 

      if(arr[j].compareTo(arr[i]) > 0){ 

       temp = arr[i] ; 
       arr[i] = arr[j]; 
       arr[j] = temp; 
      } 
     } 

    } 

    for(String val:arr){ 
     System.out.println(val); 
    } 

} 

输出是

cbc 
bac 
abc 

Answer 5

不要重新发明轮子 -

String[] strs = {"a", "b", "d", "c", "e"}; 

Arrays.sort(strs, Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER)); 

System.out.println(Arrays.toString(strs)); 

 
[e, d, c, b, a] 

Answer 6

从ARS的回答追问：

您可以使用自定义比较器，如果你被允许使用t他Arrays.Sort方法...

Arrays.sort(stringArray, new Comparator<String>() { 
      @Override 
      public int compare(String t, String t1) { 
       return -t.compareToIgnoreCase(t1); //reverse the comparison, while ignoring case 
      } 
     }); 

Answer 7

所以，首先我们需要创建一个字符串数组，然后用Arrays.sort(String[]);，然后用for扭转数组排序颠倒顺序的。

import java.util.Arrays; 

public class SortClass { 
    public static void main(String[] args) { 
     String[] arrayString = new String[5]; 
     arrayString[0] = "Cat"; 
     arrayString[1] = "Apple"; 
     arrayString[2] = "Dog"; 
     arrayString[3] = "Mouse"; 
     arrayString[4] = "kitchen"; 
     Arrays.sort(arrayString); 
     String[] arrReverse = new String[arrayString.length]; 
     for (int i = arrayString.length - 1; i >= 0; i--) { 
      arrReverse[arrayString.length - 1 - i] = arrayString[i]; 

     } 
    } 
}