JAVA Collections-Toolklasse-java类库-php.cn

Hauptanalyseinhalt:

Zwei sort()-Methoden der Collections-Tool-Klasse

2 Zwei sort()-Methoden

Format 1: public static

> void sort(List

list)

Beschreibung: Die generischen in dieser Methode sind alle vergleichbaren Unterklassen von Schnittstellen, d. h. es können nur Daten vom Unterklassentyp „Vergleichbare Schnittstelle“ verglichen und sortiert werden. Wenn andere Datentypen verglichen und sortiert werden sollen, müssen sie die Comparable-Schnittstelle erben und

die Methoden equal() und CompareTo() überschreiben. Unter diesen sind die String-Klasse und die Integer-Klasse allesamt Unterklassen der Comparable-Schnittstelle und können sortiert werden, während Grundtypen nicht sortiert werden können. Die Vergleichselemente werden innerhalb der Klasse

Format 2: public static

void sort(List

list, Comparator

Beschreibung angegeben : Dies Die Vergleichsmethode Comparator c ist in der Methode angegeben, das heißt, c muss die Schnittstelle Comparator super T> implementieren und die Methode CompareTo () überschreiben, um das Vergleichselement anzugeben. Die Vergleichselemente werden außerhalb der Klasse angegeben, was flexibler ist

super T> super T> 2. Beispiel

Öffentliche Methoden zum Abrufen von Zeichenfolgen und Zahlen im Beispiel:

1. Sortieren Sie die generische Ganzzahlliste

/**
     * 生成随机 不重复的字符串 : number 生成字符串个数
     */
    public static List<String> generateString(int number) {
        List<String> listString = new ArrayList<>(); // 用于存放返回值
        List<Integer> length = null; // 字符串长度
        StringBuffer sb = new StringBuffer(); // 中间变量
        int control = 0; // 控制个数
        String[] chars = new String[] { "a", "b", "c", "d", "e", "f", "g", "h",
                "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
                "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
                "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H",
                "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
                "U", "V", "W", "X", "Y", "Z" };
        while (true) {
            // 控制结束
            if ( control==number ) {
                break;
            }
            // 生成随机数，生成36位的2aaab761-4341-4968-aceb-3861ee3824b2 UUID类型数据
            String uuid = UUID.randomUUID().toString().replace("-", "");
            sb.setLength(0);
            // 获得随机字符串长度，长度不为0
            do {
                length = getDiffNo(1, 11);
            } while ( length.get(0)==0 );
            // 拼凑字符串
            for (int i=0; i<length.get(0); i++) {
                String str = uuid.substring(i*3, (i*3+3));
                //将str字符串转换为16进制，获得其值
                int x = Integer.parseInt(str, 16);
                //取余：x % 0x3E--0x3E = 3*16 + 14 = 62, 其中chars有62个字符
                sb.append(chars[x % 0x3E]);
            }
            listString.add(sb.toString());
            control++;
        }
        return listString;
    }

    /**
     * 生成随机不重复的数字 :n生成个数  max生成范围
     */
    public static List<Integer> getDiffNo(int n, int max) {
        // 生成 [0-n] 个不重复的随机数
        // list 用来保存这些随机数
        List<Integer> list = new ArrayList<>();
        Random random = new Random();
        Integer k;
        for (int i=0; i<n; i++) {
            do {
                k = random.nextInt(max);
            } while (list.contains(k));
            list.add(k);
        }
        return list;
    }

Nach dem Login kopieren

2. Sortieren Sie die generische String-Liste

/**
     * 1.通过Collections.sort()方法，对Integer泛型的List进行排序；
     * 创建一个Integer泛型的List，插入十个100以内的不重复随机整数， 调用Collections.sort()方法对其进行排序
     * 2.排序规则：先数字后字母，数字0-9，字母A-Z a-z的顺序
     */
    public void listIntegerSort() {
        // 插入十个100以内的不重复随机整数
        List<Integer> integerList = getDiffNo(10, 100);
        System.out.println("-------------排序前--------------");
        for (Integer integer : integerList) {
            System.out.println("元素：" + integer);
        }
        Collections.sort(integerList);
        System.out.println("----------------排序后-------------------");
        for (Integer integer : integerList) {
            System.out.println("元素：" + integer);
        }
    }

Nach dem Login kopieren

Sortieren Sie die anderen Arten von generischen Listen.

/**
     * 1.对String泛型的List进行排序； 创建String泛型的List，添加乱序的String元素，
     * 调用sort方法，再次输出排序后的顺序
     */
    public void listStringSort() {
        List<String> stringList = new ArrayList<String>();
        stringList.add("eipJlcx");
        stringList.add("WvQRufC");
        stringList.add("J");
        stringList.add("HdaU2G");
        stringList.add("M0WswHD3");
        System.out.println("------------排序前-------------");
        for (String string : stringList) {
            System.out.println("元素：" + string);
        }
        Collections.sort(stringList);
        System.out.println("--------------排序后---------------");
        for (String string : stringList) {
            System.out.println("元素：" + string);
        }
    }

Nach dem Login kopieren

Kursklasse implementiert

/**
     * 对String泛型的List进行排序，要求随机生成10个的不重复字符串，字符串的长度在10以内
     */
    public void listStringRandomSort() {
        // 生成随机字符串
        List<String> listString = generateString(10);
        System.out.println("--------------排序前---------------");
        for (String integer : listString) {
            System.out.println("元素：" + integer);
        }
        // 排序
        Collections.sort(listString);
        System.out.println("----------------排序后------------------");
        for (String integer : listString) {
            System.out.println("元素：" + integer);
        }
    }

Nach dem Login kopieren

Studentenklasse implementiert Comparable-Schnittstelle, legt Vergleichselemente innerhalb der Klasse fest

/**
 * 课程类
 * @author Administrator
 *
 */
public class Course {
    public String id;
    public String name;
    public Course(String id, String name) {
        this.id = id ;
        this.name = name;
    }
    public Course() {
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Course))
            return false;
        Course other = (Course) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

Nach dem Login kopieren

implementiert die Comparator-Schnittstelle, legt Vergleichselemente außerhalb der Klasse fest

import java.util.HashSet;
import java.util.Set;

/**
 * 学生类
 * @author Administrator
 *
 */
public class Student implements Comparable<Student> {
    public String id;
    public String name;
    public Set<Course> courses;
    
    public Student(String id, String name) {
        this.id = id;
        this.name = name;
        this.courses = new HashSet<Course>();
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Student))
            return false;
        Student other = (Student) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public int compareTo(Student o) { // 设置ID为比较项
        // TODO Auto-generated method stub
        return this.id.compareTo(o.id);
    }
}

