集合框架的一些理解

集合框架：★★★★★。用于存储数据的容器。
特点：
1：对象封装数据，对象多了也须要存储。集合用于存储对象。
2：对象的个数确定能够使用数组。可是不确定怎么办？能够用集合。由于集合是可变长度的。

集合和数组的差别：
1：数组是固定长度的；集合可变长度的。
2：数组能够存储基本数据类型，也能够存储引用数据类型；集合仅仅能存储引用数据类型。

3：数组存储的元素必须是同一个数据类型。集合存储的对象能够是不同数据类型。

数据结构：就是容器中存储数据的方式。

对于集合容器，有非常多种。由于每个容器的自身特点不同，事实上原理在于每个容器的内部数据结构不同。

集合容器在不断向上抽取过程中。出现了集合体系。
在使用一个体系时。原则：參阅顶层内容。建立底层对象。

–< java.util >– Collection接口：
Collection：
|–List：有序(元素存入集合的顺序和取出的顺序一致)。元素都有索引。

元素能够反复。
|–Set：无序(存入和取出顺序有可能不一致)。不能够存储反复元素。必须保证元素唯一性。

1。加入：
add(object)：加入一个元素
addAll(Collection) ：加入一个集合中的全部元素。
2，删除：
clear()：将集合中的元素全删除，清空集合。
remove(obj) ：删除集合中指定的对象。注意：删除成功，集合的长度会改变。

removeAll(collection) ：删除部分元素。

部分元素和传入Collection一致。
3，推断：
boolean contains(obj) ：集合中是否包括指定元素 。
boolean containsAll(Collection) ：集合中是否包括指定的多个元素。

boolean isEmpty()：集合中是否有元素。
4，获取：
int size()：集合中有几个元素。
5。取交集：
boolean retainAll(Collection) ：对当前集合中保留和指定集合中的同样的元素。

假设两个集合元素同样，返回flase；假设retainAll改动了当前集合。返回true。
6，获取集合中全部元素：
Iterator iterator()：迭代器
7，将集合变成数组：
toArray();

–< java.util >– Iterator接口：
迭代器：是一个接口。

作用：用于取集合中的元素。

boolean hasNext() 假设仍有元素能够迭代，则返回 true。

next() 返回迭代的下一个元素。

void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

每个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。

为了便于操作全部的容器，取出元素。将容器内部的取出方式依照一个统一的规则向外提供，这个规则就是Iterator接口。
也就说，仅仅要通过该接口就能够取出Collection集合中的元素，至于每个详细的容器根据自己的数据结构。怎样实现的详细取出细节，这个不用关心，这样就减少了取出元素和详细集合的耦合性。

Iterator it = coll.iterator();//获取容器中的迭代器对象，至于这个对象是是什么不重要。

这对象肯定符合一个规则Iterator接口。

public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("abc0");
        coll.add("abc1");
        coll.add("abc2");
        //--------------方式1----------------------
        Iterator it = coll.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //---------------方式2用此种----------------------
        for(Iterator it = coll.iterator();it.hasNext(); ){
            System.out.println(it.next());
        }
    }

–< java.util >– List接口：
List本身是Collection接口的子接口，具备了Collection的全部方法。

如今学习List体系特有的共性方法，查阅方法发现List的特有方法都有索引，这是该集合最大的特点。

List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素能够反复。
|–ArrayList：底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快。
|–LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。

|–Vector：底层的数据结构就是数组，线程同步的，Vector不管查询和增删都巨慢。

1，加入：
add(index,element) ：在指定的索引位插入元素。
addAll(index,collection) ：在指定的索引位插入一堆元素。
2，删除：
remove(index) ：删除指定索引位的元素。 返回被删的元素。

3，获取：
Object get(index) ：通过索引获取指定元素。

int indexOf(obj) ：获取指定元素第一次出现的索引位。假设该元素不存在返回-1；
所以。通过-1，能够推断一个元素是否存在。

int lastIndexOf(Object o) ：反向索引指定元素的位置。
List subList(start,end) ：获取子列表。

4，改动：
Object set(index,element) ：对指定索引位进行元素的改动。

5，获取全部元素：
ListIterator listIterator()：list集合特有的迭代器。

List集合支持对元素的增、删、改、查。

List集合由于角标有了自己的获取元素的方式： 遍历。

for(int x=0; x<list.size(); x++){
    sop("get:"+list.get(x));
}

在进行list列表元素迭代的时候，假设想要在迭代过程中，想要对元素进行操作的时候，比方满足条件加入新元素。会发生.ConcurrentModificationException并发改动异常。
导致的原因是：
集合引用和迭代器引用在同一时候操作元素，通过集合获取到相应的迭代器后，在迭代中，进行集合引用的元素加入，迭代器并不知道，所以会出现异常情况。

