Java集合 P511-P562

最新推荐文章于 2023-02-21 12:25:49 发布

HHU.项亮亮

最新推荐文章于 2023-02-21 12:25:49 发布

阅读量107

点赞数 1

分类专栏：学习笔记 java SE

本文链接：https://blog.csdn.net/XLL_123456/article/details/118325747

版权

学习笔记同时被 2 个专栏收录

19 篇文章 0 订阅

订阅专栏

java SE

18 篇文章 0 订阅

订阅专栏

文章目录

11.1 Java集合框架概述
11.2 Collection接口方法
11.3 Iterator迭代器接口
11.4 Collection子接口之一： List接口
11.5 Collection子接口之二:Set接口
11.6 Map接口
11.7 Collections工具类

11.1 Java集合框架概述

一.概述

集合、数组都是对多个数据（对象）进行存储操作的结构，简称Java容器
数组存储数据存在一些弊端，因此使用更高级的Java集合。Java集合就像是一种容器，可以动态地把多个对象的引用放入容器中。
数组在存储多个数据方面的特点：
- 1.一旦初始化以后，其长度就确定了。
- 2.数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
数组在存储多个数据方面的缺点：
- 1.一旦初始化以后，其长度就不可修改。
- 2.数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
- 3.获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。
- 4.数据存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

二.Java集合可以分为Collection和Map两种体系（集合框架）

Collection接口：单列集合，用来存储一个一个的对象。
- List接口：存储有序的、可重复的数据。 ------“动态”数组
  - 主要实现类：ArrayList、LinkedList、Vector
- Set接口：存储无序的、不可重复的数据。 ------高中讲的“集合”：无序性、确定性、互异性。
  - 主要实现类：HashSet、LinkedHashSet、TreeSet
Map接口：双列集合，用来存储一对“key-value一对”的数据。 ------高中函数：y=f(x)
- 主要实现类：HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

11.2 Collection接口方法

三.Collection接口中的方法的使用

    @Test
    public  void test1(){
        Collection coll =new ArrayList();
        //1.add(Object e)：将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());

        //2.size()：获取添加的元素的个数
        System.out.println(coll.size());//6

        //3.addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中。
        Collection coll1=new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);

        System.out.println(coll.size());//6
        System.out.println(coll);

        //4.clear：清空集合元素
        coll.clear();

        //5.isEmpty()：判断当前集合是否为空
        System.out.println(coll.isEmpty());//false

    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        Person p = new Person("Jerry", 20);
        coll.add(p);

        //6.contains(Object obj)：判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()。
        boolean contains = coll.contains(123);
        System.out.println(contains);

        System.out.println(coll.contains(new String("Tom")));//true
        System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("Jerry", 20)));//false--->true

        //7.containsAll(collection coll1)：判断形参coll1中的所有元素是都都存在于当前集合中
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(coll.containsAll(coll1));
    }

 @Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //8.remove(Object obj)：从当前集合移除obj元素
        coll.remove(123);
        System.out.println(coll);

        //9.removeAll(Collection coll1)：从当前集合中移除coll1中所有元素。
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);
        System.out.println(coll);

        //10.retainAll(Collection coll1)：交集：获取当前集合和和coll1集合的交集，并返回给当前集合。
        Collection coll2 = Arrays.asList("Tom");
        coll.retainAll(coll2);
        System.out.println(coll);

        //11.equals(Object obj)
    }

@Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //12.hashCode()：返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //13.集合--->数组：toArray()
        Object[] arr = coll.toArray();
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        //14.拓展：数组--->集合：调用Arrays类的静态方法asList()
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list);

11.3 Iterator迭代器接口

        //15.iterator()：返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest。java中测试。
/**
 * 集合元素的遍历操作，使用迭代器Iterator接口
 * 内部的方法：hasNext() 和 next()
 * 
 */
