Java 基础知识点笔记总结 (九)

最新推荐文章于 2024-09-15 19:46:31 发布

xupengboo

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量3.6k

点赞数 9

分类专栏： Java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/IT_Holmes/article/details/121454841

版权

Java 专栏收录该内容

61 篇文章 124 订阅

订阅专栏

文章目录

1. 数组与集合概述
2. Collection 接口和 Map接口集合
3. Collection接口集合
- 3.1 Collection 接口方法
- 3.2 集合转数组和数组转集合的一些方法
4. Iterator 遍历
- 4.1 使用 Iterator 遍历Collection
- 4.2 使用foreach循环遍历集合元素
5. Collection 子接口之一 list接口
6. Collection 子接口之二 set接口
7. Map接口
8. Collections 工具类
- 8.1 常用的工具类
- 8.2 Collections常用方法同步控制

1. 数组与集合概述

集合，数组都是对多个数据进行存储操作的结构，简称Java容器。

注意的是：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt , .jpg , .avi , 数据库中)。

在这里插入图片描述

数组存储的特点：

一旦初始化以后，其长度也就确定了。
一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
例如：String[] arr , int[] arr1 , Object[] arr2。

数组的弊端：
在这里插入图片描述

集合存储的优点：

解决数组存储数据方面的弊端。

2. Collection 接口和 Map接口集合

Collection接口是单例集合，用来存储一个一个的对象。
它有两个子接口：List接口和Set接口。

Collection接口继承树：

在这里插入图片描述

Map接口是双列集合，用来存储一对(key - value)一对的数据。

下面是Map接口的继承树：

3. Collection接口集合

3.1 Collection 接口方法

在这里插入图片描述

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;

public class CollectionTest2 {
    @Test
    public void test(){
        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());

        //addAll(Collection collName):将collName集合中的元素全部添加到当前的集合中。
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll);

        //3. isEmpty():判断当前集合是否为空(不是判断是null，是判断集合中是否有元素)
        System.out.println(coll.isEmpty());//false

        Collection coll2 = new ArrayList();
        coll2.add(null);
        System.out.println(coll2.isEmpty());//false

        //4. clear():清空集合元素
        coll.clear();
        System.out.println(coll.isEmpty());

    }
}

在这里插入图片描述
注意事项：

add()方法只能填对象。
向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()方法(不然像contain()进行比较时，比较的就是地址，而不是值)。

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionTest {
    @Test
    public void test1(){

        Collection coll = new ArrayList();

        //这里的123是一个对象
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        coll.add(new Person("hello",22));
        Person p = new Person("Jerry",20);
        coll.add(p);

        //1. contains(Object obj):判断当前集合中是否包含obj
        boolean contains = coll.contains(123);
        System.out.println(contains);//true

        //当然contain()方法比较的不是地址，如创建了两个不同地址，相同内容的String，结果就返回了true。
        //原因呢，就是因为String类中重写了equals方法，就是比较内容，所以这里返回true
        //额外说一下，equals比较是从头到尾进行比较，比较多少次得看位置在哪里。
        System.out.println(coll.contains(new String("Tom")));//true

        //对于自己定义的类，如果自己没有重写equals方法，那么就是默认调用父类Object的方法，那就是用 == 判断 ， 不是用equals判断， 那就比较的是地址。
        System.out.println(coll.contains(new Person("hello",22)));//false
        System.out.println(coll.contains(p));//true

        //2. containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。

        //Arrays.asList的作用是将数组转化为list。
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(coll.containsAll(coll1));


    }
}

class Person{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionTest {

    @Test
    public void test2(){

        //3. remove(Object obj):从当前集合中移除obj元素。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("hello",22));
        coll.add(false);

        coll.remove(123);
        System.out.println(coll);

        //4. removeAll(Collection collName):从当前集合中移除collName中所有的元素
        //意思就是：除去双方交集。
        Collection coll1 = Arrays.asList(456, new String("Tom"));
        coll.removeAll(coll1);
        System.out.println(coll);


    }

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

        Collection coll1 = Arrays.asList(123,456,789);

        //5. coll.retainAll(collName):取coll和collName的交集，并把交集返给当前集合(coll)
        coll.retainAll(coll1);
        System.out.println(coll);

        //6. equals(Object obj):
        Collection coll2 = new ArrayList();
        coll2.add(new String("Tom"));
        coll2.add(123);

