5.1 Collection（单列），是一个接口

5.1.1 Collection

5.1.1.1 概述

  • 是单列集合的顶层接口，他表示一组对象，这些对象也称为Collection的元素
  • JDK不提供此接口的任何直接实现，他提供更具体的子接口如Set和List实现

  • 创建Collection集合的对象

    • 多态的方式
    • 具体的实现类

      5.1.1.2 常用方法

  • boolean add(E,e) 添加元素

  • boolean remove(Object o) 从集合中移除指定元素
  • void chear() 清空集合中的元素
  • boolean contains(Object o) 判断集合中是否存在指定的元素
  • boolean isEmpty() 判断集合是否为空

  • int size() 集合的长度，也就是集合中元素的个数

    5.1.1.3 集合遍历

  • Iterator：迭代器，集合的专用遍历方式

    • Iterator iterator():返回此集合中的元素迭代器，通过集合的Iterator()方法得到
    • 迭代器是通过集合的Iterator()方法得到的，所以我们说它是依赖于集合而存在的
  • Iterator中常用方法
    • E next()：返回迭代中的下一个元素，通过迭代器获取元素时不能使用 集合.add() 修改集合，会抛出异常
    • boolean hasNext()：如果迭代具有更多元素，则返回true ```java import java.util.ArrayList; import java.util.Collection; import java.util.Iterator;

public class Demo { public static void main(String[] args) { Collection c = new ArrayList<>() ; c.add(“hello”); c.add(“world”); c.add(“java”); System.out.println(c);

  1.     Iterator<String> it = c.iterator();
  2.     for(int i=0;i<3;i++)
  3.         System.out.println(it.next());
  4. }

} 运行结果： [hello, world, java] hello world java

Process finished with exit code 0

  1. <a name="Uzynf"></a>
  2. ### 
  3. <a name="dNPvl"></a>
  4. ### 5.1.2 Set（不可重复）
  5. <a name="j2QvL"></a>
  6. #### 5.1.2.1 哈希值
  8. - 是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
  9. - Object类中有一个方法可以获取对象的哈希值，**_public int hashCode()_** ;
  10. - 对象的哈希值特点
  11.    - 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  12.    - 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同。
  13. <a name="Hc0f4"></a>
  14. #### 5.1.2.2 HashSet
  16. - 特点：
  17.    - 底层数据结构就是哈希表，本质就是new了一个HashMap
  18.    - 对集合的迭代顺序不做任何保证，也就是说不保证存储和取出的元素顺序一致
  19.    - 没有带索引的方法，所以不能使用普通for循环遍历
  20.    - 由于是Set集合，所以是不包含重复元素的集合
  21. - LinkedHashSet集合特点：
  22.    - 哈希表和链表实现的Set接口，具体可预测的迭代次序
  23.    - 由于链表保证元素有序，也就是说元素的存储和取出顺序是一致的
  24.    - 由哈于希表保证元素唯一，也就是没有重复的元素
  25. <a name="wg0F6"></a>
  26. #### 5.1.2.3 TreeSet
  28. - 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法。
  29.    - TreeSet()：根据其元素的自然排序进行排序，自然排序Comparable的使用：
  30.       - 存储学生对象并遍历，创建TreeSet集合使用无参构造方法。例：
  31. ```java
  32. /*
  33. 按照年龄从小到大排序，年龄相同时，按照姓名字母顺序排序
  34. */
  36. import java.util.TreeSet;
  38. public class Demo {
  39.     public static void main(String[] args) {
  40.         TreeSet<Student> ts = new TreeSet<Student>() ;
  41.         Student s1 = new Student("xishi",22);
  42.         Student s2 = new Student("wangzhaojun",25);
  43.         Student s3 = new Student("diaochan",28);
  44.         Student s4 = new Student("yangyuhuan",21);
  45.         Student s5 = new Student("ahangsannnnnn",20);
  46.         Student s6 = new Student("yhangyuhuan",20);
  47.         ts.add(s1);
  48.         ts.add(s2);
  49.         ts.add(s3);
  50.         ts.add(s4);
  51.         ts.add(s5);
  52.         ts.add(s6);
  53.         for(Student s : ts){
  54.             System.out.println(s.getName()+","+s.getAge());
  55.         }
  56.     }
  57. }
  59. ********************************************************************
  60. public class Student implements Comparable<Student>{
  61.     private String name ;
  62.     private Integer age ;
  64.     public Student() {}
  65.     public Student(String name, Integer age) {
  66.         this.name = name;
  67.         this.age = age;
  68.     }
  70.     public String getName() { return name;}
  71.     public void setName(String name) {this.name = name;}
  72.     public Integer getAge() {return age;}
  73.     public void setAge(Integer age) {this.age = age;}
  75.     @Override
  76.     public int compareTo(Student o) {
  77.         int num1 = this.age-o.age ;
  78.         int num2 = num1==0?this.name.compareTo(o.name):num1 ;
  79.         return num2 ;
  80.     }
  81. }
  83. 运行结果： 
  84. ahangsannnnnn,20
  85. yhangyuhuan,20
  86. yangyuhuan,21
  87. xishi,22
  88. wangzhaojun,25
  89. diaochan,28
  91. Process finished with exit code 0
  1.   - 结论：用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的。自然排序就是让元素所属的类实现Comparable接口，重写compareTo方法。重写方法时一定要注意排序规则必须按照要求的主要条件和次要条件来写。
  1. /*
  2. 用TreeSet结合存储多个学生信息，按照总分从高到低排，若总分一样，比语文成绩，若语文成绩一样比较名字的Unicode值，越小越靠前
  3. */
  4. import java.util.TreeSet;
  6. public class Demo {
  7.     public static void main(String[] args) {
  8.         TreeSet<Student> ts = new TreeSet<Student>() ;
  9.         Student s1 = new Student("小王",20,20) ;  //unicode值： 王 --> 29579
  10.         Student s2 = new Student("小张",20,20) ;  //unicode值： 张 --> 24352
  11.         Student s3 = new Student("小黑",50,50) ;
  12.         Student s4 = new Student("小白",90,90) ;
  13.         Student s5 = new Student("小绿",89,91) ;  //unicode值： 绿 --> 32511
  14.         Student s6 = new Student("小一",89,91) ;  //unicode值： 一 --> 19968
  16.         ts.add(s1) ;
  17.         ts.add(s2) ;
  18.         ts.add(s3) ;
  19.         ts.add(s4) ;
  20.         ts.add(s5) ;
  21.         ts.add(s6) ;
  22.         for(Student s : ts){
  23.             s.show();
  24.         }
  25.     }
  26. }
  27. ******************************************************************************
  28. public  class Student implements Comparable<Student>{
  29.     private String name ;
  30.     private int chineseScore ;
  31.     private int mathScore ;
  33.     public Student() {}
  34.     public Student(String name, int chineseScore, int mathScore) {
  35.         this.name = name;
  36.         this.chineseScore = chineseScore;
  37.         this.mathScore = mathScore;
  38.     }
  40.     public String getName() {  return name;}
  41.     public void setName(String name) {  this.name = name;}
  42.     public int getChineseScore() {return chineseScore;}
  43.     public void setChineseScore(int chineseScore) {this.chineseScore = chineseScore;}
  44.     public int getMathScore() {return mathScore;}
  45.     public void setMathScore(int mathScore) {this.mathScore = mathScore;}
  46.     public void show(){System.out.println(name+","+chineseScore+","+mathScore);}
  48.     @Override
  49.     public int compareTo(Student s) {
  50.         int cScore = this.chineseScore-s.chineseScore ;
  51.         int num = s.chineseScore+s.mathScore-this.chineseScore-this.mathScore ;
  52.         int num2 = num==0?cScore:num ;
  53.         int num3 = num2==0?this.name.compareTo(s.name):num2 ;
  54.         return num3;
  55.     }
  56. }
  57. 运行结果：
  58. 小一,89,91
  59. 小绿,89,91
  60. 小白,90,90
  61. 小黑,50,50
  62. 小张,20,20
  63. 小王,20,20
  65. Process finished with exit code 0
  • TreeSet(Comparator comparator)：根据指定的比较器进行排序，比较器排序Comparator的使用： ```java / 按照年龄从小到大排序，年龄相同时，按照姓名字母顺序排序 /

import java.util.Comparator; import java.util.TreeSet;

public class Demo { public static void main(String[] args) {

  1.     TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
  2.         @Override
  3.         public int compare(Student s1, Student s2) {
  4.             int num = s1.getAge()-s2.getAge() ;
  5.             int num2 = num==0?s1.getName().compareTo(s2.getName()):num ;
  6.             return num2;
  7.         }
  8.     }) ;
  9.     Student s1 = new Student("xishi",22);
  10.     Student s2 = new Student("wangzhaojun",25);
  11.     Student s3 = new Student("diaochan",28);
  12.     Student s4 = new Student("yangyuhuan",21);
  13.     Student s5 = new Student("ahangsannnnnn",20);
  14.     Student s6 = new Student("yhangyuhuan",20);
  15.     ts.add(s1);
  16.     ts.add(s2);
  17.     ts.add(s3);
  18.     ts.add(s4);
  19.     ts.add(s5);
  20.     ts.add(s6);
  21.     for(Student s : ts){
  22.         System.out.println(s.getName()+","+s.getAge());
  23.     }
  25. }

}

public class Student { private String name ; private Integer age ;

  1. public Student() {}
  2. public Student(String name, Integer age) {
  3.     this.name = name;
  4.     this.age = age;
  5. }
  7. public String getName() { return name;}
  8. public void setName(String name) {this.name = name;}
  9. public Integer getAge() {return age;}
  10. public void setAge(Integer age) {this.age = age;}

} 运行结果：（和上面的一样） ahangsannnnnn,20 yhangyuhuan,20 yangyuhuan,21 xishi,22 wangzhaojun,25 diaochan,28

Process finished with exit code 0

  2.       - 结论：用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的。比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compareTo()方法。
  3. - 没有带索引的方法，所以不能使用普通for循环遍历
  4. - 由于是set集合，所以不包含重复元素的集合
  6. <a name="vBQ02"></a>
  7. ### 5.1.3 List（可重复，有序集合）
  8. <a name="u0aTn"></a>
  9. #### 5.1.3.1 ArrayList<E>
  11. - 可调整大小的数组实现，底层数据结构是数组，查询快，增删慢
  12. - 构造方法和添加方法
  13.    - _**public ArrayList()**_  创建一个空白集合对象
  14.    - _**public boolean add(E e)**_  将指定元素追加到此集合的末尾
  15.    - _**public void add(int index,E element) **_ 在此集合中的指定位置插入指定元素
  16. - 常用方法：
  17.    - _**public boolean remove(Object o) **_删除指定元素，返回是否删除成功
  18.    - _**public E remove(int index) **_ 删除指定元素，返回被删除的元素
  19.    - _**public E set(int index,E element)**_  修改指定索引处的元素，返回被修改的元素
  20.    - _**public E get(int index)**_  返回指定索引处的元素
  21.    - _**public int size()  **_返回集合中元素的个数
  22. <a name="Tp5dh"></a>
  23. #### 5.1.3.2 LinkedList<E>
  25. - 底层数据结构是链表，查询慢，增删慢
  26. - 特有功能：
  27.    - _**public void addFirst(E e)  **_在该列表开肉插入指定的元素
  28.    - _**public void addLast(E e)**_  将指定的元素追加到此列表的末尾
  29.    - _**public E getFirst()**_  返回此列表中的第一个元素
  30.    - _**public E getLast() **_ 返回此列表中的最后一个元素
  31.    - _**public E removeFirst()**_  从此列表中删除并返回第一个元素
  32.    - _**public E removeLast() **_ 从此列表中删除并返回最后一个元素
  33. <a name="LV3DI"></a>
  34. #### 5.1.3.3 ListIterator<E>
  36. - 列表迭代器
  37.    - 通过List集合的ListIterator()方法得到，所以说它是List结合特有的迭代器
  38.    - 用于允许程序员沿任何一方向遍历列表迭代器，在迭代期间修改列表，并获得列表中迭代器的当前位置
  39. - 常用方法
  40.    - _**E next() **_ 返回迭代中下一个元素
  41.    - _**boolean hasNext() **_ 如果迭代具有更多元素，则返回true
  42.    - _**E previous()**_  返回列表中的上一个元素
  43.    - _**boolean hasPrevious() **_ 如果此列表迭代器在相反方法遍历列表时具有更多元素，则返回true
  44.    - _**void add(E e)**_  将指定的元素插入列表
  45. <a name="bW63n"></a>
  46. #### 5.1.3.4 增强for循环
  48. - 简化数组和Collection集合的遍历
  49. ```java
  50. public class Demo {
  51.     public static void main(String[] args) {
  52.         Collection<String> c = new ArrayList<>() ;
  53.         c.add("hello");
  54.         c.add("world");
  55.         c.add("java");
  56.         System.out.println(c);
  58.         for(String s : c)
  59.             System.out.println(s);
  60.     }
  61. }
  62. 运行结果：
  63. [hello, world, java]
  64. hello
  65. world
  66. java
  68. Process finished with exit code 0