public class IteratorTest {
    @Test
    public void test(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();
//        //方式一：不推荐
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        //报异常：NoSuchElementException
//        System.out.println(iterator.next());
//        //方式二：不推荐
//        for(int i=0;i<coll.size();i++){
//            System.out.println(iterator.next());
//        }
        //方式三：推荐
        while(iterator.hasNext()){
            System.out.println(iterator.next());  
        }
    }

    //测试Iterator中的remove()
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();
        
        //删除集合中的"Tom"
        while(iterator.hasNext()){
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();
            }
        }
        
        //遍历集合
        Iterator iterator1 = coll.iterator();
        while(iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
    }
}

/**
 * jdk 5.0 新增了foreach循环，用于遍历集合、数组
 */
public class ForTest {
    @Test
    public void test(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //for(集合元素的类型 局部变量 ：集合对象)
        //内部任然调用了迭代器
        for (Object obj:coll){
            System.out.println(obj);
        }
        
        int[] arr = new int[]{1, 2, 3, 4, 5,6};
        //for(数组元素的类型 局部变量：数组对象)
        for(int obj:arr){
            System.out.println(obj);
        }
    }
}

11.4 Collection子接口之一： List接口

一.面试题：ArrayList、LinkedList、Vector三者的异同点？

同：

三个类都是实现了List接口，存储数据的特点相同：存储有序的，可重复的数据

不同：

ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] - elementData存储。
LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储。
Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储。

二. ArrayList的源码分析：

/**
 * 1.面试题：ArrayList、LinkedList、Vector三者的异同点？
 *   同：三个类都是实现了List接口，存储数据的特点相同：存储有序的，可重复的数据
 *   不同：ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储。
 *        LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储。
 *        Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储。
 *
 *
 * 2.ArrayList的源码分析：
 * 2.1 jdk 7 情况下：
 * ArrayList list = new ArrayList(); //底层创建了长度是10的Object[]数组elementData
 * list.add(123); //elementData[0]=new Integer(123);
 * ...
 * list.add(11); //如果此次的添加导致底层elementData数组容量不够，则扩容。
 *                 默认情况下， 扩容为原来的容量的1.5倍，同时需要将原有数组
 *                 中的数据复制到新的数组中。
 * 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(nt capacity)
 *
 * 2.2 jdk 8 中 ArrayList 的变化：
 * ArrayList list = new ArrayList(); //底层Object[] elementData初始化为{}，
 *                                     并没有创建长度为10的数组；
 * list.add(123); //第一次调用add()时，底层才创建长度为10的数组，
 *                  并将数组123添加到elementData中；
 * ...
 * 后续的添加和扩容操作与jdk 7 无异。
 * 
 * 2.3小结：jdk 7 中的ArrayList的对象的创建类似于单例的饿汉式，
 *         jdk 8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省了内存。
 */

三. LinkedList的源码分析：

/**
 * 3.LinkedList的源码分析：
 * LinkedList list = new LinkedList(); //内部声明了 Node 类型的 first 和 last 属性，默认值为 null；
 * list.add(123); //将123封装到 Node 中，创建了 Node 对象。
 *
 * 其中，Node定义为：体现了 LinkedList 的双向链表的说法
 *     private static class Node<E> {
 *         E item;
 *         Node<E> next;
 *         Node<E> prev;
 *
 *         Node(Node<E> prev, E element, Node<E> next) {
 *             this.item = element;
 *             this.next = next;
 *             this.prev = prev;
 *         }
 *     }
 */

四. vector的源码分析：（用的较少）
略。
jdk 7 和jdk 8 中通过Vector()构造器创建对象时，底层都创建了长度为10的数组，在扩容方面，默认扩容为原来的数组长度的2倍。

五.List接口中的常用方法

public class ListTest {
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);

        System.out.println(list);

        //1.void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);

        //2.boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(5,list1);
        System.out.println(list.size());//6+3=9
        System.out.println(list);

        //3.Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));//123
    }
    @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);

        //4.int indexOf(Object obj):返回obj在集合中首次出现的位置
        int index = list.indexOf(456);
        System.out.println(index);//1

        //5.int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
        int lastindex = list.lastIndexOf(456);
        System.out.println(lastindex);//4

        //6.Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj);
        System.out.println(list);

        //7.Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);

        //8.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex 位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
        System.out.println(list);
    }
}

