集合的复习（补充）

集合框架--JDK1.2（解决数组定长问题，动态数组）
Collection--保存单个元素的父接口
	-Iterator接口（集合遍历迭代器接口）
	-List（允许数据重复）
		-常用方法:add()、remove()、get(int index)、set(int index,Object newValue)
		-ArrayList
		-Vector
		-LinkedList
	-Set(不允许数据重复--穿了马甲的Map）
		-HashSet
		-TreeSet
	-Queue(JDK1.5)(juc包）
		-Deque
		-BlockingQueue(juc下的阻塞队列-绑定到线程池）

一、List集合

1.对比ArrayLsit、Vector、LinkedList？

相同点：三者都是List的子类，都实现了List接口。

分开说：ArrayList在JDK1.2产生，底层的数据结构是数组，线程不安全。

              Vector在JDK1.0就出现了，底层也是数组，线程安全。

              LinkedList在JDK1.2产生，底层是链表，线程不安全。

对比说：

ArrayList  VS Vector:

二者底层都是数组，ArrayList线程不安全，Vector线程安全。Vector一旦初始化，就初始化容量为10；而ArrayList采用懒加载的方式初始化。产生对象时并不初始化，而是在第一次添加元素时初始化。ArrayList扩容以1.5倍扩容，而Vector以2倍扩容。

ArrayList  VS LinkedList:

ArrayList底层的数据结构是数组，而LinkedList底层是链表。二者都是线程不安全的。LinkedList适合进行插入和删除操作，而ArrayList适合查找。

2.了解fail-fast与fail-safe机制

2.1初步认识

fail-fast:java.util.ConcurrentModufacationException异常（并发修改异常）

fail-fast机制是Java集合中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生（fail-fast)事件。

ConcurrentModufacationException异常：当方法检测到对象的并发修改，但不允许这种修改时就抛出此异常。注意：该异常不会始终指出对象已经由不同线程并发修改，如果单线程违反了规则，同样有可能抛出该异常。

2.2如何产生？

在迭代遍历集合时同时修改集合结构（add、remove)
本质原因：modCount!=expectedModCount
           在集合的里面有一个modCount值，用于存储集合被修改的次数。当取得集合迭代器时，有一个参数expectedModCount来取得当前集合的修改次数。在每次遍历集合时，会检查这两个集合是否相等，如果不相等，会立即抛出并发修改异常。

2.3为何要抛出此异常？
           尽量保证在多线程场景下，数据不会产生脏读，即若有线程并发修改集合结构时，向同时在遍历此集合的线程发出一个异常，通知其集合数据已经修改。

如：线程2正在打印某集合，而线程1正在修改集合中的数据。此时线程2在读的时候，集合变为了一个无效的集合。

 private static void test1() {
        List<String> list=new ArrayList<>();//modCount=0
        list.add("h");//modCount=1
        list.add("e");//modCount=2
        list.add("l");//modCount=3
        //expectedModCount=modCount=3
        Iterator<String> iterator=list.iterator();
        //线程2
        while(iterator.hasNext()){
            //checkForModification
            //if(modCount!=expectedModCount)
            String str=iterator.next();
            if(str.equals("h")){
                //modCount++;=4
                //线程1
                list.remove("h");
                continue;
            }
            System.out.print(str+" ");
        }
    }

2.4fail-fast解决方法

方案一（不推荐）：在遍历过程中所有涉及到改变modCount值的地方全部加上synchronized或者直接调用Collections.synchronizedList。不推荐的原因是增删造成的同步锁可能会阻塞遍历结构。

方案二（推荐）：使用CopyOnWriteArrayList替换ArrayList.

CopyOnWriteArrayList是ArrayList的一个线程安全的变体，其中所有可变操作（add、set等等）都通过对底层数组进行一次新的复制来实现。因此开销较大。它适用于两种情况：在不想或不能进行同步遍历但又需要从并发线程中排除冲突时；当遍历的数量大大超过可变操作的数量时。

2.5哪些类会抛出此异常？哪些类不会抛出此异常？
                    ArrayList、LinkedList、Vector、HashMap

fail-safe:juc下的集合--不会抛出fail-fast异常
                   CopyOnWriteArrayList、ConcurrentHashMap不会抛出此异常。

二、Set集合

排序两个接口 ：Comparator接口（外部排序）和Compareable接口（内部排序，内部实现）

1.TreeSet有序，序指的是？

要使用TreeSet，必须满足以下两者之一：
I.作为TreeSet集合的类，必须实现Compareable接口（内部排序）
II.通过构造方法传入Comparator接口对象（外部排序）

如果这两个方法都存在，则优先使用Comparator外部排序接口（原因：更加灵活，策略模式）

package com.xunpu.collection;

import java.io.IOException;
import java.io.InputStream;
import java.util.*;

class Person implements Comparable{
    private String name;
    private Integer age;

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

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

    public String getName() {

        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    //方式一：实现Comparable接口，覆写方法实现逆序。
    @Override
    public int compareTo(Object o) {
        return -1;
    }
}
 private static void test2() {
        Person per=new Person("张三",20);
        Person per1=new Person("李四",18);
       Set<Person> set=new TreeSet<>();
        set.add(per);
        set.add(per1);

        for(Person person:set){
            System.out.println(person);
        }
    }
public class TestLiu {
    public static void main(String[] args) throws IOException {
             test2();
    }
}

package com.xunpu.collection;

import java.io.IOException;
import java.io.InputStream;
import java.util.*;

class Person{
    private String name;
    private Integer age;

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

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

    public String getName() {

        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}
//通过构造方法传入Comparator接口对象（外部排序）
class PersonComparator implements Comparator<Person>{

    @Override
    public int compare(Person o1, Person o2) {
        //自定义规则
        if(o1.getName().equals(o2.getName())){
            //比较name大小
            return o1.getName().compareTo(o2.getName());
        }else{
            return o1.getAge().compareTo(o2.getAge());
        }
    }
}
public class TestLiu {
    public static void main(String[] args) throws IOException {
        test2();

    }

    private static void test2() {
        Person per=new Person("张三",20);
        Person per1=new Person("李四",18);
        Set<Person> set=new TreeSet<>(new PersonComparator());
        set.add(per);
        set.add(per1);
        for(Person person:set){
            System.out.println(person);
        }
    }

2.请介绍hashCode()和equals()和它们之间的联系

hashCode():生成一个对象的哈希码。根据属性值生成哈希码，自定义策略。
equals():可自定义。
这两个方法共同判断一个元素是否重复。
联系：equals相等的两个对象必须保证hashCode()相等，但是hashCode()相等的对象equals不一定相等。（哈希表）

三、Properties属性资源文件

Properties,是HashTable的子类。资源文件(Properties)的使用，线程安全。同一时刻，只能有一个进程对其操作。

db.properties文件的内容：

user=root
password=123456

测试代码：

package com.xunpu;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class Test {
    public static void main(String[] args) throws IOException {
        InputStream in=Test.class.getClassLoader().getResourceAsStream("db.properties");
        Properties properties=new Properties();
        properties.load(in);
        System.out.println(properties.get("user"));
    }
}