Cadre de collection en Java (Partie 2)

Étant donné que le cadre de collection en Java a beaucoup de contenu, il est divisé en trois parties pour présenter le cadre de collection en Java. le contenu vient de Du superficiel au profond, haha, cet article est en fait toujours l'essentiel. Est-ce surprenant ou pas ? J'en ai vraiment marre d'écrire, et je suis trop paresseux pour écrire. .

Rappel chaleureux : il est recommandé de commencer la lecture à partir de (Partie 1)~

Table des matières

Facile à lire Framework de collection Java (Partie 1) )

Une introduction simple au framework de collection Java (Partie 2)

Une introduction simple à Java cadre de collection (Partie 2)

Avant-propos

Dans<

Cadre de collections Java facile à apprendre (Partie 2) > Les opérations de base de l'interface Map sont présentées. L'exemple utilisé est un petit programme permettant de simuler la sélection de cours par les étudiants dans <Java Collection Framework (Part 1) >. Les amis qui ne sont pas clairs peuvent le lire en premier<Easy to Learn Deep Java Collection Framework. (Partie 1) >. Dans cet article nous allons résoudre les problèmes suivants :

Dans une séquence de cours, comment déterminer si un ou plusieurs cours sont inclus ?

Si la séquence de cours contient un certain cours, comment déterminer la position d'index du cours ?

Dans le tableau de cartographie des étudiants, comment déterminer si une certaine carte d'étudiant est incluse ?

Comment déterminer si un objet étudiant est inclus ?

Et si les cours ou les objets étudiants sont triés par nom de cours ou par nom d'étudiant ? Qu'en est-il du tri par ID ?

Les problèmes semblent nombreux et compliqués, mais en fait ils se composent principalement de deux parties :
Comment déterminer si un ensemble contient un élément Comment ; combiner un ensemble ordonné Trier selon des règles spécifiées .

1. Application de la méthode contain dans un ensemble
Pour la première question, l'ensemble fournit une méthode appelée contain Cette méthode est utilisée pour déterminer si l'ensemble contient un certain. Element, pour la méthode contain, nous examinerons son utilisation et ses précautions à partir des collections List, Set et Map respectivement.
1) La méthode contain() dans List - déterminez si le cours dans List existe
Tout d'abord, écrivons une méthode de test pour utiliser la méthode contain pour déterminer si le cours dans List existe :

