第17章(下)--集合

1.LinkedHashSet

 

 

import java.util.LinkedHashSet;

public class LinkedHashSetDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        
        linkedHashSet.add(new Car("奥拓",1000));
        linkedHashSet.add(new Car("奥迪",300000));
        linkedHashSet.add(new Car("法拉利",10000000));
        linkedHashSet.add(new Car("奥迪",300000));
        linkedHashSet.add(new Car("保时捷",70000000));
        linkedHashSet.add(new Car("奥迪",300000)); //这条加入不了,因为重复了.
        
        //当我们遍历后，发我们发现LinkedHashSet的特点
        //1. 添加时，仍然是有HashSet规则.
        //2. 维护了双向链表，保证遍历的顺序
        for (Object object : linkedHashSet) {
            System.out.println(object);
        }

    }

}

class Car {
    private String name;
    private double price;

    
    //使用eclipse生成 
    //这里hashCode将属性考虑到. 如果我们的属性相同，则hashCode就相同
    //重写hashCode的目录：就是希望通过你(程序员)指定的属性，返回一个唯一的hashCode值.
    //目的是希望只要你给的的属性值相同，那么返回的hashCode()
    
//    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        long temp;
        temp = Double.doubleToLongBits(price);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    
    //这里比较时重写equals, 主要是比较属性值是否相同
//    @Override
    public boolean equals(Object obj) { //==
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Car other = (Car) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (Double.doubleToLongBits(price) != Double.doubleToLongBits(other.price))
            return false;
        return true;
    }

    
    public Car(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }

    
    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car [name=" + name + ", price=" + price + "]";
    }

}

 2.Map

 

 

1) HashMap和Hashtable 实行了Map接口,使用虚线表示

2) Properties 是Hashtable的子类

3) LinkedHashMap 是HashMap的子类

4) SortedMap是一个Map子接口

5) TreeMap 是SortedMap的实现子类，是可以进行排序处理.

 

3.Map常用方法

 

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

public class MapDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map map = new HashMap();//这是一个hashmap对象实例
        
        //1. 映射关系的数据:Key-Value
        //2. Map 中的 key 和  value 都可以是任何引用类型的数据
        //3. Map 中的 key 用Set来存放，不允许重复, 如果有重复key,则后面的value覆盖前面value, 等同于修改
        //4. Map 中的 value 可以重复
        //5. Map 的key 可以为 null, value 也可以为null 
        //6. Map元素是无序的，因为key是用Set来存放的
        map.put("邓超", new Book("天龙八部",100));
        map.put("邓超", "孙俪");
        map.put("王宝强", "马蓉");
        map.put("宋喆", "马蓉");
        map.put("刘令博", null);
        map.put(null, "刘亦菲");
        map.put("鹿晗", "关晓彤");
        
        
        
        //这时我们遍历Map是使用其他的方案(仍然是迭代器，但是使用方法有变化)
        System.out.println(map);

        //通过get 可以获取到对应的值
        Object object = map.get("邓超");
        System.out.println("object=" + object);
        //通过remove可以删除某对key-value
        map.remove("鹿晗");
        System.out.println(map);
        
        //containsKey 用于判断该map中是否有该key,返回boolean
        //containsValue 用于判断该map中是否有该value,返回boolean
        System.out.println(map.containsKey("王宝强")); // true
        System.out.println(map.containsKey("王宝强~")); // false
        System.out.println(map.containsValue("刘亦菲"));// true
        System.out.println(map.containsValue("刘亦菲~"));// false
        
        //size和isEmpty
        System.out.println(map.size()); // 5
        System.out.println(map.isEmpty()); // false
        
        //clear:清除
        map.clear();//将map中的所有key-value全部清空
        System.out.println(map);
 
    }

}

class Book {
    private String name;
    private int price;
    public Book(String name, int price) {
        super();
        this.name = name;
        this.price = price;
    }
    
}

4.Map的遍历

 

 

 

 

 5.HashMap的扩容机制

 

 

1)      ashMap底层维护了Node类型的数组table，默认为null [看源码]

2)      当创建对象时，将加载因子(loadfactor)初始化为0.75.

3)      当添加元素时（调用putVal方法），需要通过该元素的哈希值获取在table中的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，需要继续判断是否相等(equals)，如果              相 等，则直接覆盖；如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。

4)      如果第一次添加，则需要扩容table容量为16，临界值(threshold)为12.[即使用到12个空间，就要扩容, 公式=table容量* loadfactor = 16 * 0.75 = 12 ]

5)      如果其他次添加，则需要扩容table容量为原来的2倍，临界值为原来的2倍[公式=table容量* loadfactor = 16 * 0.75 = 12]。

 

6.TreeMap

7.     Map接口实现类-Hashtable

     HashTable的基本介绍

 

1)      This class implements a hash table[该类实现hashtable]

2)      which maps keys to values [元素是键值对]

3)      Any non-null object can be used as a key or as a value [hashtable的键和值都不能为null]

4)      所以是从上面看，hashTable 基本上和hashMap一样的.

 

8.集合的选择

 9.Collection工具类

 

• 查找、替换

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 对象的所有旧值