5.2 Collections 概述和使用

  • 是针对集合操作的工具类
  • 常用方法：
    • public static> void sort(List list) （有重载）将指定的列表升序排序
    • public static void reverse(List<?> list) 反转指定列表中的元素排序
    • public static void shuffle(List<?> list) 使用默认的随机源随机排列指定的列表 ```java import java.util.*;

public class Demo { public static void main(String[] args) {

  1.     List<Integer> list = new ArrayList<>() ;
  2.     list.add(10) ;
  3.     list.add(30) ;
  4.     list.add(90) ;
  5.     list.add(80) ;
  6.     list.add(50) ;
  7.     list.add(20) ;
  8.     Collections.sort(list);
  9.     System.out.println(list);
  11.     Collections.reverse(list) ;
  12.     System.out.println(list);
  14.     Collections.shuffle(list) ;
  15.     System.out.println(list);
  16. }

} 运行结果： [10, 20, 30, 50, 80, 90] [90, 80, 50, 30, 20, 10] [50, 30, 90, 20, 10, 80]

Process finished with exit code 0

  1. ```java
  2. /*
  3. 例子：ArrayList存储学生对象并排序
  4. 需求：使用Collections对ArrayList进行排序；按照年龄从小到大，年龄相同时，按照姓名字母进行排序
  5. */
  6. import java.util.*;
  8. public class Demo {
  9.     public static void main(String[] args) {
  10.         List<Student> arr = new ArrayList<>() ;
  11.         Student s1 = new Student("zhangsan",30) ;
  12.         Student s2 = new Student("lisi",35) ;
  13.         Student s3 = new Student("wangwu",33) ;
  14.         Student s4 = new Student("liuliu",33) ;
  16.         arr.add(s1);
  17.         arr.add(s2);
  18.         arr.add(s3);
  19.         arr.add(s4);
  21.         Collections.sort(arr, new Comparator<Student>() {
  22.             @Override
  23.             public int compare(Student s1, Student s2) {
  24.                 int num1 = s1.getAge()-s2.getAge() ;
  25.                 int num2 =num1==0?s1.getName().compareTo(s2.getName()):num1 ;
  26.                 return num2 ;
  27.             }
  28.         });
  29.         for(Student s:arr){
  30.             System.out.println(s.getName()+","+s.getAge());
  31.         }
  32.     }
  33. }
  34. *****************************************************************************
  35. public  class Student {
  36.     private String name ;
  37.     private Integer age ;
  39.     public Student() {}
  40.     public Student(String name, Integer age) {
  41.         this.name = name;
  42.         this.age = age;
  43.     }
  45.     public String getName() { return name;}
  46.     public void setName(String name) {this.name = name;}
  47.     public Integer getAge() {return age;}
  48.     public void setAge(Integer age) {this.age = age;}
  50. }
  51. 运行结果：
  52. zhangsan,30
  53. liuliu,33
  54. wangwu,33
  55. lisi,35
  57. Process finished with exit code 0