怎样解决呢？
既然是在迭代中对元素进行操作,找迭代器的方法最为合适.可是Iterator中仅仅有hasNext,next,remove方法.通过查阅的它的子接口,ListIterator,发现该列表迭代器接口具备了对元素的增、删、改、查的动作。

ListIterator是List集合特有的迭代器。

ListIterator it = list.listIterator;//代替Iterator it = list.iterator;
方法摘要
void add(E e) 将指定的元素插入列表（可选操作）。

boolean hasNext() 以正向遍历列表时，假设列表迭代器有多个元素，则返回 true（换句话说，假设 next 返回一个元素而不是抛出异常，则返回 true）。
boolean hasPrevious() 假设以逆向遍历列表，列表迭代器有多个元素。则返回 true。

next() 返回列表中的下一个元素。

int nextIndex() 返回对 next 的兴许调用所返回元素的索引。

previous() 返回列表中的前一个元素。

int previousIndex() 返回对 previous 的兴许调用所返回元素的索引。

void remove() 从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。

void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

可变长度数组的原理：
当元素超出数组长度，会产生一个新数组。将原数组的数据拷贝到新数组中，再将新的元素加入到新数组中。

ArrayList：是依照原数组的50%延长。构造一个初始容量为 10 的空列表。
Vector：是依照原数组的100%延长。

注意：对于list集合，底层推断元素是否同样，其有用的是元素自身的equals方法完毕的。所以建议元素都要复写equals方法，建立元素对象自己的比較同样的条件根据。

LinkedList：的特有方法。
addFirst();
addLast();
在jdk1.6以后。

offerFirst();
offerLast();

getFirst():获取链表中的第一个元素。假设链表为空，抛出NoSuchElementException;
getLast();
在jdk1.6以后。

peekFirst();获取链表中的第一个元素。

假设链表为空，返回null。
peekLast();

removeFirst()：获取链表中的第一个元素。可是会删除链表中的第一个元素。假设链表为空。抛出NoSuchElementException
removeLast();
在jdk1.6以后。
pollFirst();获取链表中的第一个元素，可是会删除链表中的第一个元素。假设链表为空，返回null。
pollLast();

–< java.util >– Set接口：
Set接口中的方法和Collection中方法一致的。Set接口取出方式仅仅有一种。迭代器。
|–HashSet：底层数据结构是哈希表，线程是不同步的。

无序，高效；
HashSet集合保证元素唯一性：通过元素的hashCode方法。和equals方法完毕的。

当元素的hashCode值同样时，才继续推断元素的equals是否为true。

假设为true，那么视为同样元素，不存。

假设为false，那么存储。

假设hashCode值不同，那么不推断equals，从而提高对象比較的速度。

|–LinkedHashSet：有序，hashset的子类。
|–TreeSet：对Set集合中的元素的进行指定顺序的排序。

不同步。

TreeSet底层的数据结构就是二叉树。

哈希表的原理：
1，对对象元素中的关键字(对象中的特有数据)。进行哈希算法的运算，并得出一个详细的算法值。这个值 称为哈希值。
2，哈希值就是这个元素的位置。
3。假设哈希值出现冲突，再次推断这个关键字相应的对象是否同样。

假设对象同样。就不存储，由于元素反复。假设对象不同，就存储，在原来对象的哈希值基础 +1顺延。
4。存储哈希值的结构，我们称为哈希表。

5。既然哈希表是根据哈希值存储的。为了提高效率，最好保证对象的关键字是唯一的。
这样能够尽量少的推断关键字相应的对象是否同样，提高了哈希表的操作效率。

对于ArrayList集合。推断元素是否存在，或者删元素底层根据都是equals方法。

对于HashSet集合，推断元素是否存在。或者删除元素，底层根据的是hashCode方法和equals方法。

TreeSet:
用于对Set集合进行元素的指定顺序排序。排序须要根据元素自身具备的比較性。

假设元素不具备比較性。在执行时会发生ClassCastException异常。

所以须要元素实现Comparable接口。强制让元素具备比較性，复写compareTo方法。
根据compareTo方法的返回值，确定元素在TreeSet数据结构中的位置。

TreeSet方法保证元素唯一性的方式：就是參考比較方法的结果是否为0，假设return 0，视为两个对象反复，不存。

注意：在进行比較时，假设推断元素不唯一，比方。同姓名，同年龄，才视为同一个人。

在推断时，须要分主要条件和次要条件。当主要条件同样时，再推断次要条件，依照次要条件排序。

