学习笔记07--Java集合框架

集合框架

• 集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

集合类体系结构

Collection 集合的概述和使用

• Collection集合概述

  • 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素

  • JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

• 创建Collection集合的对象

  • 多态的方式
  • 集体的实现类ArrayList

• Collection集合常用方法

  • boolean add(E e)：添加元素
  • boolean remove(Object o)：从集合中移除指定元素
  • void clear()：清空集合中的元素
  • boolean contains(Object o)：判断集合中是否存在指定的元素
  • boolean isEmpty()：判断集合是否为空
  • int size()：集合的长度，也就是集合中元素的个数

public static void main(String[] args) {
    //创建Collection集合的对象
    Collection<String> c = new ArrayList<String>();
    //boolean add(E e)：添加元素
    c.add("Hello");
    c.add("World");
    c.add("java");
    System.out.println(c);
    
    //boolean remove(Object o)：从集合中移除指定元素
    c.remove("java");
    System.out.println(c);
    
    //boolean contains(Object o)：判断集合中是否存在指定的元素
    System.out.println(c.contains("Hello"));
    System.out.println(c.contains("java"));
    
    //int size()：集合的长度，也就是集合中元素的个数
    System.out.println(c.size());
    
    //boolean isEmpty()：判断集合是否为空
    System.out.println(c.isEmpty());
    
    //void clear()：清空集合中的元素
    c.clear();
    System.out.println(c);
    System.out.println(c.isEmpty());
}

Collection集合的遍历

• Iterator：迭代器，集合的专用遍历方式
  • Iterator iterator()：返回此集合中元素的迭代器，通过集合的Iterator()方法得到
  • 迭代器是通过集合的Iterator()方法得到的，所以我们说它是依赖于集合而存在的
• Iterator中的常用方法
  • E next()：返回迭代中的下一个元素
  • boolean hasNext()：如果迭代具有更多元素，则返回true

public static void main(String[] args) {
    Collection<String> c =new ArrayList<String>();
    
    c.add("hello");
    c.add("world");
    
    Iterator<String> it = c.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
}

List集合的概述和使用

• List集合概述

  • 有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
  • 与Set集合不同，列表通常允许重复的元素

• List集合特点

  • 有序：存储和取出的元素顺序一致
  • 可重复：存储的元素可以重复

• List集合的特有方法

  • void add(int index,E element)：在此集合中的指定位置插入指定的元素
  • E remove(int index)：删除指定索引处的远射，返回被删除的元素
  • E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
  • E get(int index)：返回指定索引处的元素

public static void main(String[] args) {
    //创建集合对象
    List<String> list = new ArrayList<String>();
    //添加元素
    list.add("我");
    list.add("吃");
    list.add("饭");

    //void add(int index,E element)：在此集合中的指定位置插入指定的元素
    list.add(1,"想");
    //list.add(7,"想");    发生越界异常：IndexOutOfBoundsException

    //E remove(int index)：删除指定索引处的远射，返回被删除的元素
    System.out.println(list.remove(1));

    //E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
    System.out.println(list.set(0,"你"));

    //E get(int index)：返回指定索引处的元素
    System.out.println(list.get(2));
    System.out.println(list);
}

并发修改异常

• 并发修改异常：ConcurrentModificationException
• 产生原因：迭代器遍历过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际值不一致
• 解决方案：用for循环遍历，然后用集合对象做对应的操作即可

ListIterator

• ListIterator:列表迭代器
  • 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
  • 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
• ListIterator中的常用方法
  • E next()：返回迭代中的下一个元素
  • boolean hasNext()：如果迭代具有更多元素，则返回true
  • E previous()：返回列表中的上一个元素
  • boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
  • void add(E e)：将指定的元素插入列表

public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    
    list.add("Hello");
    list.add("this");
    list.add("world");
    
    ListIterator<String> lit = list.listIterator();
    //E next()：返回迭代中的下一个元素
    //boolean hasNext()：如果迭代具有更多元素，则返回true
    while (lit.hasNext()){
        String s = lit.next();
        System.out.println(s);
    }
    //E previous()：返回列表中的上一个元素
    //boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
    while (lit.hasPrevious()){
        String s = lit.previous();
        System.out.println(s);
    }
    //void add(E e)：将指定的元素插入列表
    while (lit.hasNext()){
        String s = lit.next();
        if (s.equals("this")){
            lit.add("java");
        }
    }
    System.out.println(list);
}

增强for循环