5.3 Map集合概述（双列）

  • Interface Map K：键的类型，V：值的类型
  • 将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值。

  • 基本方法：

    • V put(K key,value) 添加元素
    • V remove(Object key) 根据键删除键值对元素
    • void clear() 清空Map集合
    • boolean containsKey(Object key) 判断集合是否包含指定的键
    • boolean containsValue(Object Value) 判断集合是否包含指定的值
    • boolean isEmpty() 判断集合是否为空
    • int size() 集合的长度，也就是集合中键值对的个数
      1. import java.util.* ;
      2. public class Demo {
      3. public static void main(String[] args) {
      4.    Map<String,String> map = new HashMap<>() ;
      5.    map.put("001","111") ;
      6.    map.put("002","222");
      7.    map.put("003","333");
      8.    map.put("004","444");
      9. //        map.remove("003");
      10.    map.clear();
      11.    System.out.println(map.isEmpty());
      12.    System.out.println(map.size());
      13. //        System.out.println(map.containsValue("003"));
      14. //        System.out.println(map.containskey("003"));
      15.    System.out.println(map);
      16. }
      17. }

  • 获取方法：

    • V get(Object key) 根据键获取
    • Set keySet() 获取所有键的集合
    • Collection values() 获取所有值的集合

    • Set> entrySet() 获取所有键值对对象集合；用getKey()得到键，用getValue()得到值。 ```java import java.util.* ; public class Demo { public static void main(String[] args) {

      Map map = new HashMap() ; map.put(“001”,”111”) ; map.put(“002”,”222”); map.put(“003”,”333”); map.put(“004”,”444”);

      System.out.println(map.get(“0011”)); System.out.println(map.get(“001”)); System.out.println(“————-“); Collection values = map.values(); for(String i : values){

      1.    System.out.print(i+"  ");

      } System.out.println(); Set keySet = map.keySet() ; for(String i : keySet){

      1.    System.out.print(i+"  ");

      } System.out.println(); System.out.println(“————-“); Set> entrySet = map.entrySet() ; for(Map.Entry me : entrySet){

      1.    System.out.println(me.getKey()+","+me.getValue());

      }

      } } 运行结果： null 111

111 222 333 444

001 002 003 004

001,111 002,222 003,333 004,444

Process finished with exit code 0

  2. - 例子：
  3. ```java
  4. import java.util.* ;
  5. public class Demo {
  6.     public static void main(String[] args) {
  8.         HashMap<String,Student> map = new HashMap<String,Student>() ;
  9.         Student s1 = new Student("111",66,33) ;
  10.         Student s2 = new Student("222",67,34) ;
  11.         Student s3 = new Student("333",68,35) ;
  13.         map.put("001",s1) ;
  14.         map.put("002",s2);
  15.         map.put("003",s3);
  17.         Set<String> setKey = map.keySet() ;
  18.         for(String key : setKey){
  19.             System.out.print(key+",");
  20.             map.get(key).show();
  21.         }
  22.         System.out.println("----------------");
  24.         Set<Map.Entry<String,Student>> entrySet = map.entrySet() ;
  25.         for(Map.Entry<String,Student> me : entrySet){
  26.             System.out.print(me.getKey()+",");
  27.             me.getValue().show();
  28.         }
  29.     }
  30. }
  31. ***********************************************************************************
  32. public  class Student {
  33.     private String name ;
  34.     private int chineseScore ;
  35.     private int mathScore ;
  37.     public Student() {}
  38.     public Student(String name, int chineseScore, int mathScore) {
  39.         this.name = name;
  40.         this.chineseScore = chineseScore;
  41.         this.mathScore = mathScore;
  42.     }
  44.     public String getName() { return name; }
  45.     public void setName(String name) { this.name = name; }
  46.     public int getChineseScore() { return chineseScore; }
  47.     public void setChineseScore(int chineseScore) { this.chineseScore = chineseScore; }
  48.     public int getMathScore() { return mathScore; }
  49.     public void setMathScore(int mathScore) { this.mathScore = mathScore; }
  51.     public void show(){
  52.         System.out.println(name+","+chineseScore+","+mathScore);
  53.     }
  54. }
  55. 运行结果：
  56. 002,222,67,34
  57. 003,333,68,35
  58. ----------------
  59. 001,111,66,33
  60. 002,222,67,34
  61. 003,333,68,35
  63. Process finished with exit code 0
  1. import java.util.* ;
  2. public class Demo {
  3.     public static void main(String[] args) {
  5.         HashMap<Student,String> map = new HashMap<Student,String>() ;
  6.         Student s1 = new Student("111",66,33) ;
  7.         Student s2 = new Student("222",67,34) ;
  8.         Student s3 = new Student("333",68,35) ;
  9.         Student s4 = new Student("333",68,35) ;
  11.         map.put(s1,"111") ;
  12.         map.put(s2,"222") ;
  13.         map.put(s3,"333") ;
  14.         map.put(s4,"444") ;
  16.         Set<Student> s = map.keySet() ;
  17.         for(Student ss : s){
  18.             System.out.println(ss.getName()+","+ss.getChineseScore()+","+ss.getMathScore()+"-->"+map.get(ss));
  19.         }
  21.     }
  22. }
  23. ***********************************************************************************
  24. import java.util.Objects;
  26. public  class Student {
  27.     private String name ;
  28.     private int chineseScore ;
  29.     private int mathScore ;
  31.     public Student() {}
  32.     public Student(String name, int chineseScore, int mathScore) {
  33.         this.name = name;
  34.         this.chineseScore = chineseScore;
  35.         this.mathScore = mathScore;
  36.     }
  38.     public String getName() { return name; }
  39.     public void setName(String name) { this.name = name; }
  40.     public int getChineseScore() { return chineseScore; }
  41.     public void setChineseScore(int chineseScore) { this.chineseScore = chineseScore; }
  42.     public int getMathScore() { return mathScore; }
  43.     public void setMathScore(int mathScore) { this.mathScore = mathScore; }
  45.     public void show(){
  46.         System.out.println(name+","+chineseScore+","+mathScore);
  47.     }
  49.     //重写后比的是对象里面的属性值，不然比的是地址值，就会出现两个 333,68,35
  50.     @Override
  51.     public boolean equals(Object o) {
  52.         if (this == o) return true;
  53.         if (o == null || getClass() != o.getClass()) return false;
  54.         Student student = (Student) o;
  55.         return chineseScore == student.chineseScore && mathScore == student.mathScore && Objects.equals(name, student.name);
  56.     }
  58.     @Override
  59.     public int hashCode() {
  60.         return Objects.hash(name, chineseScore, mathScore);
  61.     }
  62. }
  64. 运行结果：
  65. 111,66,33-->111
  66. 333,68,35-->444
  67. 222,67,34-->222
  69. Process finished with exit code 0
  1. /* ArrayList嵌套HashMap */
  2. import java.util.* ;
  3. public class Demo {
  4.     public static void main(String[] args) {
  5.         ArrayList<HashMap<String,String>> ah =new ArrayList<>();
  6.         HashMap<String,String> hm1 = new HashMap<String,String>() ;
  7.         HashMap<String,String> hm2 = new HashMap<String,String>() ;
  8.         HashMap<String,String> hm3 = new HashMap<String,String>() ;
  10.         hm1.put("001","111");
  11.         hm2.put("002","222");
  12.         hm3.put("003","333");
  14.         ah.add(hm1);
  15.         ah.add(hm2);
  16.         ah.add(hm3);
  17.         for(HashMap<String,String> hm:ah){
  18.             Set<String> setKey = hm.keySet() ;
  19.             for (String key:setKey){
  20.                 System.out.println(key+","+hm.get(key));
  21.             }
  22.         }
  23.     }
  24. }
  1. /* HashMap嵌套ArrayList */
  2. import java.util.* ;
  3. public class Demo {
  4.     public static void main(String[] args) {
  5.         HashMap<String,ArrayList<String>> hashMap = new HashMap<String,ArrayList<String>>() ;
  6.         ArrayList<String> array1 = new ArrayList<String>() ;
  7.         ArrayList<String> array2 = new ArrayList<String>() ;
  8.         ArrayList<String> array3 = new ArrayList<String>() ;
  9.         array1.add("11");
  10.         array1.add("111");
  11.         array2.add("22");
  12.         array2.add("222");
  13.         array3.add("33");
  14.         array3.add("333");
  15.         hashMap.put("001",array1);
  16.         hashMap.put("002",array2);
  17.         hashMap.put("003",array3);
  19.         Set<String> setKey = hashMap.keySet() ;
  20.         for(String key : setKey){
  21.             ArrayList<String> list = hashMap.get(key) ;
  22.             System.out.print(key);
  23.             for(String s :list){
  24.                 System.out.print(" "+s);
  25.             }
  26.             System.out.println();
  27.         }
  28.     }
  29. }
  30. 运行结果：
  31. 001 11 111
  32. 002 22 222
  33. 003 33 333
  1. /* 统计字符串中每个字符出现的次数 */
  2. import java.util.* ;
  3. public class Demo {
  4.     public static void main(String[] args) {
  5.         Scanner sc  = new Scanner(System.in) ;
  6.         String line = sc.nextLine() ;
  7.         TreeMap<Character,Integer> tm = new TreeMap<>() ;
  9.         for(int i=0;i<line.length();i++){
  10.             char key  = line.charAt(i) ; //读取对应的索引字符
  11.             Integer value = tm.get(key) ; //把字符作为键，来获取值
  12.             if(value == null){
  13.                 tm.put(key,1) ; //如果值为空就是该字符没有在集合中出现过，创建一个键值对
  14.             }else {
  15.                 value++ ;
  16.                 tm.put(key,value);
  17.             }
  18.         }
  19.         StringBuilder sb = new StringBuilder();
  20.         Set<Character> setKey = tm.keySet() ;
  21.         for(Character key : setKey){
  22.             sb.append(key).append("-->"+tm.get(key)+"\n") ;
  23.         }
  24.         System.out.println(sb.toString());
  26.     }
  27. }
  28. 运行结果：
  29. ;-->1
  30. a-->4
  31. d-->1
  32. f-->1
  33. g-->4
  34. h-->1
  35. i-->1
  36. j-->1
  37. l-->1
  38. s-->1
  41. Process finished with exit code 0