        Collection coll3 = new ArrayList();
        coll3.add(new String("Tom"));
        coll3.add(123);

        System.out.println(coll2.equals(coll1));

        //需要注意的是equals()方法对于String等类型，都是重写后的比较值，如果用的是Object类型的equals那就是比较地址。
        //这样比较是要另外判断
        System.out.println(coll3.equals(coll2));
    }
}

3.2 集合转数组和数组转集合的一些方法

集合转数组，数组转集合等等：

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class CollectionTest3 {

    @Test
    public void test(){

        Collection coll = new ArrayList();

        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("hello",22));
        coll.add(false);

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

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

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

        //int这种写法会将123，456整体认为是一个元素
        List ints = Arrays.asList(new int[]{123, 456});
        System.out.println(ints);
        System.out.println(ints.size());//1
        //Integer包装类写法就不会
        List ints2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(ints2.size());


        //再个就是传入两个对象，那就是两个元素，不能混淆！
        List ints4 = Arrays.asList(new String[]{"abc","efg"},new String[]{"hig","kml"});
        System.out.println(ints4);
        System.out.println(ints4.size());

        List ints3 = Arrays.asList(123,456);
        System.out.println(ints3);


        //9. iterator(): 返回Iterator接口的实例，用于遍历集合元素。
        System.out.println(coll.iterator());
    }

}

4. Iterator 遍历

4.1 使用 Iterator 遍历Collection

Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，自然实现了Collection接口的结合都有一个iterator()方法，用来返回一个实现了Iterator接口的对象。
在这里插入图片描述

Iterator接口的方法有三个：

hasNext()方法：该方法用来判断是否还有下一个元素。
next()方法：指针下移，将下移以后集合位置上的元素返回。
iterator.remove()方法：这个是迭代器的remove，它也可以删除集合中的元素，但不同于集合的remove方法，一定注意。

集合遍历一般如下：

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Testset {
    @Test
    public void test(){

        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("江山如画"));
        col.add(false);

        //使用iterator遍历集合内容：
        Iterator iterator = col.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //iterator的remove()方法：
        Iterator iterator1= col.iterator();
        while (iterator1.hasNext()){

            Object obj = iterator1.next();

            if ("江山如画".equals(obj)){
                //iterator.remove()方法：也可以移除集合中的元素
                iterator1.remove();
            }

        }

        System.out.println(col);

    }

}

迭代器remove的两种错误用法：

开始不能一上来就用remove，不然开始指针还没指向第一个集合元素，无法确定移除谁？
再者就是调用了一次remove就不能调用第二次了，因为调用一次当前remove直接移除，再调用一次指针仍然指向已经移除的位置自然就会报错。

package com.holmes.java07;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Testset {
    @Test
    public void test(){

        Collection col = new ArrayList();
        col.add(123);
        col.add(456);
        col.add(new String("江山如画"));
        col.add(false);


        Iterator iterator= col.iterator();

		//第一种情况：
        //报错！java.lang.IllegalStateException
        //while (iterator.hasNext()){
        //    iterator.remove();
        //    System.out.println(iterator.next());
        //}

		//第二种情况：
        while (iterator.hasNext()){
            iterator.remove();
            System.out.println(iterator.next());
            iterator.remove();//这里也是不对的！！报错！java.lang.IllegalStateException
        }


    }

}

迭代器执行原理：

4.2 使用foreach循环遍历集合元素

通过for遍历集合：
在这里插入图片描述

同样也可以遍历数组：
在这里插入图片描述

5. Collection 子接口之一 list接口

5.1 list接口的具体类

list接口下，类定义下，元素存储有序，且可重复。

list接口下有三个类：

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

在这里插入图片描述

5.2 ArrayList类原理分析

ArrayList类：作为List接口的主要实现类；线程不安全的，效率高。底层使用Object[] elementData存储。

ArrayList源码分析：

jdk 7：
在这里插入图片描述

jdk 8：
在这里插入图片描述

5.3 LinkedList类原理分析

LinkedList类：底层使用双向链表存储，对于频繁的插入，删除操作，使用此类效率比ArrayList要高。

因为双向链式，修改插入起来更加灵活。
在这里插入图片描述

5.4 Vector类原理分析

Vector类：作为List接口的古老实现类；线程安全的，效率低。底层使用Object[] elementData存储。

