Tri des types Java Basics TreeSet et Java personnalisés

Tri des types personnalisés TreeSet et Java

• Démontre que TreeSet est triable pour String
• TreeSet Impossible de trier types personnalisés
• Comment écrire des règles de comparaison
• Structure arborescente binaire auto-équilibrée
• Implémentation de l'interface du comparateur
• Classe d'outils de collections

(Recommandation d'apprentissage gratuite : tutoriel de base Java)

Démontre que la chaîne d'appariement TreeSet est sortable

1. La couche inférieure de la collection TreeMap est en fait un TreeMap
2. La couche inférieure de la collection TreeMap est un arbre binaire
3. Les éléments placés dans la collection TreeSet , ce qui équivaut à être placé dans la partie clé de la collection TreeMap
4. Les éléments de la collection TreeSet ne sont pas ordonnés et ne peuvent pas être répétés, mais ils peuvent être automatiquement triés en fonction de la taille des éléments
Cela s'appelle : un ensemble triable
Par exemple : écrire un programme pour récupérer les données de la base de données, et afficher les informations utilisateur sur la page par ordre croissant ou décroissant par anniversaire.
Vous pouvez utiliser la collection TreeSet en ce moment, car la collection TreeSet est insérée et retirée dans l'ordre de.

//创建一个TreeSet集合
  TreeSet<string> ts=new TreeSet();
  //添加Stringts.add("zhangsan");ts.add("lisi");ts.add("wangwu");ts.add("zhangsi");ts.add("wangliu");for(String s:ts){
      //按照字典顺序排序
      System.out.print(s+" ");
  }
  TreeSet<integer> ts2=new TreeSet();ts2.add(100);ts2.add(200);ts2.add(900);ts2.add(800);  ts2.add(600);ts2.add(10);for(Integer i:ts2){
      //按照升序排序
      System.out.print(i+" ");}</integer></string>

TreeSet ne peut pas trier les types personnalisés

TreeSet peut-il trier les types personnalisés ?
Dans le programme suivant, la classe Person ne peut pas être triée car les règles de comparaison entre les objets Person ne sont pas spécifiées. Il n’est pas précisé qui est le plus âgé et qui est le plus jeune.

public class TreeSetTest02 {
    public static void main(String[] args) {
        Person p1=new Person(50);
        Person p2=new Person(10);
        Person p3=new Person(20);
        Person p4=new Person(60);
        Person p5=new Person(40);
        Person p6=new Person(30);
        TreeSet<person> persons=new TreeSet();
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);
        persons.add(p5);
        persons.add(p6);
        for(Person p:persons){
            System.out.println(p);
        }
    }}class Person{
    int age;
    public Person(int age){
        this.age=age;
    }
    @Override
    public String toString() {
        return "Person [age=" + age + "]";
    }}</person>

Exception in thread "main" java.lang.ClassCastException: testCollection.Person cannot be cast to java.lang.Comparable

La raison de cette erreur est que la classe
Person n'implémente pas java.lang, interface comparable