• 增强for：简化数组和Collection集合的遍历

  • 实现Iterable接口的类允许其对象成为增强型for语句的目标
  • 它是JDK5之后出现的，其内部原理是一个Iterator迭代器

• 增强for的格式

  • for(元素数据类型 变量名：数组或者Collection集合){

    ​ //在此处使用变量即可，该变量就是元素

    }

数据结构回顾

• 数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或存储效率
• 栈结构是一种数据先进后出的模型
  • 数据进入栈模型的过程称为：压/进栈
  • 数据离开栈模型的过程称为：弹/出栈
• 队列结构是一种数据先进先出的模型
  • 数据从后端进入队列模型的过程称为：入队列
  • 数据从前端离开队列模型的过程称为：出队列
• 数组结构是一种查询快，增删慢的模型
  • 可以通过索引定位查询数据
  • 查询任意数据耗时相同，查询速度快
  • 删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
  • 添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低
• 链表结构是一种查询慢，增删快的模型
  • 查询一个数据是否存在，需要从头进行查询
  • 添加一个数据，只需要将前一个结点指向该结点的地址，并将该结点指向下一个结点的地址即可

List集合子类特点

• List集合常用子类：ArrayList，LinkedList
  • ArrayList：底层数据结构是数组，查询快，增删慢
  • LinkedList：底层数据结构是链表，查询慢，增删快
• LinkedList集合的特有功能
  • public void addFirst(E e)：在该列表开头插入指定元素
  • public void addLast(E e)：在该列表末尾插入指定元素
  • public E getFirst()：返回此列表中的第一个元素
  • public E getLast()：返回此列表中的最后一个元素
  • public E removeFirst()：从此列表中删除并返回第一个元素
  • public E removeLast()：从此列表中删除并返回最后一个元素

public static void main(String[] args) {
    LinkedList<String> linkedList = new LinkedList<String>();

    linkedList.add("hello");
    linkedList.add("world");
    linkedList.add("java");
    System.out.println(linkedList);

    //public void addFirst(E e)：在该列表开头插入指定元素
    //public void addLast(E e)：在该列表末尾插入指定元素
    linkedList.addFirst("开头");
    linkedList.addLast("结尾");
    System.out.println(linkedList);

    //public E getFirst()：返回此列表中的第一个元素
    //public E getLast()：返回此列表中的最后一个元素
    System.out.println(linkedList.getFirst());
    System.out.println(linkedList.getLast());
    System.out.println(linkedList);

    //public E removeFirst()：从此列表中删除并返回第一个元素
    //public E removeLast()：从此列表中删除并返回最后一个元素
    System.out.println(linkedList.removeFirst());
    System.out.println(linkedList.removeLast());
    System.out.println(linkedList);
}

Set集合概述和特点

• Set集合特点
  • 不包含重复元素的集合
  • 没有带索引的方法，所以不能使用普通for循环遍历，只能采用迭代器和增强for循环进行遍历
  • HashSet：对集合的迭代顺序不做任何保证

public static void main(String[] args) {
    //创建集合对象
    Set<String> set = new HashSet<String>();
    //添加元素
    set.add("hello");
    set.add("world");
    set.add("java");
    //不包含重复元素
    set.add("java");
    //遍历
    for (String s:set){
        System.out.println(s);
    }
}

哈希值

• 哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
• Object类中有一个方法可以获取对象的哈希值
  • public int hashCode()：返回对象的哈希码值
• 对象的哈希值特点
  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

HashSet集合概述和特点

• HashSet集合特点
  • 底层数据结构是哈希表
  • 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
  • 没有带索引的方法，所以不能使用普通for循环遍历
  • 由于是Set集合，所以是不包含重复元素的集合

public static void main(String[] args) {
    //创建集合
    HashSet<Student> hashSet = new HashSet<Student>();
    //创建学生对象
    Student s1 = new Student("tian",18);
    Student s2 = new Student("jack",20);
    Student s3 = new Student("ming",18);
    //该学生也可以成功加入，需要在学生类中重写hashCode()和equals()方法
    Student s4 = new Student("tian",18);
    //添加元素
    hashSet.add(s1);
    hashSet.add(s2);
    hashSet.add(s3);
    hashSet.add(s4);
    //遍历
    for (Student s:hashSet){
        System.out.println(s);
    }
}

• LinkedHashSet集合概述和特点
  • 哈希表和链表实现的Set接口，具有可预测的迭代顺序
  • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
  • 由哈希表保证元素唯一，也就是说没有重复的元素

