集合Collection和Map

Java集合可分为 Collection 和 Map 两种体系

1、Collection接口：单列数据，定义了存取一组对象的方法的集合

List：元素有序、可重复的集合
Set：元素无序、不可重复的集合

2、Map接口：双列数据，保存具有映射关系 ”key-value对“ 的集合

一、Collection接口

说明：

Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。
JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List)
实现。
在 Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object 类型处理；从 JDK 5.0 增加了泛型以后，Java 集合可以记住容器中对象的数据类型。

1、常用方法

import org.junit.Test;

import java.util.*;

/**
 * 要求：
 * 想Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()
 */
public class test01 {

    @Test
    public void testCollection1(){
        Collection coll = new ArrayList();

        //1.add(Object e)：将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(new String("LaLa"));
        coll.add(123);
        coll.add(new Date());

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

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

        System.out.println(coll1.size());//7

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

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


    }

    @Test
    public void testCollection2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("LaLa"));

        //6.contains(Object obj)：判断当前集合中是否包含obj
        //判断时会调用obj对象所在类的equals()
        System.out.println(coll.contains(new String("LaLa")));//true

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

    @Test
    public void testCollection3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        //7.remove(Object obj)：从当前集合中移除obj元素
        coll.remove(123);
        System.out.println(coll);//[456, Tom, false]

        //8.removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素（差集）
        Collection coll1 = Arrays.asList(456, 1234);
        coll.removeAll(coll1);
        System.out.println(coll);//[Tom, false]
    }

    @Test
    public void testCollection4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

        //9.retainAll(Collection coll1)：获取当前集合和coll1集合的交集，并返回给当前集合
        Collection coll1 = Arrays.asList(123, 456, 789);
        coll.retainAll(coll1);
        System.out.println(coll);//[123, 456]

    }

    @Test
    public void testCollection5(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new String("Tom"));
        coll1.add(false);

        //10.equals(Object obj)：不仅要相等，还要有序
        System.out.println(coll.equals(coll1));//true
    }

    @Test
    public void testCollection6(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

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

    }

    @Test
    public void testCollection7(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

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

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

        //但是要注意
        List arr2 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr2.size());//1
        List arr3 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr3.size());//2
    }
}

二、Collection子接口之一： List接口

说明：

List集合类中元素有序、且可重复。
JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

1、常用方法

List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法。

import org.junit.Test;

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

/**
 * void add(int index, Object ele):在index位置插入ele元素
 * boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
 * Object get(int index):获取指定index位置的元素
 * int indexOf(Object obj):返回obj在集合中首次出现的位置
 * int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
 * Object remove(int index):移除指定index位置的元素，并返回此元素
 * Object set(int index, Object ele):设置指定index位置的元素为ele
 * List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
 */
public class test05 {
    @Test
    public void testList(){
        List list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new String("BB"));
        list.add(789);

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


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

        //3.Object get(int index):获取指定index位置的元素
        System.out.println(list.get(1));

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

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

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

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

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

2、List实现类之一：ArrayList

说明：

ArrayList 是 List 接口的典型实现类、主要实现类
ArrayList的JDK1.8之前与之后的实现区别？
- JDK1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组
- JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组
Arrays.asList(…) 方法返回的 List 集合，既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合

3、List实现类之二：LinkedList

说明：

对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高。
LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。Node除了保存数据，还定义了两个变量：prev（变量记录前一个元素的位置）和 next（变量记录下一个元素的位置）。
新增方法：
- void addFirst(Object obj)
- void addLast(Object obj)
- Object getFirst()
- Object getLast()
- Object removeFirst()
- Object removeLast()

4、List 实现类之三：Vector

说明：

Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList 相同，区别之处在于Vector是线程安全的。
在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。
新增方法：
- void addElement(Object obj)
- void insertElementAt(Object obj,int index)
- void setElementAt(Object obj,int index)
- void removeElement(Object obj)
- void removeAllElements()

三、 Collection子接口之二： Set接口

说明：

Set接口是Collection的子接口，set接口没有提供额外的方法。
Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法

1、Set实现类之一：HashSet

说明：

HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
不能保证元素的排列顺序；HashSet 不是线程安全的；集合元素可以是 null。
HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。
对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。
向HashSet中添加元素的过程：

当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）。

如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。
底层也是数组，初始容量为16，当如果使用率超过0.75，（16*0.75=12）就会扩大容量为原来的2倍。（16扩容为32，依次为64,128....等）

2、Set实现类之二：LinkedHashSet

说明：

LinkedHashSet 是 HashSet 的子类。
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。

3、Set实现类之三：TreeSet

说明：

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。
TreeSet底层使用红黑树结构存储数据。
新增方法：
- Comparator comparator()
- Object first()
- Object last()
- Object lower(Object e)
- Object higher(Object e)
- SortedSet subSet(fromElement, toElement)
- SortedSet headSet(toElement)
- SortedSet tailSet(fromElement)

只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。

@Test
public void test1(){
    TreeSet set = new TreeSet();

    //失败：不能添加不同类的对象
    //        set.add(123);
    //        set.add(456);
    //        set.add("AA");
    //        set.add(new User("Tom",12));

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

    //举例二：
    set.add(new User("Tom",12));
    set.add(new User("Jerry",32));
    set.add(new User("Jim",2));
    set.add(new User("Mike",65));
    set.add(new User("Jack",33));
    set.add(new User("Jack",56));


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

}

TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。

//自然排序
//按照姓名从大到小排列,年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return -this.name.compareTo(user.name);
            int compare = -this.name.compareTo(user.name);
            if(compare != 0){
                return compare;
            }else{
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }

    }

