java：容器/集合（Map（HashMap，TreeMap）Collection和Collections，（Collection-value（）;)

*Map接口:采用是键值对的方式存放数据。无序

HashMap：
*常见的实现类:
*--HashMap:基于哈希表的 Map 接口的实现。
*常用的构造方法:
* HashMap()构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
* HashMap(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap
*常用方法:
* put(K key, V value)在此映射中关联指定值与指定键。
* get(Object key) 返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
* size() 返回此映射中的键-值映射关系数。
* remove(Object key) 从此映射中移除指定键的映射关系（如果存在）。
* clear() 从此映射中移除所有映射关系。
* containsKey(Object key) 如果此映射包含对于指定键的映射关系，则返回 true。
* containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
*----LinkedHashMap
*--Hashtable
*--TreeMap

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

public class TestHashMap {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        //向容器中添加元素:以键值对的方式进行存放.
        map.put("jack", "成龙");
        map.put("jay", "周杰伦");
        map.put("eason", "陈奕迅");//添加元素
        //取:
//        map.remove("eason");//通过key移除元素
        System.out.println("是否包含eason:"+map.containsKey("eason"));
        System.out.println("是否包含成龙:"+map.containsValue("成龙"));
        System.out.println("容器中总共有"+map.size()+"个键值对元素");
        String name = map.get("jack");//根据key获取元素的值
        System.out.println(name);
        String name2 = map.get("jay");
        System.out.println(name2);

    }
}

HashMap取值的两种方法：

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 *Map的遍历
 *    Set<K> keySet() 返回此映射中所包含的键的 Set 视图。
 *  Set<Map.Entry<K,V>> entrySet() 返回此映射所包含的映射关系的 Set 视图。
 */
public class TestHashMap2 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        //向容器中添加元素:以键值对的方式进行存放.
        map.put("jack", "成龙");
        map.put("jay", "周杰伦");
        map.put("eason", "陈奕迅");//添加元素
        map.put("jack", "杰克");//键如果重复，将发生覆盖
        System.out.println(map);
        //方式1:先获取键的集合，通过键获取值
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            String value = map.get(key);
            System.out.println(key+"----"+value);
        }
        System.out.println("-------------------------------");
        //方式2:获取键值对的集合，然后从键值对获取键和值。(推荐)
        //Entry<String,String>:对键和值进行泛型,Set<Entry<String,String>>对Set集合中Entry(键值对)进行泛型
        Set<Entry<String,String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            String key = entry.getKey();//获取键值对的键
            String value = entry.getValue();//获取键值对中值
            System.out.println(key+"****"+value);
        }
    }
}

LinkedHashMap继承了HashMap：

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;

/**
 * java.util.LinkedHashMap:哈希表+链表，有序(添加顺序其实就是摆放顺序)，继承了HashMap类。
 * 常用的构造方法:
 *     LinkedHashMap()构造一个带默认初始容量 (16) 和加载因子 (0.75) 的空插入顺序 LinkedHashMap 实例
 *      LinkedHashMap(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的空插入顺序 LinkedHashMap 实例。
 * 常用的方法:
 *  put(K key, V value)在此映射中关联指定值与指定键。
 *  get(Object key) 返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
 *  size() 返回此映射中的键-值映射关系数。
 *  remove(Object key) 从此映射中移除指定键的映射关系（如果存在）。
 *  clear() 从此映射中移除所有映射关系。
 *  containsKey(Object key)  如果此映射包含对于指定键的映射关系，则返回 true。
 *  containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
 *  Set<K> keySet() 返回此映射中所包含的键的 Set 视图。
 *  Set<Map.Entry<K,V>> entrySet() 返回此映射所包含的映射关系的 Set 视图。
 */
public class TestLinkedHashMap {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<String,String>();
        map.put("jack", "成龙");
        map.put("jay", "周杰伦");
        map.put("eason", "陈奕迅");//添加元素
        //方式1:通过先遍历键的集合获取键，然后通过键获取值
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            String value = map.get(key);
            System.out.println(key+"-----"+value);
        }
        //方式2:通过先遍历键值对的集合获取键值对，然后通过键值对获取键和值。
//        Set<Entry<String,String>> entrySet = map.entrySet();
//        for (Entry<String, String> entry : entrySet) {
//            System.out.println(entry.getKey()+"==="+entry.getValue());
//        }
        for(Iterator<Entry<String,String>> iter = map.entrySet().iterator();iter.hasNext();){
            Entry<String,String> entry = iter.next();
            System.out.println(entry.getKey()+"==="+entry.getValue());
        }
    }
}

TreeMap：

*TreeMap:类似于TreeSet,采用二叉树的方式存储数据，有序(大小顺序)。
*常用的构造函数:
*TreeMap() 使用键的自然顺序构造一个新的、空的树映射。 插入该映射的所有键都必须实现 Comparable 接口.
*TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序。

(对象放前面，值放后面)

public class TestTreeMap {
    public static void main(String[] args) {
        TreeMap<String,String> map = new TreeMap<String,String>();
        map.put("a","aaa");
        map.put("c","ccc");
        map.put("b","bbb");
        System.out.println(map);
        System.out.println("------------");
        TreeMap<Student,String> map2 = new TreeMap<Student,String>();
        Student stu1 = new Student("zhangsan",);
        Student stu2 = new Student("lisi",);
        Student stu3 = new Student("wangwu",);
        map2.put(stu1,"zhangsan");
        map2.put(stu2,"lisi");
        map2.put(stu3,"wangwu");
        System.out.println(map2);
    }
}