在这里插入图片描述

5.5 list接口的常用方法

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class Testset {
    @Test
    public void test(){

        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add(new String("江山如画"));
        list.add(false);

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

        //list.addAll(int index , Collection elements):从index位置开始将elements中的所有元素添加刀集合中
        List list2 = Arrays.asList(1,2,3,4);
        list.addAll(3,list2);
        System.out.println(list);

        //list.indexOf(Object obj):查询obj在集合中的位置返回索引。
        int index = list.indexOf(456);
        System.out.println(index);

        //list.lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。
        list.add(0,"江山如画");
        int index2 = list.lastIndexOf("江山如画");
        System.out.println(index2);

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

        //list.set(int index , Object element)方法：设置指定index位置的元素为element。
        list.set(0,"三国演义");
        System.out.println(list);

        //list.subList(int fromIndex , int toIndex):返回从fromIndex到toIndex位置的子集合。
        List list1 = list.subList(1, 3);
        System.out.println(list1);
        
        //list.size():返回当前集合长度
        System.out.println(list.size());

        //list.get(Int index):返回当前index位置的元素
        System.out.println(list.get(0));
    }

}

6. Collection 子接口之二 set接口

6.1 Set接口介绍

set接口是Colection的子接口，它不允许包含相同的元素，同时它是无序的。

Set接口的实现类：

HashSet：作为Set接口的主要实现类；线程不安全，可以存储null值。
LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。
TreeSet：可以按照添加对象的指定属性，进行排序。

Set接口中没有额外定义的新方法，使用的都是Collection中声明过的方法。

Set接口的无序性：

无序性不等于随机，存储数据在底层不是按照索引添加来确定顺序，而是根据数据的哈希值确定。

Set接口的不可重复性：

保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个。

add()方法添加元素的原理如下：(重要)

它是先查看存放位置是否相同，不相同直接添加；位置相同的话，就比较hash值相同不相同，hash值不相同就添加；如果hash值相同的话，再比较equals想不想同，不想相同就添加。
在这里插入图片描述

Set实现类HashSet的扩容方式：

在这里插入图片描述

6.2 Set中重写hashCode() 和 equals()方法

hashCode()方法作用详解：
在这里插入图片描述

Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即 “相等的对象必须具有相等的散列码” 。

在这里插入图片描述

平时，我们创建的类，最好通过系统直接重写equals()和hashCode()方法：

在这里插入图片描述

class Person01 {
    private String name;
    private int age;

