java集合笔记

集合和数组的区别

区别1：
- 数组即可以存储基本数据类型,又可以存储引用数据类型,
  基本数据类型存储的是值，引用数据存储的是地址值
- 集合只能存储引用数据类型(也可存储基本数据类型，但是会装箱变成对象)
区别2:
- 数组长度是固定的，不能自动增长
- 集合的长度是可变的,可以根据元素的增加而增长
注：数组转集合Arrays.asList(arr);
集合转数组:list.toArray(new String[10]);需要制定长度

单列集合根接口Collection

* 两个实现类：
List(有序)：存和取得顺序一致，有索引可以存储重复
Set(无序)：存和取得顺序不一致，无索引，不可以存储重复

List集合

* ArrayList(常用):
由于底层是数组实现的,也具备了数组的的属性——元素的查询快，增删慢，
线程不安全，效率高。
* Vector(不常用)：
底层数据结构是数组,查询快，增删满，线程安全，效率低
* LinkedList:
双层链表,查询慢,增删快,线程不安全，效率高

Set集合

* HashSet,LinkedHashSet(子类,有序)去重,TreeSet——排序

HashSet集合

(1)HashSet:底层是哈希表,线程不同步,无序，高效
保证元素唯一性：在添加元素的时候用hashCode()和equals()方法进行比较来保证唯一性
先用hashcode比较，提高效率
(2)存储对象的时候,确保对象重写equals方法和hashcode()方法,这样才能比较对象的
值是否相等。
why:
重写hashCode()方法就是为了使hash值出现相同的情况下(哈希冲突，无法避免)，然后让两个元素比较属性值，
去除重复元素。不重写hashCode()方法，默认比较的是地址值，则无论两个元素内的
属性值是否相同，地址值永远不会相同，则集合无论是否重复，都会添加。】

(3)hashSet的实现原理
　* HashSet实现Set接口，由哈希表（实际上是一个HashMap实例）支持。
  它不保证set的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用null元素。HashSet中不允许有重复元素
  ，这是因为HashSet是基于HashMap实现的，HashSet中的元素都存放在HashMap的key上面，
  而value中的值都是统一的一个private static final Object PRESENT = new 
  Object();HashSet跟HashMap一样，都是一个存放链表的数组。
　* HashSet中add方法调用的是底层HashMap中的put()方法，而如果是在HashMap中调用put，首先会判断key是否存在，
　  如果key存在则修改value值，如果key不存在这插入这个key-value。而在set中，因为value值没有用，
　　也就不存在修改value值的说法，因此往HashSet中添加元素，首先判断元素（也就是key）是否存在，
　　如果不存在这插入，如果存在着不插入，这样HashSet中就不存在重复值。

public class Person {
    private String name;
    private int age;

    public Person(String name, int 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 int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    
    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof Person)){
            return false;
        }
        Person person=(Person)obj;
        if(this==obj)
        return true;//用户可能直接添加了同一个对象。
        return this.getName().equals(person.getName())&&this.getAge()==person.getAge();
    }
    
    @Override
    public int hashCode() {//返回唯一的hash值
        // TODO Auto-generated method stub
        return this.getName().hashCode()+this.getAge();
    }
}

(2)LinkedHashSet：HashSet的子类(有序的),根据元素的放入顺序排序

TreeSet集合

TreeSet也是用Map接口的另一个实现类TreeMap实现;TreeMap是一个有序的二叉树.

* compareTo()返回值(二叉树实现元素唯一和排序原理):
0:相等就不存【保证元素的唯一性】
负数:小的存在左边【保证排序】
正数:大的存在右边


* TreeSet能对Integer和String类型的数据进行排序
因为Integer和String都实现Comparable接口并实现了compareTo()方法

* 自定义的对象
(1)实现Comparable接口并自定义compareTo()方法来实现自定义的规则排序
class Person implements Comparable<Person> {
    public int compareTo(Person p) {
        int num = this.age - p.age;
        return num == 0 ? this.name.compareTo(p.name) : num;
    }
}
    TreeSet<Person> ts = new TreeSet<Person>();
    ts.add(new Person("zhangsan", 23));
    ts.add(new Person("lisi", 24));
}
(2)在TreeSet构造方法中传入一个Comparator比较器
TreeSet<Person> ts = new TreeSet<Person>(new Comparator<Person>(){
    public int compare(Person p1, Person p2) {
        int num = p1.getAge() - p2.getAge();
        return num == 0 ? p1.getName().compareTo(p2.getName()) : num;
    }
});
    ts.add(new Person("zhangsan", 23));
    ts.add(new Person("lisi", 24));

Map集合(双列集合)

put(K key,V value);//存储的是键值对
entrySet();//获取所有键值对
keySet();//获取所有键

HashMap和HashTable(数据是哈希表,通过hashCode()和equals()来保证数据唯一)

*线程安全问题
线程安全:多线程并发访问修改某个类,不需要额外的代码表现出正确的行为
线程不安全：多线程并发访问修改某个类，表现出不正确的行为
原因：多线程交替执行任务，产生了竞态条件
解决机制:
1.加锁(原子性)
2.不公享状态
3.用final修饰成不可变对象

*区别:
HashMap线程不安全，效率高;HashTable是线程安全，效率低
HashTable可以存储null key值和null value值,而HashTable都不可以

TreeMap

底层数据结构时二叉树，不同步，可排序;与Set很像，Set底层就是使用了Map集合

* compareTo()返回值(二叉树实现元素唯一和排序原理):
0:相等就不存【保证元素的唯一性】
负数:小的存在左边【保证排序】
正数:大的存在右边

* 自然排序(元素具备比较性):
实现Comparable接口
* 比较器排序(集合具备比较性)                
实现Comparator接口    \

集合工具类

Collections：操作集合（一般是list集合）的工具类。方法全为静态的
sort(List list);对list集合进行排序; sort(List list, Comparator c) 
按指定比较器排序
fill(List list, T obj);将集合元素替换为指定对象；
swap(List list, int I, int j)交换集合指定位置的元素
shuffle(List list); 随机对集合元素排序
reverseOrder() ：返回比较器，强行逆转实现Comparable接口的对象自然顺序
reverseOrder(Comparator c)：返回比较器，强行逆转指定比较器的顺序

数组对象工具类

asList()：将数组转为list集合
* 好处：可通过list集合的方法操作数组中的元素：
isEmpty()、contains()、indexOf()、set()
* 弊端：数组长度固定，不可使用集合的增删操作。
如果数组中存储的是基本数据类型，asList会将数组整体作为一个元素存入集合
集合转为数组：Collection.toArray()；

好处：限定了对集合中的元素进行增删操作，只需获取元素