TreeSet集合排序有两种方式，Comparable和Comparator差别：
1：让元素自身具备比較性，须要元素对象实现Comparable接口。覆盖compareTo方法。
2：让集合自身具备比較性，须要定义一个实现了Comparator接口的比較器，并覆盖compare方法，并将该类对象作为实际參数传递给TreeSet集合的构造函数。

另外一种方式较为灵活。

Map集合：
|–Hashtable：底层是哈希表数据结构，是线程同步的。不能够存储null键，null值。

|–HashMap：底层是哈希表数据结构。是线程不同步的。

能够存储null键。null值。

替代了Hashtable.
|–TreeMap：底层是二叉树结构。能够对map集合中的键进行指定顺序的排序。

Map集合存储和Collection有着非常大不同：
Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值。键与值之间有相应(映射)关系。

特点：要保证map集合中键的唯一性。

1，加入。
put(key,value)：当存储的键同样时。新的值会替换老的值。并将老值返回。假设键没有反复。返回null。
void putAll(Map);
2，删除。

void clear()：清空
value remove(key) ：删除指定键。
3，推断。
boolean isEmpty()：
boolean containsKey(key)：是否包括key
boolean containsValue(value) ：是否包括value
4，取出。
int size()：返回长度
value get(key) ：通过指定键获取相应的值。假设返回null。能够推断该键不存在。当然有特殊情况，就是在hashmap集合中。是能够存储null键null值的。

Collection values()：获取map集合中的全部的值。

5。想要获取map中的全部元素：
原理：map中是没有迭代器的，collection具备迭代器。仅仅要将map集合转成Set集合，能够使用迭代器了。之所以转成set。是由于map集合具备着键的唯一性，事实上set集合就来自于map。set集合底层其有用的就是map的方法。

★ 把map集合转成set的方法：
Set keySet();
Set entrySet();//取的是键和值的映射关系。

Entry就是Map接口中的内部接口。
为什么要定义在map内部呢？entry是訪问键值关系的入口。是map的入口。訪问的是map中的键值对。

取出map集合中全部元素的方式一：keySet()方法。
能够将map集合中的键都取出存放到set集合中。对set集合进行迭代。

迭代完毕，再通过get方法对获取到的键进行值的获取。

        Set keySet = map.keySet();
        Iterator it = keySet.iterator();
        while(it.hasNext()) {
            Object key = it.next();
            Object value = map.get(key);
            System.out.println(key+":"+value);
        }

取出map集合中全部元素的方式二：entrySet()方法。

Set entrySet = map.entrySet();
        Iterator it = entrySet.iterator();
        while(it.hasNext()) {
            Map.Entry  me = (Map.Entry)it.next();
            System.out.println(me.getKey()+"::::"+me.getValue());
        }

使用集合的技巧：
看到Array就是数组结构，有角标，查询速度非常快。

看到link就是链表结构：增删速度快，并且有特有方法。

addFirst； addLast； removeFirst()； removeLast()。 getFirst()；getLast()；
看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。

看到tree就是二叉树。就要想到排序，就想要用到比較。
比較的两种方式：
一个是Comparable：覆盖compareTo方法；
一个是Comparator：覆盖compare方法。
LinkedHashSet，LinkedHashMap:这两个集合能够保证哈希表有存入顺序和取出顺序一致。保证哈希表有序。

集合什么时候用？
当存储的是一个元素时。就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。

保证唯一，就用Set。不保证唯一，就用List。

Collections：它的出现给集合操作提供了很多其它的功能。这个类不须要创建对象，内部提供的都是静态方法。
静态方法：
Collections.sort(list);//list集合进行元素的自然顺序排序。
Collections.sort(list,new ComparatorByLen());//按指定的比較器方法排序。

class ComparatorByLen implements Comparator<String>{
    public int compare(String s1,String s2){
        int temp = s1.length()-s2.length();
        return temp==0?s1.compareTo(s2):temp;
    }
}

Collections.max(list); //返回list中字典顺序最大的元素。
int index = Collections.binarySearch(list,”zz”);//二分查找。返回角标。
Collections.reverseOrder();//逆向反转排序。

Collections.shuffle(list);//随机对list中的元素进行位置的置换。

将非同步集合转成同步集合的方法：Collections中的 XXX synchronizedXXX(XXX);
List synchronizedList(list);
Map synchronizedMap(map);
原理：定义一个类，将集合全部的方法加同一把锁后返回。

Collection 和 Collections的差别：
Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、推断一个元素是否其成员、遍历等。

Arrays：
用于操作数组对象的工具类，里面都是静态方法。