5.4 泛型

  • 概述：是JDK5中引入的特性，他提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，他的本质是参数化类型，也就是所操作的数据类型被指定为一个参数。提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾明思义，就是 将 类型由原来的具体的类型参数化，然后在使用/调用是传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。
  • 格式：
    • <类型>：指定一种类型的格式。这里的类型可以看成是形参。
    • <类型1，类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参。
    • 将来具体调用的时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型。
  • 好处：把运行时期的问题提前到了编译期间；避免了强制类型转换。

  • 泛型类：格式：修饰符 class 类名<类型>{}
    ```java public class Demo { public static void main(String[] args) {

    1.   Generic<String> name = new Generic<>() ;
    2.   name.setT("小红");
    3.   Generic<Integer> age = new Generic<>() ;
    4.   age.setT(99);
    6.   System.out.println(name.getT()+","+age.getT());

    } }

public class Generic { private T t ;

  1. public T getT() { return t; }
  2. public void setT(T t) { this.t = t; }

} 运行结果： 小红,99

Process finished with exit code 0

  2. - 泛型方法：格式：修饰符<类型> 返回值类型 方法名(类型 变量名)
  3. ```java
  4. public class Demo {
  5.     public static void main(String[] args) {
  6.         Generic name = new Generic() ;
  7.         name.show("sss");
  8.         name.show(666);
  9.     }
  10. }
  11. ***********************************************************************************
  12. public class Generic {
  13.     public <T> void show(T t){
  14.         System.out.println(t);
  15.     }
  16. }
  17. 运行结果：
  18. sss
  19. 666
  21. Process finished with exit code 0
  • 泛型接口：格式：修饰符 interface 接口名<类型> ```java public class Demo { public static void main(String[] args) {
    1.   Generic<String> name = new GenericImpl<String>() ;
    2.   name.show("sss");
    3.   Generic<Integer> age = new GenericImpl<>();
    4.   age.show(666);
    } }

public interface Generic { void show(T t) ; }

public class GenericImpl implements Generic { @Override public void show(T t) { System.out.println(t); } }

  2. - 类型通配符：
  3.    - 为了表示各种泛型List的父类，可以使用类型通配符 <?>
  4.       - List<?>:表示元素类型未知的List，它的元素可以匹配任何的类型。
  5.       - 这种通配符的List仅表示他是各种泛型的父类，并不能把元素添加到其中。
  6. ```java
  7. import java.util.* ;
  8. public class Demo {
  9.     public static void main(String[] args) {
  10.         List<?> list1 = new ArrayList<Object>() ;
  11.         List<?> list2 = new ArrayList<Number>() ;
  12.         List<?> list3 = new ArrayList<String>() ;
  13.     }
  14. }
  • 如果不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型LIst的父类，可以使用类型通配符的上限。
    • 类型通配符上限：<? extend 类型>
    • List<? extends Number> : 表示的类型是Number或者其子类型
  • 除了可以指定上限还可以指定下限，
    • 类型通配符下限 <? super 类型>
    • List<? super Number>：表示的类型是Number或者其父类
  • 可变参数（可变参数又称个数可变，用作方法的形参出现，那么方法参数个数就是可变的了）
    • 格式：修饰符 返回值类型 方法名(数据类型… 变量名)
    • 这里的变量是一个数组。如果一个方法有多个参数，包含可变参数，可变参数要放在最后面
      1. public class Demo {
      2. public static void main(String[] args) {
      3.    System.out.println(sum(10,20)); //30
      4.    System.out.println(sum(10,20,30)); //60
      5.    System.out.println(sum(10,20,30,40));  //100
      6.    System.out.println(sum(10,20,30,40,50)); //150
      7.    System.out.println(sum(10,20,30,40,50,60)); //210
      8.    System.out.println(sum(10,20,30,40,50,60,70)); //280
      9. }
      10. public static int sum(int... a){
      11.    int sum=0 ;
      12.    for(int i : a){
      13.        sum+=i ;
      14.    }
      15.    return sum ;
      16. }
      17. public static int sum(int a,int b,int c){
      18.    return a+b+c ;
      19. }
      20. public static int sum(int a,int b,int c,int d){
      21.    return a+b+c+d ;
      22. }
      23. }