public static void main(String[] args) {
    //创建集合对象
    LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
    //添加元素
    linkedHashSet.add("hello");
    linkedHashSet.add("world");
    linkedHashSet.add("java");
    linkedHashSet.add("hello");
    //遍历集合
    for (String s:linkedHashSet){
        System.out.println(s);
    }
}

TreeSet集合概述和特点

• TreeSet集合特点
  • 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
    • TreeSet()：根据其元素的自然顺序（从小到大）进行排序
    • TreeSet(Comparator comparator)：根据指定的比较器进行排序
  • 没有带索引的方法，所以不能使用普通for循环遍历
  • 由于是Set集合，所以不包含重复的元素的集合

public static void main(String[] args) {
    //创建集合对象
    TreeSet<Integer> treeSet = new TreeSet<Integer>();
    //添加元素
    treeSet.add(10);
    treeSet.add(30);
    treeSet.add(50);
    treeSet.add(40);
    treeSet.add(20);
    //发生重复，不会添加进集合
    treeSet.add(30);
    //遍历集合
    for (Integer i:treeSet){
        System.out.println(i);
    }
}

• 自然排序Comparable的使用

  • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
  • 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

• 比较器排序Comparator的使用

  • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
  • 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

public static void main(String[] args) {
    //创建集合对象，使用Comparator进行比较，需要重写compare方法
    TreeSet<Student> treeSet = new TreeSet<Student>(new Comparator<Student>() {
        @Override
        public int compare(Student s1, Student s2) {
            //先按照年龄进行排序
            int num1 = s1.getAge() - s2.getAge();
            //如果年龄相同，则按照姓名的字母顺序排序
            int num2 = (num1 == 0)?s1.getName().compareTo(s2.getName()):num1;
            return num2;
        }
    });
    //创建学生对象
    Student s1 = new Student("tian", 21);
    Student s2 = new Student("karsa", 24);
    Student s3 = new Student("jack", 22);
    Student s4 = new Student("369", 20);
    Student s5 = new Student("rookie", 24);
    Student s6 = new Student("abin", 24);
    Student s7 = new Student("abin", 24);
    //添加到集合中
    treeSet.add(s1);
    treeSet.add(s2);
    treeSet.add(s3);
    treeSet.add(s4);
    treeSet.add(s5);
    treeSet.add(s6);
    treeSet.add(s7);
    //遍历集合
    for (Student s : treeSet) {
        System.out.println(s);
    }
}

泛型

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

泛型类

• 泛型类的定义格式
  • 格式：修饰符class类名<类型>{ }
  • 范例：public class Generic{ },此处T可以随便写为任意标识，常见的有T、E、K、V等形式的参数用于表示泛型

public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new Generic<String>();
        g1.setT("hello");
        System.out.println(g1.getT());

        Generic<Integer> g2 = new Generic<Integer>();
        g2.setT(100);
        System.out.println(g2.getT());
    }
}

• 泛型方法定义格式：
  • 格式：修饰符<类型>返回值类型方法名（类型 变量名）{}
  • 范例：public void show(T t){}

public class Generic<T> {
    public <T> void show(T t){
        System.out.println(t);
    }
}

public class GenericDemo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("张三");
        g.show(60);
        g.show(true);
        g.show(8.24);
    }
}

• 泛型接口的定义格式：
  • 格式：修饰符 interface 接口名<类型>{}
  • 范例：public interface Generic{}

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

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

类型通配符

• 为了表示各种泛型List的父类，可以使用类型通配符
  • 类型通配符：<?>
  • List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
  • 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
• 如果不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限
  • 类型通配符上限：<?extends类型>
  • List<?extends Number>：它表示的类型是Number或者其子类型
• 除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
  • 类型通配符下限：<?super类型>
  • List<?super Number>：它表示的类型是Number或者其父类

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符：<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();

        //类型通配符上限：<? extends 类型>
        //List<? extends Number> list4 = new ArrayList<Object>();上限是Number，Object 是 Number的父类超出上限
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();

        //类型通配符下限：<? super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
        //List<? super Number> list9 = new ArrayList<Integer>();下限是Number，Integer 是 Number的子类超出下限
    }
}

可变参数

• 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
  • 格式：修饰符 返回值类型 方法名（数据类型…变量名）{}
  • 范例：public static int sum(int…a){}
• 可变参数注意事项
  • 这里的变量其实是一个数组
  • 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

public class ArgsDemo {
    public static void main(String[] args) {
        System.out.println(sum(1,2,3));
        System.out.println(sum(1,2,3,4));
        System.out.println(sum(1,2,3,4,5));
        System.out.println(sum(1,2,3,4,5,6));
    }