asList方法：将数组转换成list集合。
String[] arr = {“abc”,”kk”,”qq”};
List list = Arrays.asList(arr);//将arr数组转成list集合。
将数组转换成集合。有什么优点呢？用aslist方法。将数组变成集合。
能够通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；
注意（局限性）：数组是固定长度，不能够使用集合对象添加或者删除等。会改变数组长度的功能方法。比方add、remove、clear。（会报不支持操作异常UnsupportedOperationException）。
假设数组中存储的引用数据类型，直接作为集合的元素能够直接用集合方法操作。
假设数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。

集合变数组：用的是Collection接口中的方法：toArray();
假设给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法。会自定再创建一个该类型的数据。长度为集合的size。

假设传递的指定的类型的数组的长度大于了集合的size。那么toArray方法，就不会创建新数组，直接使用该数组就可以。并将集合中的元素存储到数组中。其它为存储元素的位置默认值null。
所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

将集合变成数组后有什么优点？限定了对集合中的元素进行增删操作，仅仅要获取这些元素就可以。

Jdk5.0新特性：
Collection在jdk1.5以后，有了一个父接口Iterable。这个接口的出现的将iterator方法进行抽取，提高了扩展性。

增强for循环：foreach语句，foreach简化了迭代器。
格式：// 增强for循环括号中写两个參数，第一个是声明一个变量。第二个就是须要迭代的容器
for( 元素类型 变量名 : Collection集合 & 数组 ) {
…
}

高级for循环和传统for循环的差别：
高级for循环在使用时。必须要明白被遍历的目标。

这个目标。能够是Collection集合或者数组，假设遍历Collection集合，在遍历过程中还须要对元素进行操作。比方删除，须要使用迭代器。
假设遍历数组，还须要对数组元素进行操作，建议用传统for循环由于能够定义角标通过角标操作元素。假设仅仅为遍历获取。能够简化成高级for循环，它的出现为了简化书写。

高级for循环能够遍历map集合吗？不能够。可是能够将map转成set后再使用foreach语句。

1)、作用：对存储对象的容器进行迭代： 数组 collection map
2)、增强for循环迭代数组：
String [] arr = {“a”, “b”, “c”};//数组的静态定义方式，仅仅试用于数组首次定义的时候
for(String s : arr) {
System.out.println(s);
}
3)、单列集合 Collection：
List list = new ArrayList();
list.add(“aaa”);
// 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能
for(Object obj : list) {
String s = (String) obj;
System.out.println(s);
}
4)、双列集合 Map：
Map map = new HashMap();
map.put(“a”, “aaa”);
// 传统方式：必须掌握这种方式
Set entrys = map.entrySet(); // 1.获得全部的键值对Entry对象
iter = entrys.iterator(); // 2.迭代出全部的entry
while(iter.hasNext()) {
Map.Entry entry = (Entry) iter.next();
String key = (String) entry.getKey(); // 分别获得key和value
String value = (String) entry.getValue();
System.out.println(key + “=” + value);
}
// 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，由于增强for循环仅仅能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，仅仅有实现了Iterable接口的类，才干保证一定有iterator方法，java有这种限定是由于增强for循环内部还是用迭代器实现的，而实际上。我们能够通过某种方式来使用增强for循环。
for(Object obj : map.entrySet()) {
Map.Entry entry = (Entry) obj; // obj 依次表示Entry
System.out.println(entry.getKey() + “=” + entry.getValue());
}
5）、集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发訪问异常）；能够用迭代器的方法进行操作（子类listIterator：有增删的方法）。

6)、增强for循环注意问题：在使用增强for循环时。不能对元素进行赋值；
int[] arr = {1,2,3};
for(int num : arr) {
num = 0; //不能改变数组的值
}
System.out.println(arr[1]); //2

可变參数（…）：用到函数的參数上。当要操作的同一个类型元素个数不确定的时候，可是用这个方式。这个參数能够接受随意个数的同一类型的数据。

和曾经接收数组不一样的是：
曾经定义数组类型。须要先创建一个数组对象。再将这个数组对象作为參数传递给函数。

如今，直接将数组中的元素作为參数传递就可以。底层事实上是将这些元素进行数组的封装，而这个封装动作，是在底层完毕的，被隐藏了。所以简化了用户的书写。少了调用者定义数组的动作。

假设在參数列表中使用了可变參数，可变參数必须定义在參数列表结尾(也就是必须是最后一个參数，否则编译会失败。)。

假设要获取多个int数的和呢？能够使用将多个int数封装到数组中。直接对数组求和就可以。

静态导入：导入了类中的全部静态成员。简化静态成员的书写。
import static java.util.Collections.*; //导入了Collections类中的全部静态成员