总结：常用方法

/**
 * 总结：常用方法
 * 增：add(Object obj)
 * 删:remove(int index) / remove(Object obj)
 * 改：set(int index, Object ele)
 * 查：get(int index)
 * 插：add(int index,Object ele)
 * 长度：size()
 * 遍历：①Iterator迭代器方式 ②增强for循环 ③普通的循环
 */

@Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        //遍历的三种方式：

        //方式一：Iterator迭代器方式
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //方式二：增强for循环
        for (Object obj:list) {
            System.out.println(obj);
        }

        //方式三：普通for循环
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }

一个小的笔试题：

 /*
    区分list中remove(int index)和remove(Object obj)
     */
    @Test
    public void testListRemove() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);//
        }

        private static void updateList(List list) {
            //list.remove(2);
            list.remove(new Integer(2));
        }

11.5 Collection子接口之二:Set接口

/**
 *set接口：存储无序的、不可重复的数据
 *HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值；
 * ---LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
 *                   优点：对于比较频繁的遍历操作，LinkedHashSet的效率高于HashSet。
 *TreeSet：可以按照添加对象的指定属性，进行排序。
 *
 * 1.Set接口中没有额外定义新的方法，使用的都是Collection中声明的方法。
 *
 * 2.要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
 *   要求：重写的hashCode()和equals()尽可能保持一致：相等的对象必须具有相等的散列码。
 */

/**
 * 一：set接口：存储无序的、不可重复的数据
 * 以HashSet为例说明：
 * 1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
 *
 * 2.不可重复性：保证添加的元素按照equals()判断时，不能返回true，即：相同的元素只能添加一个。
 *
 *二.添加元素的过程：
 * 以HashSet为例说明：
 * 我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组
 * 中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：
 *   如果此位置上没有其他元素，则元素a添加成功；--->情况1
 *   如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
 *     如果hash值不相同，则元素a添加成功。--->情况2
 *     如果hash值相同，进而需要调用元素a所在类的equals()方法：
 *       equals()返回true，元素a添加失败
 *       equals()返回false，元素a添加成功 --->情况3
 *
 * 对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上的数据以链表的方式存储。
 * jdk 7：元素a放在数组中，指向原来的元素。
 * jdk 8：原来的元素放在数组中，指向元素a。
 * 总结：七上八下
 *
 *HashSet底层：数组+链表的结构。
 */