@Test
public void test2(){
    Comparator com = 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(com);
    set.add(new User("Tom",12));
    set.add(new User("Jerry",32));
    set.add(new User("Jim",2));
    set.add(new User("Mike",65));
    set.add(new User("Mary",33));
    set.add(new User("Jack",33));
    set.add(new User("Jack",56));


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

四、Map接口

说明：

Map与Collection并列存在。用于保存具有映射关系的数据:key-value 。
Map 中的 key 和 value 都可以是任何引用类型的数据。
Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法。
Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和 Properties。其中，HashMap是 Map 接口使用频率最高的实现类。

1、常用方法：

@Test
public void test3(){
    Map map = new HashMap();
    //1.Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
    map.put("AA",123);
    map.put(45,123);
    map.put("BB",56);
    map.put("AA",87);

    Map map1 = new HashMap();
    map1.put("CC",123);
    map1.put("DD",123);

    //2.void putAll(Map m):将m中的所有key-value对存放到当前map中
    map.putAll(map1);

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

    //4.void clear()：清空当前map中的所有数据
    map.clear();//与map = null操作不同
    System.out.println(map.size());
    System.out.println(map);
}

@Test
public void test4(){
    Map map = new HashMap();
    map.put("AA",123);
    map.put(45,123);
    map.put("BB",56);

    //5.Object get(Object key)：获取指定key对应的valuey)
    System.out.println(map.get(45));

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

    //7.boolean containsValue(Object value)：是否包含指定的value
    isExist = map.containsValue(123);
    System.out.println(isExist);

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

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

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

}

@Test
public void test5(){
    Map map = new HashMap();
    map.put("AA",123);
    map.put(45,1234);
    map.put("BB",56);

    //11.Set keySet()：返回所有key构成的Set集合
    Set set = map.keySet();
    Iterator iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }

    //12.Collection values()：返回所有value构成的Collection集合
    Collection values = map.values();
    for(Object obj : values){
        System.out.println(obj);
    }

    //13.Set entrySet()：返回所有key-value对构成的Set集合
    Set entrySet = map.entrySet();
    Iterator iterator1 = entrySet.iterator();
    while (iterator1.hasNext()){
        Object obj = iterator1.next();
        //entrySet集合中的元素都是entry
        Map.Entry entry = (Map.Entry) obj;
        System.out.println(entry.getKey() + "---->" + entry.getValue());

    }
    System.out.println();
    //方式二：
    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);

    }

}

2、Map实现类之一：HashMap

说明：

HashMap是 Map 接口使用频率最高的实现类。
允许使用null键和null值，与HashSet一样，不保证映射的顺序。
所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()。
一个key-value构成一个entry。
JDK 7及以前版本：HashMap是数组+链表结构(即为链地址法) 。JDK 8版本发布以后：HashMap是数组+链表+红黑树实现。

3、Map实现类之二：LinkedHashMap

说明：

LinkedHashMap 是 HashMap 的子类。
在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序。
与LinkedHashSet类似，LinkedHashMap 可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致。

4、Map实现类之三：TreeMap

说明：

TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。 TreeMap 可以保证所有的 Key-Value 对处于有序状态。
TreeSet底层使用红黑树结构存储数。
自然排序、定制排序

5、Map实现类之四：Hashtable

说明：

Hashtable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap， Hashtable是线程安全的。
Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。
与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value。

6、Map实现类之五：Properties

Properties 类是 Hashtable 的子类，该对象用于处理属性文件。
由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型。
存取数据时，建议使用setProperty(String key,String value)方法和 getProperty(String key)方法。

public class PropertiesTest {

    //Properties:常用来处理配置文件。key和value都是String类型
    public static void main(String[] args)  {
        FileInputStream fis = null;
        try {
            Properties pros = new Properties();

            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);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}