    public Person01(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person01 person01 = (Person01) o;
        return age == person01.age && Objects.equals(name, person01.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

6.3 HashSet 和 LinkedHashSet(HashSet的子类)

HashSet：作为Set接口的主要实现类；线程不安全，可以存储null值。

LinkedHashSet：作为HashSet的子类，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。

优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet。

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class SetTest {

    @Test
    public void test(){

        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        System.out.println(set);

        Set set2 = new LinkedHashSet();
        set2.add(456);
        set2.add(123);
        set2.add("AA");
        set2.add("CC");
        System.out.println(set2);

    }

}

6.4 TreeSet 的自然排序和定制排序

首先，TreeSet不能添加不同类的对象！不然报错java.lang.ClassCastException。只能添加相同类的属性。

TreeSet遍历要配合重写toString方法，不然返回的就是地址值。

6.4.1 TreeSet 自然排序

自然排序就要对TreeSet中的类，让该类实现comparable接口，重写compareTo方法和toString()方法。

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class SetTest {

    @Test
    public void test(){

        TreeSet set = new TreeSet();
        set.add(new User("Tom",22));
        set.add(new User("Aerry",24));
        set.add(new User("Mim",49));
        set.add(new User("Mim",36));
        set.add(new User("Jack",12));

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

    }

}

class User implements Comparable{

    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }


    @Override
    public int compareTo(Object o) {
        //按照姓名从小到大排序
        if (o instanceof User){

            User user = (User)o;
            int compare = this.name.compareTo(user.name);

            //如果姓名大小相同，则就比较年龄
            if (compare != 0){
                return compare;
            }else {
            	//这里有Integer的compare比较方法牢记！！
                return Integer.compare(this.age,user.age);
            }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

6.4.2 TreeSet 定制排序

定制排序就是定义comparator作为参数，传给TreeSet。

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class SetTest {


    @Test
    public void test2(){
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //按照年龄排序：
                if (o1 instanceof User && o2 instanceof User){
                    User u1 = (User) o1;
                    User u2 = (User) o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else {
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };

        TreeSet set = new TreeSet(comparator);

        set.add(new User("Tom",22));
        set.add(new User("Aerry",24));
        set.add(new User("Mim",49));
        set.add(new User("Mim",36));
        set.add(new User("Jack",12));

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


}

class User {

    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

7. Map接口

7.1 Map接口实现类和结构原理

Map接口：双列数据，存储key-value对的数据，类似于数学中的y和x对应。

Map接口实现类：

HashMap：作为Map的主要实现类；线程不安全的，效率高；能存储null的key和value。

LinkedHashMap：它是HashMap的子类，在原有的HashMap底层结构基础上，添加一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。
Hashtable：(注意这里时小写t) 作为古老的实现类；线程安全的，效率低；不能存储null的key和value。

Properties:常用来处理配置文件，key和value都是String类型。(例如jdbc的Properties文件)。
TreeMap：保证按照添加的key-value对进行排序，实现排序遍历此时要考虑key的自然排序或定制排序。

Map 的结构原理：

Map中的key：无序的，不可重复的，使用Set存储所有的key。
Map中的value：无序的，可重复的，使用Collection存储所有value。
一个键值对：key-value构成一个Entry对象。Map中的entry：无序的，不可重复的，使用Set存储所有的entry。

7.2 HashMap的底层实现原理？

JDK 7：

在这里插入图片描述
扩容问题，既然涉及到数组，必然有扩容的问题，HashMap默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。

JDK 8：

在这里插入图片描述

LinkedHashMap的底层实现原理？

7.3 Map接口一些常用的方法

Map的基本操作方法：

package com.holmes.java07;

import org.junit.Test;

import java.util.HashMap;
import java.util.Map;


public class MapTest {

    @Test
    public void test(){

        Map map = new HashMap();

        //map.put(Object key , Object value)方法：添加和修改，key，value。
        map.put("AA",123);
        map.put("BB",456);
        map.put("CC",789);
        //修改
        map.put("AA",342);

        System.out.println(map);


        Map map2 = new HashMap();
        map2.put("KK",453);
        map2.put("oo",2342);

        //map.putAll(Map map)方法:将m中的所有key—value对存放到当前map中。
        map.putAll(map2);
        System.out.println(map);

        //map.remove(Object key)方法:移除指定key的key-value对，并返回value。
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //map.clear()方法:清空当前map中的所有数据。
        map.clear();//注意！清空后不是null
        System.out.println(map);
    }

    @Test
    public void test2(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",456);
        map.put("CC",789);

        //map.get(Object key)方法:获取指定key对应的value
        System.out.println(map.get("CC"));

        //map.containsKey(Object key)方法：是否包含指定的key
        boolean isExist = map.containsKey("BB");
        System.out.println(isExist);

        //map.containsValue(Object value)方法：是否包含指定的value
        boolean isExist2 = map.containsValue(456);
        System.out.println(isExist2);

        //map.size()方法：返回map中key-value对的个数
        System.out.println(map.size());

        //map.isEmpty()方法：判断当前map是否为空
        System.out.println(map.isEmpty());

        //map.equals(Object obj)方法：判断当前map和参数对象obj是否相等
    }

}

元视图的方法：

package com.holmes.java07;

import org.junit.Test;

import java.util.*;


public class MapTest {

    @Test
    public void test(){

        Map map = new HashMap();

        //map.put(Object key , Object value)方法：添加和修改，key，value。
        map.put("AA",123);
        map.put("BB",456);
        map.put("CC",789);
        //修改
        map.put("AA",342);

        System.out.println(map);


        Map map2 = new HashMap();
        map2.put("KK",453);
        map2.put("oo",2342);

        //map.putAll(Map map)方法:将m中的所有key—value对存放到当前map中。
        map.putAll(map2);
        System.out.println(map);

        //map.remove(Object key)方法:移除指定key的key-value对，并返回value。
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //map.clear()方法:清空当前map中的所有数据。
        map.clear();//注意！清空后不是null
        System.out.println(map);
    }

    @Test
    public void test2(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",456);
        map.put("CC",789);

        //map.get(Object key)方法:获取指定key对应的value
        System.out.println(map.get("CC"));

        //map.containsKey(Object key)方法：是否包含指定的key
        boolean isExist = map.containsKey("BB");
        System.out.println(isExist);

        //map.containsValue(Object value)方法：是否包含指定的value
        boolean isExist2 = map.containsValue(456);
        System.out.println(isExist2);

        //map.size()方法：返回map中key-value对的个数
        System.out.println(map.size());

        //map.isEmpty()方法：判断当前map是否为空
        System.out.println(map.isEmpty());

        //map.equals(Object obj)方法：判断当前map和参数对象obj是否相等
    }

    @Test
    public void test03(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",456);
        map.put("CC",789);

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

        //遍历所有value集：values()
        Collection values = map.values();
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }

        //遍历所有的key-value:entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator2 = entrySet.iterator();
        while (iterator2.hasNext()){
            Object obj = iterator2.next();
            //这里要强转一下！！！
            //entrySet集合中的元素都是entry。
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey() + "----->" + entry.getValue());
        }
        
    }

}

Set集合的遍历有两种方式：

在这里插入图片描述

7.4 TreeMap 类

同样，想TreeMap中添加key-value，要求key必须是由同一个类创建的对象。也要对key进行排序：自然排序，定制排序。

自然排序：

package com.holmes.java07;

import org.junit.Test;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapTest {

    @Test
    public void test(){

        TreeMap treeMap = new TreeMap();

        treeMap.put(new User2("Tom",22),50);
        treeMap.put(new User2("Aerry",24),23);
        treeMap.put(new User2("Mim",49),43);
        treeMap.put(new User2("Mim",36),78);
        treeMap.put(new User2("Jack",12),12);

        Set entrySet = treeMap.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());
        }
    }

}

class User2 implements Comparable{

    private String name;
    private int age;

    public User2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Object o) {
        //按照姓名从小到大排序
        if (o instanceof User2){

            User2 user2 = (User2)o;
            int compare = this.name.compareTo(user2.name);

            //如果姓名大小相同，则就比较年龄
            if (compare != 0){
                return compare;
            }else {
                //这里有Integer的compare比较方法牢记！！
                return Integer.compare(this.age,user2.age);
            }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

定制排序：

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class TreeMapTest {

    @Test
    public void test(){

        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User2 && o2 instanceof User2){
                    User2 u1 = (User2)o1;
                    User2 u2 = (User2)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else {
                    throw new RuntimeException("类型不匹配！");
                }
            }
        };

        TreeMap treeMap = new TreeMap(comparator);

        treeMap.put(new User2("Tom",22),50);
        treeMap.put(new User2("Aerry",24),23);
        treeMap.put(new User2("Mim",49),43);
        treeMap.put(new User2("Mim",36),78);
        treeMap.put(new User2("Jack",12),12);

        Set entrySet = treeMap.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());
        }
    }

}

class User2{

    private String name;
    private int age;

    public User2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

7.5 Properties类

在这里插入图片描述

8. Collections 工具类

首先，Collections 和 Collection不同！Collection是创建集合的接口；而Collections是工具类，负责操作Collection，Map的工具类。

8.1 常用的工具类

在这里插入图片描述

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class CollectionsTest {

    @Test
    public void test(){

        List list = new ArrayList();
        list.add(123);
        list.add(233);
        list.add(23);
        list.add(23);
        list.add(23);
        list.add(73);
        list.add(93);
        list.add(0);

        //查看出现多少次
        int frequency = Collections.frequency(list,23);
        System.out.println(frequency);


        //copy方法会遇到一个异常：java.lang.IndexOutOfBoundsException: Source does not fit in dest
        //该异常通过源码得知，它是dest的长度小于list。
        List dest = Arrays.asList(new Object[list.size()]);//这种方式很好，相当于里面有list.size数量的null。
        //将list的集合内容，复制到dest
        Collections.copy(dest,list);
        System.out.println(dest);

    }

}

8.2 Collections常用方法同步控制

在这里插入图片描述

package com.holmes.java07;

import org.junit.Test;

import java.util.*;

public class CollectionsTest {

    @Test
    public void test(){

        List list = new ArrayList();
        list.add(123);
        list.add(233);
        list.add(73);
        list.add(93);
        list.add(0);

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


        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",456);
        map.put("CC",789);
        //同样map也是一样,这map1就是线程安全的
        Map map1 = Collections.synchronizedMap(map);


    }

}