TreeSet集合,Map集合,HashMap集合,TreeMap集合,Collections集合工具类

TreeSet集合

• TreeSet集合:

•  本质基于TreeMap的底层实现(红黑树结构---->自平衡"的二叉树结构")
  

• 有两种排序方式:

•  自然排序
  

•  选择器排序
  

• 取决于创建当前Set集合对象的时候的构造方法
• public TreeSet():默认的自然顺序排序
• TreeSet
• 由于TreeSet属于Set集合(本身保证元素唯一,不重复的元素!),还可以将元素按照自然顺序排序

public TreeSet(Comparator<? super E> comparator)

	//创建TreeSet集合
	//方式1:直接给了创建了接口子实现类
	//TreeSet<Student> ts = new TreeSet<Student>(new MyComparator()) ;
	//形式参数是一个接口类型,需要传递该接口子实现类对象
	
	//方式2:形参参数如果接口:传入接口的匿名内部类(本质:接口的子实现类)
	//匿名内部类(推荐的方式)
	/*
	 * 匿名内部类的格式:
	 * 		new 类名/接口名(){
	 * 				重写抽象类中或者接口中的抽象方法...
	 * 		};
	 * */

TreeSet集合add()方法的源码

interface Collection{}

interface Set extends Collection{
}
class TreeSet implements Set{

	//成员位置
	private transient NavigableMap<E,Object> m;

	public boolean add(E e) {//20,18,24,17,16,23,22,24
        return m.put(e, PRESENT)==null;
    }
}


interface NavigableMap<K,V> extends Map<K,V>{
		
		 V put(K key, V value);
}
//Entry<K,v>实现了接口:Map.entry<K,V>:键值对对象,以一种内部类的方式出现在TreeMap集合汇总
//将put进行重写
public class TreeMap<K,V> implements NavigableMap<K,V>{
		public V put(K key, V value) {//key =20,18,24,17,16,23,22,24
        Entry<K,V> t = root;  //root---->是一个键对对象 (根节点)
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent; //parent:是一个父节点
        // split comparator and comparable paths//分了两种方式
        
        
        //核心代码...
        
        //comparator接口:比较器排序
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
        	//自然排序:通过构造方法 
        	
            if (key == null) //如果存储的元素为空
                throw new NullPointerException();//一定抛出空指针异常!
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key); //20,18,17,24,23,22,16,17,24....
                if (cmp < 0)
                    t = t.left;  //左节点
                else if (cmp > 0)
                    t = t.right; //右节点
                else
                    return t.setValue(value); //重复元素直接存储一个!
            } while (t != null); //如果根节点不为空
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

结论:
如果使用TreeSet集合存储自定义对象,那么要进行自然排序?
那么该自定义对象所在的类必须实现Comparable接口,重写Comparaeable接口中
CompareTo(T t)方法!
刚才存储TreeSet: TreeSet() :空参构造(默认自然排序)
由于Integer类它已经实现了Compareable接口中的compareTo方法
使用三元运算符进行判断

​ 如果要使用比较器排序,那么自定义对象所在的类必须实现comparator接口,
​ 重写接口中:compare方法

Map集合

• Map集合:
• java.util.Map<K,V>:接口
• 需求:学生有姓名和年龄,通过学生的学号查询学生的姓名
• Java提供了集合:双列集合
• 键:K 学号:String “班级+学号id” 键的特点:必须唯一的!
• 值:V 学生Student
• Map集合的特点: 一个键值对元素(一个键对应一个值,值是可以重复,但是键必须唯一)

•  	只针对键有效,跟值无关!	(看成是:夫妻对)
  

Map集合的功能:

•  	添加功能
  

•  	V put(K key, V value) :添加一个键值对元素
  

•  			问题:返回值是什么意思 
  

•  		/如果当前键是一次存储的时候,返回的结果null
   		//如果键是不是第一次存储,后面重复,将当前对应的值把以前的值覆盖掉并保存下来,返回以前的值!
  

•  	刪除功能:
  

•  	V remove(Object key):刪除指定的键,返回的是跟键关联的值,如果没有映射关系,则返回null
  

•  	void clear():删除全部的键以及值
  

•  	判断功能
  

•  	boolean containsKey(Object key):是否包含指定的键
  

•  	boolean containsValue(Object value):是否包含指定的值
  

•  	boolean isEmpty():判断Map集合是否为空
  

Map和Collection集合的区别

• Map<K key,V value>集合:双列集合,键映射到值的对象 ,键必须保证唯一,可以看成是一个(夫妻对)

•  			遍历方式和Collection集合遍历方式不同
  

• Collection集合:

•  	单列集合:只能存储一种引用类型,里面的set集合依赖于Map集合的实现 (理解为:光棍)
  

•  		HashSet---->HashMap里面put方法
  

•  		TreeSet---->TreeMap里面的put方法
  

Map集合的遍历

• 高级功能:

•  方式1:(推荐的方式:Map常用的方式)
  

•  	Set<K> keySet():获取所有的键的集合
  

•     V get(Object key):通过键获取对应的值
  

• 方式2遍历

•  Set<Map.Entry<K,V>> entrySet():获取当前Map集合中所有的键值对对象
  

•  	K getKey() :通过键值对对象获取键
  

•  	V getValue():通过键值对对象获取值
  

HashMap集合

• HashMap<K,V>是Map集合的子实现类,里面哈希表结构,保证(键唯一)
• Map集合只只针对键有效
• HashMap<Integer,String>键:Integer
• HashMap<String,Student> :键:String
• HashMap<Student,String>:键是自定义对象

对于Map存储的键如果是自定义对象:该自定义对象的所在类必须重写Object:equals()和hashCode()

•  会依赖于HashMap的put方法
  

•  	hash()---->依赖于hashCode():算出每一个对象哈希码值一样
  

•  	putValue()---->equals()方法:哈希码值一样,还有比较每一个成员信息是否相同!
  

TreeMap集合

• TreeMap:红黑树结构

• 构造方法:

• public TreeMap():默认的自然顺序排序

• public TreeMap(Comparator<? super K> comparator):是一种比较器排序(推荐)

• TreeMap<Student,String> / TreeSet: 一定要有条件进行排序!

• 按照主要条件:学生的年龄从小到进行排序!

• 面试题:

• TreeSet集合存储自定义类型,什么情况下自然排序(Comparable),什么情况下是选择器排序(Comparator)?

• 执行无参构造方法:TreeSet():无参构造----是自然排序:

• 要求当前自定义类型需要实现Comparable接口,重写comparesTo方法

• 执行有参构造方法:TreeSet(Comparator com):

• 方式1:自定义一个类实现Comparator接口中 的compare(T t1,T t2)方法

• 方式2:通过接口匿名内部类实现

  Collections工具类

  Collections:java.util.Collections 类

  可以针对Collection集合进行操作的工具类!

  public static int binarySearch(List<?> list,T key):针对集合的二分查询方法:

  查询key在集合中出现的索引值

  public static T max(Collection<? extends T> list):获取集合中最大值

  public static T min(Collection<? extends T> list):获取集合中最小值

  public static void sort(List list):针对List集合进行排序:升序排序

  public static void sort(List list,Comparator com):比较器排序

ic T max(Collection<? extends T> list):获取集合中最大值

public static T min(Collection<? extends T> list):获取集合中最小值

public static void sort(List list):针对List集合进行排序:升序排序

public static void sort(List list,Comparator com):比较器排序

public static void shuffle(List<?> list):针对List集合的元素进行随机置换