一种字母排序方式

       这里我没有专注于排序算法，而是写了一个MyString类，实现了comparable的接口，然后用Arrays的sort方法来实现排序。我觉得这道题的难度在于如果比较两个。因为大小写的关系，实现起来有点复杂。

这是类一

       

1. import java.util.Arrays;
3. /*1.对字符串进行排序，用任意一种编程语言来实现，不能使用现有的类，在排序中，
4. 字符串“Bc”，“Ad”，“aC”,“Hello”，“X man”，“little”，“During”,“day”
5. 能够排序成 “Ad”，"aC"，“Bc”，“During”，“day”，“Hello”，“little”，“Hello”，
6. 也就是说，在排序的过程并不是传统的按照字符串排序，在排序中还需要将小写字母一并排序，
7. 也就是说a字符串要在B或b之前。*/
8. public class LetterSort {
10.     public static void main(String[] args) {
11.         // TODO Auto-generated method stub
12.         String[] str = { "dad", 
13.                          "bOod",
14.                          "bada","Admin","Good","aete","cc","Ko","Beta","Could"}; 
15.         MyString[] strcompare = new MyString[str.length];
16.         for(int i = 0;i<str.length;i++){
17.             strcompare[i] = new MyString(str[i]);
18.         }
19.         Arrays.sort(strcompare);
20.         for(MyString string:strcompare){
21.             System.out.println(string);
22.         }
23.     }
24. }

实现接口的MyString

1. /*这个类是封装了一个String。实现Comparable接口。这样使得可以用Arrays的sort方法进行排序*/
2. public class MyString implements Comparable<MyString> {
3.     private String string;
4.     
5.     public void setString(String string) {
6.         this.string = string;
7.     }
11.     public String getString() {
12.         return string;
13.     }
17.     //构造方法
18.     public MyString(String string){
19.         this.string = string;
20.     }
21.     
22.     
23.     
24.     //比较
25.     public int compareTo(MyString other) {
26.         // TODO Auto-generated method stub
27.         char[] thisarr = this.string.toCharArray();        //存储被包装  字符串的字符数组
28.         
29.         char[] otherarr = other.getString().toCharArray(); //存储要比较的字符串的字符数组
30.         
31.         /*取得循环次数，为两个字符串的长度的最小值*/
32.         int iterate = thisarr.length<otherarr.length?thisarr.length:otherarr.length;
33.         
34.         boolean mlowercase;                                 //记录被封装的字符串循环到的字符是否为小写
35.         
36.         boolean olowercase;                                 //记录要比较的字符串循环到的字符是否为小写                               
37.         
38.         char    thisletter;                                 //记录被封装的字符串循环到的字符
39.         
40.         char    otherletter;                                //记录要比较的字符串循环到的字符 
41.         
42.         /*字符串相等，则返回0*/
43.         if(this.getString().equals(other.getString())){
44.             return 0;
45.         }
46.         
47.         /*循环字符串，做比较*/
48.         for(int i=0;i<iterate;i++){
49.             mlowercase = this.isLowercase(thisarr[i]);        
50.             olowercase = this.isLowercase(otherarr[i]);
51.             
52.             /*把比较字符变成大写*/
53.             thisletter = mlowercase?(char)(thisarr[i]-32):thisarr[i]; 
54.             otherletter = olowercase?(char)(otherarr[i]-32):otherarr[i];
55.             
56.             /*比较*/
57.             if(thisletter!=otherletter){               //比较字母大小，不相等，则取差值，字母小的在前面
58.                 return (thisletter-otherletter);
59.             }else{                                     //字母的大写形式相同
60.                 if(mlowercase == olowercase){          //此位置大小写形式相同,判断下一个字符；
61.                     continue;
62.                 }else if(mlowercase){                  //被封装的字符为小写,则返回负值
63.                     return 32;
64.                 }else if(olowercase){                  //比较字符串的字符为小写，则返回正直
65.                     return -32;
66.                 }
67.             }
68.             
69.         }
70.         
71.         /*如果循环好之后还分不出大小，则小的排在后面*/
72.         return (thisarr.length<otherarr.length?-1:1);
73.     }
74.     
75.     @Override
76.     public String toString() {
77.         // TODO Auto-generated method stub
78.         return string;
79.     }
83.     //通过码值，来判断字符是否为小写字母
84.     private boolean isLowercase(char ch){
85.         if((int)ch >=97 && (int)ch<=122){
86.             return true;
87.         }else{
88.             return false;
89.         }
90.     }
92. }