public class SetTest {
@Test
    public void test1(){
    Set set = new HashSet();
    set.add(456);
    set.add(123);
    set.add("AA");
    set.add("CC");
    set.add(new Person("Tom",12));
    set.add(129);

    Iterator iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}
}

    //LinkedHashSet的使用
    //LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据。
    //优点：对于比较频繁的遍历操作，LinkedHashSet的效率高于HashSet。
    @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new Person("Tom",12));
        set.add(new Person("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

public class TreeSetTest {
    /*
    1.向TreeSet中添加的数据，要求是相同类的对象。
    2.两种排序方式：自然排序（实现Comparable接口）和定制排序
    3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals().
    4.定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals().
     */
    @Test
    public void test1(){
        TreeSet set = new TreeSet();
        //失败：不能添加不同类的对象
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add(new Person("Tom",12));

        //举例一：
//        set.add(34);
//        set.add(-34);
//        set.add(43);
//        set.add(11);
//        set.add(8);

        set.add(new Person("Tom",12));
        set.add(new Person("Jerry",32));
        set.add(new Person("Jim",2));
        set.add(new Person("Mike",65));
        set.add(new Person("Jack",33));
        set.add(new Person("Jack",56));

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void test2(){
        Comparator com =new Comparator() {
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Person && o2 instanceof Person){
                    Person p1=(Person) o1;
                    Person p2=(Person) o2;
                    return Integer.compare(p1.getAge(),p2.getAge());

                }else{
                    throw new RuntimeException("输入的类型不匹配");
                }
            }
        };
        TreeSet set = new TreeSet(com);

        set.add(new Person("Tom",12));
        set.add(new Person("Jerry",32));
        set.add(new Person("Jim",2));
        set.add(new Person("Mike",65));
        set.add(new Person("Jack",33));
        set.add(new Person("Jack",56));

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

11.6 Map接口

在这里插入图片描述

/**
 * 一.Map的实现类结构：
 *   /----Map:双列数据，存储key-value对的数据  ---类似于高中的函数；y=f(x)
 *         /----HashMap:作为Map的主要实现类；线程不安全的，效率高；可以存储null的key和value的
 *                /----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
 *                              原因：在原有的HashMap底层结构的基础上，添加了一对指针，指向前一个和后一个元素。
 *                              对于频繁的遍历操作，此类执行效率高于HashMap。
 *         /----TreeMap:保证按照添加的key-vale对进行排序，实现排序遍历。此时考虑key的自然排序和定制排序。
 *                      底层使用红黑树。
 *         /----Hashtable:作为Map的古老实现类；线程安全的，效率低；不能存储null的key和value的
 *                /----Properties:常用来处理配置文件。key和value都是String类型。
 *
 *          HashMap底层：数组+链表 （jdk -7及之前）
 *                      数组+链表+红黑树（jdk 8）
 *面试题（高频）
 * 1.HashMap的底层实现原理？
 * 2.HashMap和Hashtable的异同？
 * 3.CurrentHashMap与Hashtable的异同？（暂时不讲）
 *
 * 二.Map结构的理解：
 * Map中的key：无序的、不可重复的，使用Set存储所有的key   --->key所在的类要重写equals()和hashCode()  (以HashMap为例)
 * Map中的Value：无序的、可重复的，使用Collection存储所有的Value  --->value所在的类要重写equals()
 * 一个键值对：key-value构成了一个Entry对象。
 * Map中的entry：无序的、不可重复的，使用Set存储所有的entry。
 *
 *三.HashMap的底层实现原理？ 以jdk7为例说明：
 * HashMap map=new HashMap()：
 * 在实例化以后，底层创建了长度是16的一维数组Entry[] table。
 * ...可能已经执行过多次put...
 * map.put(key1,value1)：
 * 首先。调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到Entry数组中的存放位置。
 * 如果此位置上的数据为空，此时的key1-value1添加成功。----情况1
 * 如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在))，比较key1和已经存在的一个或多个数据的哈希值：
 *      如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
 *      如果key1的哈希值与已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals()方法，比较：
 *            如果equals()返回false：此时key1-value1添加成功。----情况3
 *            如果equals()返回true：使用value1替换value2。
 * 补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
 *
 * 在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空时)，扩容。
 * 默认的扩容方式，扩容为原来容量的2倍，并将原来的数据复制过来。
 *
 * jdk 8 相较于jdk 7在底层实现方面的不同：
 * 1.new HashMap()：底层没有创建一个长度为16的数组
 * 2.jdk 8底层的数组是：Node[]，而非Entry[]
 * 3.首次调用put()方法时，底层创建长度为16的数组
 * 4.jdk 7底层结构只有：数组＋链表。jdk 8中底层结构：数组+链表+红黑树。
 *   当数组中的某一个索引位置上的元素以链表形式存在的数据个数>8，且当前数据的长度>64时，
 *   此时此索引位置上的所有数据改为使用红黑树存储。
 *
 *   DEFAULT_INITIAL_CAPACITY : HashMap的默认容量：16
 *   DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
 *   threshold：扩容的临界值，=容量*填充因子：16*0.75=12
 *   TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8
 *   MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量：64
 *   
 * 四.LinkedHashMap的底层实现原理（了解）
 */

* 五.Map中定义的方法：
 *  添加、删除、修改操作：
 *  Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
 *  void putAll(Map m):将m中的所有key-value对存放到当前map中
 *  Object remove(Object key)：移除指定key的key-value对，并返回value
 *  void clear()：清空当前map中的所有数据
 *  元素查询的操作：
 *  Object get(Object key)：获取指定key对应的value
 *  boolean containsKey(Object key)：是否包含指定的key
 *  boolean containsValue(Object value)：是否包含指定的value
 *  int size()：返回map中key-value对的个数
 *  boolean isEmpty()：判断当前map是否为空
 *  boolean equals(Object obj)：判断当前map和参数对象obj是否相等
 *  元视图操作的方法：
 *  Set keySet()：返回所有key构成的Set集合
 *  Collection values()：返回所有value构成的Collection集合
 * Set entrySet()：返回所有key-value对构成的Set集合
 *
 * 总结：常数方法：
 * 添加：put(Object key,Object value)
 * 删除：remove(Object key)
 * 修改：put(Object key,Object value)
 * 查询：get(Object key)
 * 长度：size()
 * 遍历：keySet() / values() / entrySet()
 *
 * @author XiangLiangliang
 * @create 2021-07-02 10:30
 */
public class MapTest {
    /*
     *  元视图操作的方法：
     *  Set keySet()：返回所有key构成的Set集合
     *  Collection values()：返回所有value构成的Collection集合
     * Set entrySet()：返回所有key-value对构成的Set集合
     */
    @Test
    public void test4(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        //遍历所有的key集：keySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //遍历所有的value集：
        Collection values = map.values();
        for (Object obj:values) {
            System.out.println(obj);
        }

        //遍历所有的key-value
        //方式一：
        Set set1 = map.entrySet();
        Iterator iterator1 = set1.iterator();
        while (iterator1.hasNext()) {
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry=(Map.Entry)obj;
            System.out.println(entry.getKey()+"--->"+entry.getValue());

        }
        //方式二：
        Set keyset = map.keySet();
        Iterator iterator2 = keyset.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key+"--->"+value);
        }

    }

    /*
    * 元素查询的操作：
    *  Object get(Object key)：获取指定key对应的value
    *  boolean containsKey(Object key)：是否包含指定的key
    *  boolean containsValue(Object value)：是否包含指定的value
    *  int size()：返回map中key-value对的个数
    *  boolean isEmpty()：判断当前map是否为空
    *  boolean equals(Object obj)：判断当前map和参数对象obj是否相等
    */
    @Test
    public void test3(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);

        System.out.println(map.get(45));

        boolean isExist = map.containsKey("BB");
        System.out.println(isExist);

        isExist = map.containsValue(123);
        System.out.println(isExist);

        map.clear();
        System.out.println(map.isEmpty());
    }




    /*
     *  添加、删除、修改操作：
     *  Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
     *  void putAll(Map m):将m中的所有key-value对存放到当前map中
     *  Object remove(Object key)：移除指定key的key-value对，并返回value
     *  void clear()：清空当前map中的所有数据
     */
    @Test
    public void test2(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //修改
        map.put("AA",87);

        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);
        map.putAll(map1);
        System.out.println(map);

        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        map.clear();//与map=null不同
        System.out.println(map.size());
        System.out.println(map);

    }