Nach dem Login kopieren

Schülerklasse vergleichen

import java.util.Comparator;
public class StudentComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        // TODO Auto-generated method stub
        return o1.name.compareTo(o2.name);
    }
}

Nach dem Login kopieren

Referenz-Lernverbindung:

Implementierung und Verwendung der vergleichbaren Schnittstelle: http://www.cnblogs.com/gnuhpc/archive / 2012/12/17/2822251.html

/**
     * 对其他类型泛型的List进行排序，以Student为例。
     */
    public void listComparatorSort() {
        List<Student> studentList = new ArrayList<Student>();
        List<Integer> list = getDiffNo(4, 1000);

        studentList.add(new Student(list.get(0) + "", "Mike"));
        studentList.add(new Student(list.get(1) + "", "Angela"));
        studentList.add(new Student(list.get(2) + "", "Lucy"));
        studentList.add(new Student(1000 + "", "Beyonce"));
        System.out.println("--------------排序前---------------");
        for (Student student : studentList) {
            System.out.println("学生：" + student.id + ":" + student.name);
        }
        // 实现Comparator<T>接口，设置ID比较方式
        Collections.sort(studentList);
        System.out.println("----------------按照ID排序后------------------");
        for (Student student : studentList) {
            System.out.println("学生：" + student.id + ":" + student.name);
        }

        // 实现Comparator<T>接口，设置特定比较方式，以name比较排序
        Collections.sort(studentList, new StudentComparator());
        System.out.println("----------------按照姓名排序后-----------------");
        for (Student student : studentList) {
            System.out.println("学生：" + student.id + ":" + student.name);
        }
    }

Nach dem Login kopieren

Collections.sort Zwei Methoden zum Sortieren von Listen: http://blog.csdn.net/wxx614817/article/details/50628197