Java实现单词自定义排序|集合类、工具类排序、comparable、comparator接口

课题

针对单词进行排序，先按字母的长度排序，长者在前；
在长度相等的情况下，按字典降序排序。
例如，有单词序列“apple banana grape orange”,排序后输出结果应为“orange banana grape apple”。

代码

package exp1;

import java.util.List;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.TreeSet;
import java.util.stream.Collector;


class word implements Comparable {
    public String text;
    public int len;
    public word() {
        // TODO Auto-generated constructor stub
        this.text = null;
        len = 0;
    }
    public word(String text) {
        this.text = text;
        this.len = text.length();
    }
    public String toString() { //println 打印字符串 先把"输出"转型成字符串:使用valueof 调用了obj.toString之后返回字符串
        return text + ":" +  len;
    }
    public int compareTo(Object obj) {
        word anothorWord = (word) obj; //父类型转型
        if(this.len > anothorWord.len) return -1;
        else if(this.len < anothorWord.len) return 1;
        int cmpFlag = this.text.compareTo(anothorWord.text);
        return -cmpFlag;
    }
    
}

class myTreeComparator implements Comparator{ //定制排序
    //用obj2 和 obj1 比较,obj2是主,和其他obj1比较,
    public int compare(Object obj1,Object obj2) {
        String s1 = (String) obj1; //父转子类型
        String s2 = (String) obj2;
        if(s2.length() > s1.length()) return 1;//先比较长度
        else if(s2.length() < s1.length()) return -1;
        int cmpFlag = s2.compareTo(s1);//按字典序比较字符串
        return cmpFlag; //compareTo约定 返回值:负数小于,0相等,正数大于
    }
}

class myArrayCompartor implements Comparator{ //定制ArrayList的排序规则
    public int compare(Object obj1,Object obj2) {
        word s1 = (word) obj1;
        word s2 = (word) obj2;
        if(s2.len > s1.len) return 1;
        else if(s2.len < s1.len) return -1;
        int cmpFlag = s2.text.compareTo(s1.text);
        return cmpFlag;
    }
}


public class hellotest {
        
    public static void main(String args[]) {
        TreeSet<word> tre = new TreeSet<word>(); //测试泛型 和下面写法的不同点
//      TreeSet tre2 = new TreeSet();//默认按字典序排序
        tre.add(new word("grape"));
//      tre.add(1213); //出错
        /*
         * 方法1:使用集合类排序,  实现comparable重写compareTo方法，  或者使用Compartor定制排序器
         * 方法2:使用工具类Array排序, 同上
        */
        //:自然排序,存储元素的自定义和类实现Comparable接口,重写compareTo方法
        TreeSet tre1 = new TreeSet();
//      tre1.add(112);
        tre1.add(new word("apple"));
        tre1.add(new word("orange"));
        tre1.add(new word("banana"));
        tre1.add(new word("grape"));
        System.out.println("Treeset实现comparable接口：");
        System.out.println(tre1);
        
        //传入compartor接口实现定制排序规则
        TreeSet tre2 = new TreeSet(new myTreeComparator()); //传入匿名类 覆写compare方法
        tre2.add("apple");
        tre2.add("orange");
        tre2.add("banana");
        tre2.add("grape");
        System.out.println("Treeset实现compartor接口：");
        System.out.println(tre2); //打印成数组
        
        //使用Lambda表达式定制排序规则
        TreeSet tre3 = new TreeSet((obj1,obj2)->{
            String s1 = (String) obj1;
            String s2 = (String) obj2;
            if(s2.length() > s1.length()) return 1;//先比较长度
            else if(s2.length() < s1.length()) return -1;
            return s2.compareTo(s1);//字符串降序
        });
        tre3.add("apple");
        tre3.add("orange");
        tre3.add("banana");
        tre3.add("grape");
        System.out.println("Treeset使用Lambada表达式实现compartor接口：");
        tre3.forEach(obj->System.out.println("tre3: " + obj));
        
        //List集合的sort排序
        ArrayList<word> arlArrayList = new ArrayList<word>();
        arlArrayList.add(new word("apple"));
        arlArrayList.add(new word("orange"));
        arlArrayList.add(new word("banana"));
        arlArrayList.add(new word("grape"));
        //ArrayList 继承重写父接口 List的sort方法,需传入comparator接口参数， 实际上也是调用Arrays工具类的sort
        //ArrayList的sort方法,再调用工具类Array的Arrays.sort((E[]) elementData, 0, size, c);
        arlArrayList.sort(new myArrayCompartor());
        System.out.println("Treeset使用Lambada表达式实现compartor接口：");
        System.out.println(arlArrayList);
        
        
        //方法2:使用工具类Arrays的sort方法对数组排序  asList返回一个ArrayList  new ArrayList(collection) 接收一个集合 使用底层copy数据
        //Arrays.asList返回类型是ArrayList  听说过asList的坑：返回的ArrayList无法再添加新元素 所以这里使用new ArrayList(Arrays.asList) 包装一层就可以再添加新元素啦
        List<word> list = new ArrayList<word>(Arrays.asList(new word("apple"),new word("orange"),new word("banana"),new word("grape"))); //asList接收可变长度参数
        word[] arr = new word[list.size()];
        list.toArray(arr); // return an array containing the elements of this list
        Arrays.sort(arr); //使用工具类Arrays的sort方法对数组排序  1.可以传入自定义的Comparator,2.也可以在自定义类里实现Comparable重写compare方法
        //底层遗留归并排序 新二分排序
        for(int i=0;i<arr.length;i++) System.out.println(arr[i]);
    }
}