1 /* 2  * 测试List的contains方法 3  */ 4     public void testListContains(){ 5         //取得备选课程序列的第0个元素 6         Course cr=this.CoresesToSelect.get(0); 7         System.out.println("取得课程：" +cr.getId()+","+cr.getName()); 8         System.out.println("备选课程中是否包含课程："+cr.getName()+","+this.CoresesToSelect.contains(cr)); 9         //创建一个新的课程对象，它的id和name和cr一样10         Course cr2=new Course(cr.getId(),cr.getName());11         System.out.println("备选课程中是否包含课程："+cr2.getName()+","+this.CoresesToSelect.contains(cr2));12         //通过indexOf方法来取的某元素的索引位置13         if(CoresesToSelect.contains(cr2)){14             System.out.println("课程："+cr2.getName()+"的索引位置为："+CoresesToSelect.indexOf(cr2));15 16         }17     }
Copier après la connexion
Résultats en cours :

Analyse des résultats :
Depuis résultats en cours d'exécution On peut voir que le premier cours "Data Structure" appelle la méthode contain et renvoie true, tandis que le deuxième cours "Data Structure" appelle la méthode contain et renvoie false. Pourquoi les cours portant le même titre « Structure des données » ont-ils deux résultats complètement différents ?
Le premier cours "structure de données" est tiré de la collection
CoresesToSelect, donc bien sûr la collection CoresesToSelect le contient, et l'appel de la méthode contain renvoie true ;Le le deuxième cours "Data Structure" est un nouveau cours (nouvellement créé) et le système a ouvert un autre espace mémoire. Bien que son nom soit le même que le premier "Data Structure", il s'agit de deux objets différents pour le système. La méthode contain compare par défaut l'adresse mémoire de l'objet de référence (code de hachage), alors comment pouvons-nous utiliser des cours portant le même nom pour déterminer si le cours est inclus dans la liste ?
Ici, nous devons avoir une compréhension approfondie des principes de la méthode contain pour nous aider à comprendre et à utiliser la méthode contain. Comme le montre la figure ci-dessous :

Toutes les classes de la méthode sont héritées de la classe Object, et il existe une méthode equals() dans la classe Object, qui est utilisée pour comparer deux. Que les objets soient égaux, l'explication détaillée de la méthode equals() se trouve dans mon autre article de blog, lien :
Jetons ensuite un coup d'œil au principe interne de la méthode contain.
Comme le montre la figure ci-dessus, la méthode contain compare en fait si deux objets sont égaux en parcourant la méthode equals de chaque objet de la collection S'ils sont égaux, elle renvoie vrai, sinon elle renvoie faux. Par défaut, equals() compare si les références de deux objets sont égales. Si nous voulons utiliser la méthode contain pour comparer si les valeurs de deux objets sont égales afin de déterminer si la collection contient un objet, nous devons remplacer les égaux. () méthode de l'objet.
Ce qui suit consiste à réécrire la méthode equals() de la classe Course pour comparer si les noms de deux objets de cours sont identiques, tels que :

1 public void equals (Object obj) 2 { 3   if(this == obj)  // 指向同一个内存快必然是相同的 4      returned true;  //为什么contains(course2) 返回的是false 原因就在在这里只是比较了一下引用的值是否相同没有进一步的比较内存块中的值下就是对这里记性了改写 5   if (obj == null)  // 如果obj为空就直接没有戏了 6      return false; 7   if(! (obj instanceof Course))  //如果两者的不属于同一类型则也直接没戏了 8     return false; 9   //经过以上的这么多的比较终于可以判断二者的值是不是相同了10   //首相要把objet型的obj转成 Course11   Course course = (Course)  obj；12   if( this.name == null )13   ｛14      if(course.name == null )15         return true;16      else return false;17    }18    else19    {20      if(this.name.equals(course.name)) return true;21      else return false;22    )23    //如果还有别的属性接着写24 }
Copier après la connexion

重写完Course类的equals()方法后，我们重写运行一下程序，结果如下：

可以看到contains方法可以根据课程名称来判断是否包含该课程了。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

这里的indexOf()方法与lastIndexOf()方法实现原理和contains方法相似：

1、遍历调用每个元素的equals()方法，如果返回true则将次元素的索引返回；

2、如果有多个相同元素，则只返回第一个元素的索引；

3、lastIndexOf()方法则从最后一个元素开始遍历；

2）Set中contains()方法——判断Set中课程是否存在

首先我们也来写一个测试方法来用contains方法来判断Set中课程是否存在：

1     /* 2      * 测试Set的contains方法 3      */ 4     public void testSetContains(){ 5         System.out.println("请输入学生已选的课程名称："); 6         String cName=in.next(); 7         Course c=new Course(cName); 8         System.out.println("学生已选的课程是否包含课程："+cName+","+stu.getCourses().contains(c)); 9 10     }
Copier après la connexion

运行结果：

这就奇怪了，我们不是已经重写了Course类的equals()方法吗？为什么在Set集合里调用contains方法还是返回false？

原来在HashSet里的contains方法和List里略有不同。它的原理如下图所示：

Set.contains(E e)工作原理是先调用从Object继承而来的hashCode方法，然后再调用equals()方法，如果hashCode相同，才会调用equals方法，只有两者都返回true，contains方法才返回true。jvm运行时，给每个对象分配唯一一个标志身份的标志hashcode。众类鼻祖Object的hashCode()方法在默认情况下，判断哈希码是不是相同。即如同equals默认情况下比较的是二者是不是同一个内存快。Set集的contains方法，内部就是先调用hashCode再调用equals(）方法。很多情况要结合实际对hashCode进行改写。

这里给出我对hashCode的重写（系统自动生成）：

1 public int hashCode() {2         final int prime = 31;3         int result = 1;4         result = prime * result + ((name == null) ? 0 : name.hashCode());5         return result;6     }
Copier après la connexion

然后我们重写运行一下程序，结果如下：

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

这里我总结一下List和Set中contains方法的注意事项：

1.list 与 set 中contain()方法调用机制：

list 中的contain()方法是拿到list中的每个对象来调用Object类中的equals()方法；

Set 中的contain()方法是拿到list中的每个元素来先调用hashcode()方法来返回哈希码值，当哈希码的值相等时，再调用equals()方法，当比较的元素此时也相同时，才会返回true。因此调用Set中的contain()方法时，需要对hashcode()方法及equals()方法进行重写。

2. == 和equals()两种比较方法，在使用时要注意：

1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

　　　　      如果作用于引用类型的变量，则比较的是所指向的对象的地址。

2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量。

如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；诸如String、Date等类应该根据情况覆盖其父类或Object类中的equals()方法，否则默认的equals()方法功能与“==”相同。

3）Mapt中containsKey方法和containsValue方法——判断Map中是否包含指定的key和value

Map中通过containsKey()方法和containsValue()方法来判断键和值是否存在（已经重写Student类的Hashcode和equals方法，这里不再列出）：

1 /* 2      * 测试Map中，是否包含某个key值或者某个value值 3      */ 4     public void ContainsKeyOrValue(){ 5         //在Map中，用containsKey方法，来判断是否包含某个key值 6         System.out.println("请输入学生id："); 7         String id =in.next(); 8         System.out.println("您输入的学生id为"+id+",Map中是否包含此id："+this.students.containsKey(id)); 9         if(students.containsKey(id)){10             System.out.println("对应的学生姓名："+students.get(id).getName());11 12         }13         //在Map中，用containsValue方法，来判断是否包含某个value值14         System.out.println("请输入学生姓名：");15         String name =in.next();16         Student st=new Student();17         st.setName(name);18         System.out.println("您输入的学生姓名为"+name+",Map中是否包含此姓名："+this.students.containsValue(st));19         if(students.containsValue(st)){20             21             Set<Entry<String, Student>> entrySet =students.entrySet();22             for(Entry<String, Student> entry:entrySet){23                 if(entry.getValue().getName().equals(name)){24                     System.out.println("对应的学生的id："+entry.getValue().getId());25                 }26 27             }28         }29 30     }
Copier après la connexion

运行结果：

注意：

1.Map 中对对象进行了 Key 标记，通过 get（Key）可以取得对应的对象。

2.Map 的containsValue（）方法的参数是 Object 对象，因为Map 的 Value 值是对象元素。

3.Map 的containsKey（）方法取得 Map 映射的 Key 值。

4.Map中的containsValue()方法原理跟HashSet的contains（）相同，所以要重写Hashcode和equals方法。

二、Collections工具类

对于第二个问题，java集合框架还有一个成员就是Collections工具类，这个工具类提供了很多操作集合的方法，其中sort()方法是很常见的方法，它能对有序集合按照默认规则进行排序。接下来我们通过实例来看看Collections工具类是如何通过sort()对List进行排序的。

我写了四个测试方法来测试sort（）方法，分别如下：

1）对Integer泛型的List进行排序

1 /* 2      * 1.通过Collections.sort()方法，对Integer泛型的List进行排序 3      * 创建一个Integer泛型的List，插入十个100以内的不重复随机整数 4      * 调用Collections.sort()方法对其排序 5      */ 6     public void testSort1(){ 7         //创建一个Integer泛型的List，插入十个100以内的不重复随机整数 8         List<Integer> intList=new ArrayList<Integer>(); 9         int i=0;10         do{11             Random random=new Random();12             Integer n=random.nextInt(100);13             if(!intList.contains(n)){14                 intList.add(n);15                 System.out.println("成功添加整数："+n);16                 i++;17             }18         }while(i<10);19 System.out.println("----------排序前-----------");20 for(Integer t:intList){21 System.out.print(t+" ");22 }23 System.out.println();24 //调用Collections.sort()方法对其排序25 26 System.out.println("----------排序后-----------");27 Collections.sort(intList);28 for(Integer t:intList){29 System.out.print(t+" ");30 }31 }
Copier après la connexion
运行结果：
这里我使用了Random类来获取随机数，Random类的出现，可以替代之前的Math.random方法；
Random类有很多方法：nextByte、nextDouble、nextInt、nextDouble、nextBoolean、nextFloat、nextLong，获取各种类型的随机数，但是没有nextShort和nextCharacter。
并且对于nextInt并且支持传入一个int类型参数，作为随机数的取值范围。
常见用法：nextInt对于从某一个String类型的对象中，获取一个随机位的字符很有用，
例如String str = "sdfsfsfsdsafdf"; Random r = new Random();char c = str.charAt(r.nextInt(str.length));
Copier après la connexion
2）对String泛型的List进行排序
1 /* 2 *2.对String泛型的List进行排序 3 * 创建一个String泛型的List，添加三个乱序的String 4 * 调用Collections.sort()方法对其排序 5 */ 6 public void testSort2(){ 7 //创建一个String泛型的List，添加三个乱序的String 8 List<String> strList=new ArrayList<String>(); 9         String[] str={"egesg","eDSGvdxbrb","23235sdvfsd"};10         strList.addAll(Arrays.asList(str));11         System.out.println("----------排序前-----------");12         for(String s:strList){13             System.out.print(s+",");14         }15         System.out.println();16     //调用Collections.sort()方法对其排序17         System.out.println("----------排序后-----------");18         Collections.sort(strList);19         for(String s:strList){20             System.out.print(s+",");21         }22     }
Copier après la connexion

运行结果：

再写一个稍微复杂一点的例子：

1 /* 2      * 3      * 创建一个String泛型的List，往其中添加十条随机字符串 4      * 每条字符串的长度为10以内的随机整数 5      * 每条字符串的每个字符都为随机生成的字符，字符可以重复 6      * 每条随机字符串不可以重复 7      * 调用Collections.sort()方法对其排序 8      */ 9     public String getRandomString(int size) {10         StringBuilder str= new StringBuilder();//可变字符串11         Random random=new Random();12         //存放所包含字符62位13         String  container = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";14         for(int j=0;j<size;j++){15             str.append(container.charAt(random.nextInt(container.length()-1)));16         }17         return str.toString();18     }19     public void testSort3(){20     21         //创建一个String泛型的List22         List<String> strList=new ArrayList<String>();23         Random random=new Random();24         String str;25         for(int i=0;i<10;i++){//添加十条随机字符串26 do{27 int size=random.nextInt(10);//每条字符串的长度为10以内的随机整数28 str=getRandomString(size);29 }while(strList.contains(str)||str.length()==0);30 strList.add(str);31 32 }33 System.out.println("----------排序前-----------");34 for(String s:strList){35 System.out.println(s);36 }37 System.out.println();38 //调用Collections.sort()方法对其排序39 System.out.println("----------排序后-----------");40 Collections.sort(strList);41 for(String s:strList){42 System.out.println(s);43 }44 }
Copier après la connexion
运行结果：
注意：
对于String类型的sort（）方法默认排序顺序为：
数字（0-9）--->大写字母（A-Z）--->小写字母（a-z）
3）对其他类型泛型的list进行排序，以，Student为例。
1     /* 2      * 对其他类型泛型的list进行排序，以，Student为例。 3      */ 4     public void testSort4(){ 5         List<Student> stus=new ArrayList<Student>(); 6         Random random=new Random(); 7         stus.add(new Student(random.nextInt(1000)+"","Mike")); 8         stus.add(new Student(random.nextInt(1000)+"","Angela")); 9         stus.add(new Student(random.nextInt(1000)+"","Lucy"));10         System.out.println("----------排序前-----------");11         for(Student s:stus){12             System.out.println(s.getId()+","+s.getName()+" ");13         }14         System.out.println();15         System.out.println("----------排序后-----------");16         Collections.sort(stus);//程序编译出错17         for(Student s:stus){18             System.out.println(s.getId()+","+s.getName()+" ");19         }20         21     }
Copier après la connexion
查看信息说是sort（）方法类型不匹配，无法对Student类型的List进行排序，为什么会这样呢？我们来看一下API的sort方法说明：
Copier après la connexion
原来collection.sort（）方法对元素进行排序，列表中的元素都必需实现 Comparable 接口，否则不能使用 sort（）方法排序，那么Comparable 接口是什么，该如何实现呢？请往下看！
三、Comparable & Comparator简介
在上述例子可以看到Collections工具类的sort()方法不能对Student类的List集合进行排序，通过查阅API我们知道因为Student类并没有继承Comparable & Comparator接口，Student类是不可比较的，所以编译器会报错。那么Comparable & Comparator这两个接口有什么不同呢？
compareable 是默认比较规则， comparator是临时比较规则
1.Comparable接口------可比较的

实现该接口表示：这个类的实例可以比较大小，可以进行自然排序

定义了默认的比较规则

其实现类需实现compareTo()方法

comparaTo()方法返回正数表示大，负数表示小，0表示相等

2.Comparator接口-----比较工具接口

用于定义临时比较规则，而不是默认比较规则

其实现类需要实现compare()方法

compareTo()方法和compare()方法的返回值有三种：

返回0：两个对象相等

返回1：该对象大于比较的对象

返回-1：该对象小于比较的对象

那么我们给Student类加上Comparable接口和Comparator接口，规定默认规则是比较学生的id大小，临时规则是比较学生的姓名。代码如下：

注意：Comparable接口和Comparator接口后面都要加上泛型！！！

1 public class Student implements Comparable<Student>,Comparator<Student>{ 2 .......//省略一段代码 3 @Override 4     public int compare(Student arg0, Student arg1) { 5         // TODO Auto-generated method stub 6         return arg0.name.compareTo(arg1.getName()); 7     } 8     @Override 9     public int compareTo(Student arg0) {10         // TODO Auto-generated method stub11         //默认与学生id比较12         return Integer.valueOf(this.getId()).compareTo(Integer.valueOf(arg0.getId()));13     }
Copier après la connexion

再修改testSort4()方法，如下：

1 /* 2      * 对其他类型泛型的list进行排序，以，Student为例。 3      */ 4     public void testSort4(){ 5         List<Student> stus=new ArrayList<Student>(); 6         Random random=new Random(); 7         stus.add(new Student(random.nextInt(1000)+"","Mike")); 8         stus.add(new Student(random.nextInt(1000)+"","Angela")); 9         stus.add(new Student(random.nextInt(1000)+"","Lucy"));10         System.out.println("----------排序前-----------");11         for(Student s:stus){12             System.out.println(s.getId()+","+s.getName()+" ");13         }14         System.out.println();15         System.out.println("----------排序后-----------");16         Collections.sort(stus);17         for(Student s:stus){18             System.out.println(s.getId()+","+s.getName()+" ");19         }20         System.out.println("----------根据姓名排序-----------");21         Collections.sort(stus,new Student());22         for(Student s:stus){23             System.out.println(s.getId()+","+s.getName()+" ");24         }25         26     }
Copier après la connexion

Résultats en cours d'exécution :

Remarque : L'appel direct de sort (set) utilise les règles de comparaison par défaut ; l'appel de la méthode surchargée de sort (set, implémente Comparatorinterface object name) utilise des règles temporaires.

>>>>>>>>>>>>>> >>>>>> ;>>>>>>>>>>>>>>>>>>>>>

Comment comparer des classes sans règles de comparaison par défaut. Résumé des étapes :

1. Laissez la classe implémenter l'interface Comparable :

1. la classe.

2. Implémentez la méthode .compareTo(class name object name) si celle-ci est plus grande, elle renvoie une valeur positive, si elles sont égales, elle renvoie 0, et si elle est plus petite, elle renvoie une valeur négative. valeur. (Diverses classes incluent la méthode .compareTo())

3. Appelez Collections.sort (nom de l'objet) pour trier.

2. Laissez cette classe implémenter l'interface Comparator :

1. Créez une nouvelle classe et ajoutez les implémentations Comparator

2. nom de l'objet 1, nom de la classe, nom de l'objet 2), s'il est plus grand, il renvoie une valeur positive, s'ils sont égaux, il renvoie 0, s'il est plus petit, il renvoie une valeur négative.

3. Appelez la méthode Collections.sort (nom de l'objet, nom de l'objet qui implémente l'interface Comparator).

4. Résumé du Java Collection Framework

A la fin de cet article, nous avons enfin reconnu le Java Collection Framework, qui comprend le contenu suivant :

Collection interface, Interface de carte, Classe d'outils de collections, Interface comparable, Interface de comparaison

Dans Java Collection Framework (Partie 1) Découvrez l'interface Collection dans ;

Découvrez l'interface Mao dans Java Collection Framework (Partie 2) >
Dans cet article, nous avons découvert la classe d'outils Collections, l'interface Comparable et l'interface Comparator.

Je viens d'en écrire un peu. Si vous voulez en savoir plus, veuillez vous référer à l'API Java.,,