集合框架知识总结

集合框架

（1）Collections：提供了对集合进行排序，遍历等多种算法

（2）具体类：List,Map List(ArrayList,LinkedList) Map(HashMap)

（3）接口 Collection(List) ,Map

Set和List的区别：

（1）Set接口实例存储的是无序的，不重复的数据，List接口实例存储的是有序的，可以重复的数据。

（2）Set检索效率低下，删除和插入效率高，插入和删除不会引起元素的变化。

（3）List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素高，删除效率低，会引起其他元素的变化。

所有集合类都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，也就时for-each

方法：

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

从图中可以看到：

此时cursor和size相等，while循环退出。
（1）iterator

（2）foreach

在iterator中要求返回一个Iterator的接口子类实例对象

此接口包含了

hasNext()

next()方法

ArrayList

优点：遍历和随机访问元素效率比较高

缺点：添加和删除需要大量移动元素效率低，按照内容查询效率低

ArrayList:原始长度为10，到达长度时自动扩容1.5倍，实现的底层算法是数组

线程不安全的，效率高

java API文档https://docs.oracle.com/javase/8/docs/api/

ArrayList arrayList = new ArrayList();
//添加元素
arrayList.add("hello");
//在索引1位置添加元素
arrayList.add(1，"hello");
//添加另一个数组
arrayList.addAll(Collection<? extends E> c);
//清空数组
arrayList.clear();
//..可以看API来进行响应的操作

Vector

和ArrayList结构差不多，线程安全的，效率低，

Vector扩容2倍

LinkedList

优点：插入和删除时效率较高

缺点：随机访问和遍历效率低

LinkedList:底层实现用双向链表

HashSet

Set中存放的是无序的，唯一的数据

优点：添加速度块，查询速度块，删除速度块

缺点：无序

初始化为16，加载因子为0.75

TreeSet

Set不能通过下表来获取对应位置的元素的值，因为无序的特点

treeset底层实现是treemap，利用红黑树来实现

设置元素的时候，如果自定义对象，会查找对象中的equals和hashcode方法，如果没有，比较的是地址。

使用TreeSet需要实现Compariable接口

树中的元素默认进行排序，如果是基本数据类型会自动比较，如果是引用类型的话则需要添加比较器

比较器分为

​ 通过实现comparable来实现

内部比较器

​ 定义在当前类中，通过实现comparable来实现，将比较器传递到集合中

外部比较器

public class Person implements Comparable{
    public String name;
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.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 o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

    @Override
    public int compareTo(Object o) {
        Person p = (Person)o;
        if (this.name.length()>p.name.length()){
            return -1;
        }
        else if (this.name.length()<p.name.length()){
            return 1;
        }else {
            return 0;
        }
    }
}

//实现方式二
public class Test implements Comparator<Person>{
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet(new Test());
        treeSet.add(new Person("zhangsan",19));
        treeSet.add(new Person("zhangsan1",19));
        treeSet.add(new Person("liming",23));
        System.out.println(treeSet);

    }
    @Override
    public int compare(Person o1, Person o2) {
        if (o1.name.length()>o2.name.length()){
            return -1;
        }
        else if (o1.name.length()<o2.name.length()){
            return -1;
        }
        else
            return 0;
    }
}

Map

特点：key-value

HashMap:key无序，唯一

Value：无序不唯一

HashMap:数组+链表（jdk1.7） 数组+链表+红黑树（jdk1.8）

LinkedMap:链表

TreeMap:红黑树

HashMap和HashTabel的区别：

Hashmap线程不安全，效率高，初始值为16，扩容2的N次幂

HashTabel线程安全，效率低，初始值为11，扩容为2*oldCapacity+1

（1）方便进行&操作，提高效率，&要比取模运算效率高

（2）hash&(initialCapacity-1)

/**
     * Returns index for hash code h.哈希表取模操作使用二进制来表示，原因是效率高
     */
    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }

HashMap遍历方式

 //遍历方式一
        Set<String> keys = map.keySet();
        for (String key:keys){
            System.out.println(key+"="+map.get(key));
        }
        //遍历方式二
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, String> next = iterator.next();
            System.out.println((next.getKey() + "=" + next.getValue()));
        }

总结

Collection接口：
	子接口：
		List，Set，map
	常用的api方法：
		增
		删
		改
		查
		注意：每个方法来源于哪个父类
	迭代器：
		Iterator：
		Iterable：
		增强for循环
	比较器：
		当存储某些元素的时候，需要对集合中的元素进行排序，此时需要比较器
		内部比较器：Comparable
		外部比较器：Comparator
	泛型：
		泛型类
		泛型接口
		泛型方法
	数据结构：
		数组：
		链表：
		哈希表：
		红黑树：