//Put il dans la collection TreeSet Les éléments nécessaires pour implémenter l'interface java.lang.Comparable
// et implémenter la méthode compareTo, égal à n'a pas besoin d'être écrit

  public class TreeSetTest04 {
        public static void main(String[] args) {
            Customer p1=new Customer(50);
            Customer p2=new Customer(10);
            Customer p3=new Customer(20);
            Customer p4=new Customer(60);
            Customer p5=new Customer(40);
            Customer p6=new Customer(30);
            TreeSet<customer> customers=new TreeSet();
            customers.add(p1);
            customers.add(p2);
            customers.add(p3);
            customers.add(p4);
            customers.add(p5);
            customers.add(p6);
            for(Customer p:customers){
                System.out.println(p);
            }
        }
    }
    //放在TreeSet集合中的元素需要实现java.lang.Comparable接口//并且实现compareTo方法，equals可以不写
    class Customer implements Comparable<customer>{
        int age;
        public Customer(int age){
            this.age=age;
        }
        @Override
        public String toString() {
            return "Customer [age=" + age + "]";
        }
        //需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较。
        //k.compareTo(t.key)
        //拿着参数k和集合中的每个k进行比较，返回值可能是>0,age2){//       return 1;//    }else{//       return -1;//    }
            return this.age-c.age;    //>,<p>//besoin de écrire une logique de comparaison dans cette méthode, ou comparaison Les règles selon lesquelles les comparaisons sont effectuées. <br> //k.compareTo(t.key)<br> //Comparez le paramètre k avec chaque k de l'ensemble. La valeur de retour peut être >0, / /<strong>Les règles de comparaison sont finalement mises en œuvre par les programmeurs : par exemple, par ordre croissant d'âge, ou par ordre décroissant d'âge</strong></p>
<p><strong>Comment rédiger des règles de comparaison</strong></p>
<p> Trier d'abord par âge Ordre croissant, si l'âge est le même, puis trier par nom par ordre croissant </p>
<pre class="brush:php;toolbar:false">public class TreeSetTest05 {
    public static void main(String[] args) {
        TreeSet<vip> vips=new TreeSet();
        vips.add(new Vip("zhangsi",20));
        vips.add(new Vip("zhangsan",20));
        vips.add(new Vip("king",18));
        vips.add(new Vip("soft",17));
        for(Vip vip:vips){
            System.out.println(vip);
        }
    }}class Vip implements Comparable<vip>{
    String name;
    int age;
    public Vip(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    public String toString() {
        return "Vip [name=" + name + ", age=" + age + "]";
    }
    //compareTo方法的返回值很重要：
    //返回0表示相同，value会覆盖
    //>0,会继续在右子树上找
    //<p><strong>Structure arborescente binaire auto-équilibrée</strong></p>
<p>1.<strong>Arbre binaire auto-équilibré, suivez le principe de la petite gauche et de la grande droite </strong><br> 2. Il existe trois façons de parcourir un arbre binaire <br> Traversée pré-commandée : racines gauche et droite <br> Mi- Parcours d'ordre : racines gauche et droite <br> Parcours post-ordre : racines gauche et droite <br> Remarque : avant et centre Ce dont je parlerai plus tard, c'est l'emplacement de la racine <br> 3. <strong> La collection TreeSet et la collection TreeMap utilise un parcours dans l'ordre, c'est-à-dire racine gauche et droite. Ce sont des arbres binaires auto-équilibrés</strong><br>100 200 50 60 80 120 140 130 135 180 666</p>
<p><strong>implémenter l'interface du comparateur</strong></p>
<p>Les éléments du La collection TreeSet peut être triée La deuxième façon est d'utiliser un comparateur</p>
<pre class="brush:php;toolbar:false">public class TreeSetTest06 {
    public static void main(String[] args) {
        //创建TreeSet集合的时候，需要使用比较器
        //TreeSet<wugui> wuGuis=new TreeSet();   //这样不行，没有通过构造方法传递一个比较器进去
        TreeSet<wugui> wuGuis=new TreeSet(new WuguiComparator());
        wuGuis.add(new Wugui(1000));
        wuGuis.add(new Wugui(800));
        wuGuis.add(new Wugui(900));
        wuGuis.add(new Wugui(300));
        wuGuis.add(new Wugui(60));
        for(Wugui wugui:wuGuis){
            System.out.println(wugui);
        }

    }}class Wugui{
    int age;

    public Wugui(int age) {
        super();
        this.age = age;
    }

    @Override
    public String toString() {
        return "Wugui [age=" + age + "]";
    }}//单独再这里编写一个比较器//比较器实现java.util.Comparator接口（Comparable是java.lang包下的）class WuguiComparator implements Comparator<wugui>{
    public int compare(Wugui o1,Wugui o2){
        //指定比较规则
        //按照年龄排序
        return o1.age-o2.age;
    }}</wugui></wugui></wugui>

Nous pouvons utiliser une manière de classe interne anonyme
Nous pouvons utiliser une manière de classe interne anonyme (ce la classe n'a pas de nom, nouvelle interface directe)

TreeSet<wugui> wuGuis=new TreeSet(new Comparator<wugui>(){public int compare(Wugui o1,Wugui o2){
        //指定比较规则
        //按照年龄排序
        return o1.age-o2.age;
        }});</wugui></wugui>

Conclusion finale, si vous souhaitez trier les éléments placés dans la partie clé de la collection TreeSet ou TreeMap, il y a deux manières
La première : mettre Les éléments de la collection implémentent l'interface java.lang.Comparable
Deuxièmement : Transmettez-lui un objet comparateur lors de la construction de la collection TreeSet ou TreeMap.
Comment choisir entre Comparable et Comparateur ?
Lorsque les règles de comparaison ne changent pas, ou lorsqu'il n'y a qu'une seule règle de comparaison, il est recommandé d'implémenter l'interface Comparable
S'il existe plusieurs règles de comparaison et plusieurs règles de comparaison sont nécessaires Pour basculer fréquemment entre les règles de comparaison, il est recommandé d'utiliser l'interface du comparateur
La conception de l'interface du comparateur est conforme aux principes OCP.

Classe d'outils de collection

Java.util.Collections classe d'outils de collection, qui facilite le fonctionnement des collections

public class CollectionsTest {
    static class Wugui2 implements Comparable<wugui2>{
        int age;

        public Wugui2(int age) {
            super();
            this.age = age;
        }

        @Override
        public String toString() {
            return "Wugui2 [age=" + age + "]";
        }

        @Override
        public int compareTo(Wugui2 o) {
            // TODO Auto-generated method stub
            return this.age-o.age;
        }
    }
    public static void main(String[] args) {
        //ArrayList集合不是线程安全的
        List<string> list=new ArrayList<string>();
        //变成线程安全的
        Collections.synchronizedList(list);
        //排序
        list.add("abc");
        list.add("abe");
        list.add("abd");
        list.add("abf");
        list.add("abn");
        list.add("abm");
        Collections.sort(list);
        for(String s:list){
            System.out.println(s);
        }
        List<wugui2> wuguis=new ArrayList();
        wuguis.add(new Wugui2(1000));
        wuguis.add(new Wugui2(8000));
        wuguis.add(new Wugui2(4000));
        wuguis.add(new Wugui2(6000));
        //注意：对list集合中元素排序，需要保证list集合中元素实现了Comparable接口
        Collections.sort(wuguis);
        for(Wugui2 wugui:wuguis){
            System.out.println(wugui);
        }
        //对set集合怎么排序呢
        Set<string> set=new HashSet();
        set.add("king");
        set.add("kingsoft");
        set.add("king2");
        set.add("king1");
        //将set集合转换成list集合
        List<string> myList=new ArrayList(set);
        Collections.sort(myList);
        for(String s:myList){
            System.out.println(s);
        }
        //这种方式也可以排序
        //Collections.sort(list集合，比较器对象)
    }}</string></string></wugui2></string></string></wugui2>

Recommandations d'apprentissage associées : bases de Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!