public class TreeMapTest {
    //向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
    //因为要按照key进行排序：自然排序、定制排序
    //自然排序
    @Test
    public void test1(){
        TreeMap map = new TreeMap();
        Person1 p1 = new Person1("Tom", 23);
        Person1 p2 = new Person1("Jerry", 32);
        Person1 p3 = new Person1("Jack", 20);
        Person1 p4 = new Person1("Rose", 18);
        map.put(p1,98);
        map.put(p2,89);
        map.put(p3,76);
        map.put(p4,100);

        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            Map.Entry entry=(Map.Entry) obj;
            System.out.println(entry.getKey()+"---->"+entry.getValue());
        }

    }

    //定制排序
    @Test
    public void test2(){
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Person1 && o2 instanceof Person1){
                    Person1 p1  = (Person1) o1;
                    Person1 p2 = (Person1) o2;
                    return Integer.compare(p1.getAge(),p2.getAge());

                }else{
                    throw new RuntimeException("输入的类型不匹配");
                }
            }
        });
        Person1 p1 = new Person1("Tom", 23);
        Person1 p2 = new Person1("Jerry", 32);
        Person1 p3 = new Person1("Jack", 20);
        Person1 p4 = new Person1("Rose", 18);
        map.put(p1,98);
        map.put(p2,89);
        map.put(p3,76);
        map.put(p4,100);

        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            Map.Entry entry=(Map.Entry) obj;
            System.out.println(entry.getKey()+"---->"+entry.getValue());
        }

    }
}