    public static int sum(int... a){
        int sum = 0;
        for (int i:a){
            sum += i;
        }
        return sum;
    }
}

• 可变参数的使用
  • Arrays工具类中有一个静态方法：
    • public static List asList(T… a)：返回由指定数组支持的固定大小的列表
    • 返回的集合不能做增删操作，可以做修改操作
  • List接口中有一个静态方法：
    • public static List of(E… elements)：返回包含任意数量元素的不可变列表
    • 返回的集合不能做增删改操作
    • java 9才能支持该方法
  • Set接口中有一个静态方法：
    • public static Set of(E… elements)：返回一个包含任意数量元素的不可变集合
    • 在给元素的时候，不能给重复的元素
    • 返回的集合不能做增删操作，没有修改的方法
    • java 9才能支持该方法

public static void main(String[] args) {
        //public static <T> List<T> asList(T... a)：返回由指定数组支持的固定大小的列表
        List<String> list = Arrays.asList("hello","world","java");
        //list.add("this");//UnsupportedOperationException
        //list.remove("world");//UnsupportedOperationException
        //Arrays.asList不能使用添加和移除方法，因为这两个方法会改变集合的大小，而修改方法不会改变大小，是可以使用的
        list.set(1,"this");
        System.out.println(list);

        //public static <E> List<E> of(E... elements)：返回包含任意数量元素的不可变列表
/*      //List.of()这个方法需要JDK 9以上才能支持
        List<String> list1 = List.of("hello","world","java");
        list1.add("this");//UnsupportedOperationException
        list1.remove("world");//UnsupportedOperationException
        list1.set(1,"this");//UnsupportedOperationException
        System.out.println(list1);
 */
        //public static <E> Set<E> of(E... elements)：返回一个包含任意数量元素的不可变集合
/*      //Set.of()这个方法需要JDK 9以上才能支持
        Set<String> set = Set.of("hello","world","java");//不能给重复元素
        set.add("this");//UnsupportedOperationException
        set.remove("this");//UnsupportedOperationException
        System.out.println(set);
 */
    }

Map

Map集合概述

• Interface Map<K,V> K：键的类型；V：值的类型

• 将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值

• 创建Map集合的对象

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

• Map集合的基本功能

  • V put(K key,V value)：添加元素
  • V remove(Object key)：根据键删除键值对元素
  • void clear()：移除所有的键值对元素
  • boolean containsKey(Object key)：判断集合是否包含指定的键
  • boolean containsValue(Objiect value)：判断集合是否包含指定的值
  • boolean isEmpty()：判断集合是否为空
  • int size()：集合的长度，也就是集合中键值对的个数

public static void main(String[] args) {
    Map<String,String> map = new HashMap<String, String>();
    
    //V put(K key,V value)：添加元素
    map.put("TESad","jkl");
    map.put("TESmid","knight");
    map.put("TESjug","tian");
    map.put("TESsup","mark");
    System.out.println(map);
    
    //V remove(Object key)：根据键删除键值对元素
    System.out.println(map.remove("TESsup"));
    System.out.println(map);
    
    //boolean containsKey(Object key)：判断集合是否包含指定的键
    System.out.println(map.containsKey("TESad"));
    System.out.println(map.containsKey("TEStop"));
    
    //boolean containsValue(Objiect value)：判断集合是否包含指定的值
    System.out.println(map.containsValue("tian"));
    System.out.println(map.containsValue("369"));
    
    //int size()：集合的长度，也就是集合中键值对的个数
    System.out.println(map.size());
    
    //boolean isEmpty()：判断集合是否为空
    System.out.println(map.isEmpty());
    
    //void clear()：移除所有的键值对元素
    map.clear();
    System.out.println(map.isEmpty());
}

• Map集合的获取方法
  • V get(Object key)：根据键获取值
  • Set keySet()：获取所有键的集合
  • Collection values()：获取所有值的集合
  • Set<Map.Entry<K,V>>entrySet()：获取所有键值对对象的集合

public static void main(String[] args) {
    Map<String,String> map = new HashMap<String, String>();

    map.put("TESad","jkl");
    map.put("TESsup","mark");
    map.put("TESmid","knight");

    //V get(Object key)：根据键获取值
    System.out.println(map.get("TESad"));
    System.out.println(map.get("TEStop"));

    //Set<K> keySet()：获取所有键的集合
    Set<String> keySet = map.keySet();
    for (String s:keySet){
        System.out.println(s);
    }

    //Collection<V> values()：获取所有值的集合
    Collection<String> collection = map.values();
    for (String s:collection){
        System.out.println(s);
    }
}

