MySort(选做)的实现

题目内容

注意：研究sort的其他功能，要能改的动代码，需要答辩
模拟实现Linux下Sort -t : -k 2的功能。
要有伪代码，产品代码，测试代码（注意测试用例的设计）
参考 Sort的实现。提交博客链接。

代码框架（题目给出）

import java.util.*;

public class MySort {
    public static void main(String[] args) {
        String[] toSort = {"aaa:10:1:1",
                "ccc:30:3:4",
                "bbb:50:4:5",
                "ddd:20:5:3",
                "eee:40:2:20"};

        System.out.println("Before sort:");
        for (String str : toSort) {
            System.out.println(str);
        }
        Arrays.sort(toSort);

        System.out.println("After sort:");
        for (String str : toSort){
            System.out.println(str);
        }
    }
}

题目理解与实现

sort命令

-t:设定间隔符。题目中-t :即设定冒号作为间隔符
-k:指定列数，即被间隔符分割后的第几块区域

所以，此题实际指实现以冒号为分隔符分割数组每个元素，以分割后每个元素的第二列的大小对原数组进行排序

伪代码

获得字符数组元素个数
建立循环，逐一获得以冒号分隔后所需区域的值
按照该值的大小，对原字符数组重新进行排序
输出排序后的该字符数组

分隔符的实现

以往涉及到分解String对象的字符序列时，我使用都是使用Stringtokenizer类和Scanner类。但是这次的实现其实使用String类提供的split（）方法（该方法见教材P189）就已经足够，它会将字符序列按照提供的分隔符进行分解，并且存为一个字符数组。我们采用此方法，就可以在这个分解出的字符数组中很轻易的得到我们想要的值。

排序的实现

思路一

这里的实现我们可以将所得到的值存为一个数组colunmn[]，先对这个数组进行排序，然后建立两层循环，对column[]中的每个值，都遍历一次原数组，数值匹配则将该元素输出，最后输出完的结果即为排序后的结果。

思路二

思路一中的方法实际上是最后输出的内容为原数组排序后的结果，实际上并未对原数组进行任何顺序的改变，而且过程中建立了许多中间数组。于是我决定换一条思路，不用Arrays.sort()方法，而是自己来写排序方法。为了方便，我选择了使用特别熟练的冒泡排序，来对原数组进行重新排序。只需将if判断内容更改为判断该分隔区的内容即可。

产品代码

public class MySort {
    public static void main(String[] args) {
        String[] toSort = {"aaa:10:1:1",
                "ccc:30:3:4",
                "bbb:50:4:5",
                "ddd:20:5:3",
                "eee:40:2:20"};

        System.out.println("Before sort:");
        for (String str : toSort) {
            System.out.println(str);
        }
        //args[0]获得我们想要排序的区域，注意这个值在后续我们放在数组中使用，因此存为area时要减1。
        int area = Integer.parseInt(args[0])-1;
        //获得原字符数组的元素个数
        int len = toSort.length;
        //冒泡排序
        for(int i=0;i<len-1;i++){
            for(int j=0;j<len-i-1;j++){
                //if中的判断条件为每一条元素被冒号分隔后area列的内容的大小
                if(Integer.valueOf(toSort[j].split(":")[area])>Integer.valueOf(toSort[j+1].split(":")[area])){
                    String tmp = toSort[j];
                    toSort[j]=toSort[j+1];
                    toSort[j+1]=tmp;
                }
            }
        }
        System.out.println("After sort:");
        for (String str : toSort) {
            System.out.println(str);
        }

    }
}

测试代码

将原代码中排序部分功能单独取出，写成代码如下：

public class MySort1 {
    String[] strings = new String[100];
    String sort(String[]strings,int n){
        this.strings = strings;
        int area =n-1;
        int len=strings.length;
        for(int i=0;i<len-1;i++){
            for(int j=0;j<len-i-1;j++){
                if(Integer.valueOf(strings[j].split(":")[area])>Integer.valueOf(strings[j+1].split(":")[area])){
                    String tmp = strings[j];
                    strings[j]=strings[j+1];
                    strings[j+1]=tmp;
                }
            }
        }
        String result ="";
        for(int i=0;i<len;i++){
            result+=strings[i]+" ";
        }
        return result;

    }

}

对上述代码进行测试，测试代码如下：

import junit.framework.TestCase;
import org.junit.Test;
public class MySort1Test extends TestCase {
    MySort1 mySort1 =new MySort1();
    String[] toSort = {"aaa:10:1:1",
            "ccc:30:3:4",
            "bbb:50:4:5",
            "ddd:20:5:3",
            "eee:40:2:20"};
    String myresult = "aaa:10:1:1 ddd:20:5:3 ccc:30:3:4 eee:40:2:20 bbb:50:4:5 ";
    String[] toSort2 = {"banana:30:5",
            "apple:10:8",
            "pear:90:7",
            "orange:20:9"};
    String myresult2 = "banana:30:5 pear:90:7 apple:10:8 orange:20:9 ";
    @Test
    public void testsort() throws Exception{
        assertEquals(myresult,mySort1.sort(toSort,2));
        assertEquals(myresult2,mySort1.sort(toSort2,3));
    }
}

测试结果截图：

MySort排序结果截图

参考

linux sort 命令详解
Java2实用教程（第八章：常用实用类）