*TreeMap(Comparator<? super K> comparator)   构造一个新的、空的树映射，该映射根据给定比较器进行排序。

import java.util.Comparator;

public class AgeComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return -(o1.getAge()-o2.getAge());
    }

}

public class TestTreeMap2 {
    public static void main(String[] args) {
        TreeMap<Student,String> map = new TreeMap<Student,String>(new AgeComparator());
        Student stu1 = new Student("zhangsan",);
        Student stu2 = new Student("lisi",);
        Student stu3 = new Student("wangwu",);
        map.put(stu1,"zhangsan");
        map.put(stu2,"lisi");
        map.put(stu3,"wangwu");
        System.out.println(map);
    }
}

* Collection和Collections的区别:

* Collection是List和Set的父接口，而Collections是操作Collection集合的工具类。
* Collections(对Collection集合进行操作的工具类),类似Arrays类(对数组进行操作的工具类),提供了若干个静态的方法以方便操作集合。
* 常用的方法:
* addAll(Collection<? super T> c, T... elements) 将所有指定元素添加到指定 collection 中。
* sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。
* reverse(List<?> list)反转指定列表中元素的顺序。
* max(Collection<? extends T> coll) 根据元素的自然顺序，返回给定 collection 的最大元素。
* min(Collection<? extends T> coll) 根据元素的自然顺序 返回给定 collection 的最小元素。
* binarySearch(List<? extends Comparable<? super T>> list, T key)
* 使用二分搜索法搜索指定列表，以获得指定对象，必须根据列表元素的自然顺序对列表进行升序排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestCollections {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add();
        list.add();
        list.add();
        list.add();
        list.add();
        System.out.println("排序前:"+list);
        Collections.sort(list);//排序，默认按照升序进行排列
        System.out.println("排序后:"+list);
        Collections.reverse(list);//反转:倒序输出
        System.out.println("反转后:"+list);
        int index = Collections.binarySearch(list, );//二分查找:待查找的集合中元素必须有大小顺序

        System.out.println("index="+index);
        Integer max = Collections.max(list);
        System.out.println("max="+max);
        Integer min = Collections.min(list);
        System.out.println("min="+min);
    }
}

Collection-value();

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 *3、定义一个Worker类,属性:name:String,age:int,salary:double
    a).把若干Worker对象放在List中,排序并遍历输出,按照age升序排列
    b).把若干Worker对象放在Set中并遍历,要求没有重复元素
    c).把若干Worker对象放在Map中并按照三种方式分别遍历,要求以Worker的姓名作为key。
 *
 */
public class Homework3 {
    //1.把若干Worker对象放在List中,排序并遍历输出,按照age升序排列
    public void saveAsList(){
        List<Worker> list = new ArrayList<Worker>();
        Worker w1 = new Worker("zhangsan",,);
        Worker w2 = new Worker("lisi",,);
        Worker w3 = new Worker("wangwu",,);
        list.add(w1);
        list.add(w2);
        list.add(w3);
        Collections.sort(list,new AgeComparator());//排序
        for (Worker worker : list) {
            System.out.println(worker.getName()+"---"+worker.getAge()+"---"+worker.getSalary());
        }
    }

    //2.把若干Worker对象放在Set中并遍历,要求没有重复元素
    public void saveAsSet(){
        Set<Worker> set = new HashSet<Worker>();
        Worker w1 = new Worker("zhangsan",,);
        Worker w2 = new Worker("lisi",,);
        Worker w3 = new Worker("wangwu",,);
        Worker w4 = new Worker("wangwu",,);
        set.add(w1);
        set.add(w2);
        set.add(w3);
        set.add(w4);
        //遍历Set
        for (Worker worker : set) {
            System.out.println(worker.getName()+"---"+worker.getAge()+"---"+worker.getSalary());
        }

    }

    //3.把若干Worker对象放在Map中并按照三种方式分别遍历,要求以Worker的姓名作为key。
    public void saveAsMap(){
        Map<String,Worker> map = new HashMap<String,Worker>();
        Worker w1 = new Worker("zhangsan",,);
        Worker w2 = new Worker("lisi",,);
        Worker w3 = new Worker("wangwu",,);
        map.put(w1.getName(), w1);
        map.put(w2.getName(), w2);
        map.put(w3.getName(), w3);
        System.out.println("第一种遍历:");
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Worker worker = map.get(key);
            System.out.println(worker.getName()+"---"+worker.getAge()+"---"+worker.getSalary());
        }
        System.out.println("第二种遍历:");
        Set<Entry<String,Worker>> entrySet = map.entrySet();
        for (Entry<String, Worker> entry : entrySet) {
            Worker worker = entry.getValue();
            System.out.println(worker.getName()+"---"+worker.getAge()+"---"+worker.getSalary());
        }
        System.out.println("第三种遍历:");
        Collection<Worker> values = map.values();//获取值的集合
        for (Worker worker : values) {
            System.out.println(worker.getName()+"---"+worker.getAge()+"---"+worker.getSalary());
        }
    }

    public static void main(String[] args) {
        Homework3 homework3 = new Homework3();
//        homework3.saveAsList();
//        homework3.saveAsSet();
        homework3.saveAsMap();
    }
}