//Properties:常用来处理配置文件。key和value都是String类型。
public class PropertiesTest {
    public static void main(String[] args) throws Exception {
        Properties pros = new Properties();
        FileInputStream fis = new FileInputStream("jdbc.properties");
        pros.load(fis); //加载流对应的文件

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");
        System.out.println("name="+name+",password="+password);
    }
}

11.7 Collections工具类

Collections是一个操作Collection(Set、List)和Map等集合的工具类。
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。
相关常用方法如下：

/*
一.排序操作：（均为static方法）
    1.reverse(List)：反转 List 中元素的顺序
    2.shuffle(List)：对 List 集合元素进行随机排序
    3.sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
    4.sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
    5.swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

二.查找、替换
    1.Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
    2.Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回 给定集合中的最大元素
    3.Object min(Collection)
    4.Object min(Collection，Comparator)
    5.int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
    6.void copy(List dest,List src)：将src中的内容复制到dest中
    7.boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
    */
    //举例说明如下：
    @Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);
        System.out.println(list); //[123, 43, 765, -97, 0]
        //1.reverse(List)：反转 List 中元素的顺序
        Collections.reverse(list);
        System.out.println(list); //[0, -97, 765, 43, 123]
        
        //2.shuffle(List)：对 List 集合元素进行随机排序
        Collections.shuffle(list);
        System.out.println(list);//[123, 0, -97, 43, 765]

        //3.sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        Collections.sort(list);
        System.out.println(list);//[-97, 0, 43, 123, 765]
        
        //4.sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        Collections.sort(list,new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof Integer && o2 instanceof Integer){
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return -Integer.compare(i1,i2);
            }else {
                throw new RuntimeException("输入的类型不匹配");
            }
        }
    });
        System.out.println(list);//[765, 123, 43, 0, -97]
        
        //5.swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
        Collections.swap(list,0,3);
        System.out.println(list);//[-97, 43, 765, 123, 0]
       }
}
 
    @Test
    public void test2() {
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);
        //6.void copy(List dest,List src)：将src中的内容复制到dest中
        //报异常：IndexOutOfBoundsException: Source does not fit in dest
//        List dest = new ArrayList();
//        Collections.copy(dest, list);
        //正确的：
        List dest = Arrays.asList(new Object[list.size()]);
        Collections.copy(dest, list);
        System.out.println(dest);
    }

Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

     //返回的list1即为线程安全的List
     List list1 = Collections.synchronizedList(list);

HHU.项亮亮

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java集合 P511-P562

文章目录11.1 Java集合框架概述11.2 Collection接口方法11.3 Iterator迭代器接口11.4 Collection子接口之一： List接口11.5 Collection子接口之二:Set接口11.1 Java集合框架概述一.概述集合、数组都是对多个数据（对象）进行存储操作的结构，简称Java容器数组存储数据存在一些弊端，因此使用更高级的Java集合。Java集合就像是一种容器，可以动态地把多个对象的引用放入容器中。数组在存储多个数据方面的特点：1.一旦初始化
复制链接

扫一扫