• Map集合的遍历方式一

public static void main(String[] args) {
    Map<String, String> map = new HashMap<String, String>();

    map.put("TESad", "jkl");
    map.put("TESsup", "mark");
    map.put("TESmid", "knight");

    //获取所有键的集合，用keySet()方法实现
    Set<String> keySet = map.keySet();
    //遍历键的集合，获取到每一个键
    for (String s : keySet) {
        //根据键找到对应的值
        String s1 = map.get(s);
        System.out.println(s + "," + s1);
    }
}

• Map集合的遍历方式二

public static void main(String[] args) {
    Map<String, String> map = new HashMap<String, String>();

    map.put("TESad", "jkl");
    map.put("TESsup", "mark");
    map.put("TESmid", "knight");
    //获取所有键值对对象的集合
    Set<Map.Entry<String, String>> entrySet = map.entrySet();
    //遍历键值对对象的集合，得到每一个键值对对象
    for (Map.Entry<String, String> me : entrySet) {
        //得到每一个键值对的键和值
        String key = me.getKey();
        String value = me.getValue();
        System.out.println(key + "," + value);
    }
}

• 练习：统计字符串中每个字符串出现的个数

/*
    需求：
        键盘录入一个字符串，要求统计字符串中每个字符串出现的个数
        举例：键盘录入"aababcabcdabcde             在控制台输出：a(5)b(4)c(3)d(2)e(1)
 */
public class TreeMapTest {
    public static void main(String[] args) {
        //输入字符串
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个字符串：");
        String s = scanner.nextLine();
        //创建一个TreeMap集合
        TreeMap<Character, Integer> treeMap = new TreeMap<Character, Integer>();

        //遍历字符串，得到每一个字符
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            //拿每一个字符作为键到TreeMap集合中去找对应的值，看返回值
            Integer integer = treeMap.get(c);

            if (integer == null) {       //该集合中没有这个字符
                treeMap.put(c, 1);
            } else {                     //给这个字符对应的值加一
                treeMap.put(c, integer + 1);
            }
        }
        Set<Map.Entry<Character, Integer>> entrySet = treeMap.entrySet();
        for (Map.Entry<Character, Integer> me : entrySet) {
            Character key = me.getKey();
            Integer value = me.getValue();
            System.out.print(key + "(" + value + ")");
        }

    }
}

Collections

Collections概述和使用

• Collections类的概述
  • 是针对集合操作的工具类
• Collections类的常用方法
  • public static <T extends Comparable<?super T>> void sort(List list)： 将指定的列表按升序排序
  • public static void reverse(List<?> list)：反转指定列表中元素的顺序
  • public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表

public static void main(String[] args) {
    //创建集合对象
    List<Integer> list = new ArrayList<Integer>();
    //添加元素
    list.add(30);
    list.add(20);
    list.add(50);
    list.add(10);
    list.add(40);

    System.out.println(list);

    //public static <T extends Comparable<?super T>> void sort(List<T>  list)： 将指定的列表按升序排序
    Collections.sort(list);
    System.out.println(list);

    //public static void reverse(List<?> list)：反转指定列表中元素的顺序
    Collections.reverse(list);
    System.out.println(list);

    //public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表
    Collections.shuffle(list);
    System.out.println(list);
}

• 使用Collections.sort按照规定的顺序进行排序

/*
        需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序
        要求:按照年龄从小到大排序，年龄相同时，按照姓名字母顺序进行排序
 */
public static void main(String[] args) {
    ArrayList<Student> arrayList = new ArrayList<Student>();

    Student s1 = new Student("tian", 22);
    Student s2 = new Student("jkl", 22);
    Student s3 = new Student("369", 20);
    Student s4 = new Student("knight", 21);

    arrayList.add(s1);
    arrayList.add(s2);
    arrayList.add(s3);
    arrayList.add(s4);

    Collections.sort(arrayList, new Comparator<Student>() {
        @Override
        //按照年龄从小到大排序，年龄相同时，按照姓名字母顺序进行排序
        public int compare(Student s1, Student s2) {
            int num1 = s1.getAge() - s2.getAge();
            int num2 = (num1 == 0) ? s1.getName().compareTo(s2.getName()) : num1;
            return num2;
        }
    });
    for (Student s:arrayList){
        System.out.println(s);
    }

}