java集合

Java中的集合：
为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

集合是存储对象的一个工具。

集合和数组的特点：
　　相同点：
　　数组和集合都是容器。
　　
　　不同的：
集合：
　　1，可以存储对象，只能存储对象
　　2，集合的长度是可变的。
数组：
　　1，可以存储对象，也可以存储基本数据类型。
　　2，数据长度是固定的。

**容器对象有很多种，通过内部的数据结构来区分。
数据结构：就是一种数据存储的方式。

**容器在不断将共性向上抽取的过程中，就出现了集合体系结构。
该结构的顶层是一个接口，Collection。


Collection接口：
创建一个集合对象，也就是一个容器。
Collection coll = new ArrayList();

1，添加元素
　　Add(); coll.add(“abc”);
2,删除元素
　　Boolean b = coll.remove(“abc”);
3,获取集合的长度
　　Int size = coll.size();
4,清除集合中的所有元素
　　Coll.clear();
5,判断集合是否为空（其实依据的是size()是否等于0判断的）
　　Boolean b = coll.isEmpty();
6,添加一堆元素
　　coll.addAll(Collection co1);//添加的是一个集合
7, 判断一堆元素是否存在
　　coll.containsAll(Collection co1);
8,删除一堆元素
　　Boolean b = coll.removeAll(Collection co1);
9,获取两个集合的交集。
　　Boolean b = coll.retainAll(co1);
　　//retainAll会将coll和co1中相同的元素保留在coll中，所以coll中存储的就是交集的元素，当coll集合中的元素变化时，retainAll方法返回的是true，当coll集合中的元素本身就是交集元素，不发生变化，返回false。
10，Collection集合中对元素的获取方法。
　　Coll.iterator();
　　 
　　
**集合容器都具备取出方式，取出方式并不是一个方法。因为一个方法不足以完成取出功能。
取出是由多个功能来完成，为了方便使用，就将这些功能封装成对象。该对象在描述这些功能会直接使用到具体集合中的数据和集合特点。
所以这个取出元素的描述类，定义在了集合的内部。也就是一个内部类。
因为这个类直接访问集合中的数据，根据集合自身的数据结构特点。将具体的方法都定义完成后。需要将对象提供出去。让用户使用。所以暴露了一个方法来完成对这个内部类对象的访问。
为了提高扩展性，发现只要是容器，就具备取出功能。但是数据结构不同，取出的具体实现就不一样，这时为了扩展，就抽取出了一个接口。Iterator。

取出对象有两种表现形式：
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());
}
第二种可以减少内存的消耗，因为第一种的it使用完之后还存在，而在for循环中，it出了for循环就不存在了


容器在进行添加的时候add();中的参数是object类型。
那么在取出的时候就要写成
Person p1 = (Person)it.next();
所以在进行迭代器使用的时候，next方法在循环中，建议只定义一个，定义多个会导致数据错误。当next方法没有获取到元素时，会发生NoSuchElementException;

**其实集合中存储的都是对象的引用。
获取迭代器后，迭代器中持有的也是元素的引用。




Collection
　　|--List:该容器的元素是有序的 (存储的顺序和取出的顺序一致)
　　该集合中的元素都有索引 (角标) ，该集合可以存储重复的元素
　　|--ArrayList:底层数据结构是数组结构 不同步的，查询的速度很快
　　|--vector:底层数据结构是数组结构 jdk1.0版本。 同步的
　　|--LinkedList:底层数据结构是链表结构 不同步的，对元素的增删操作效率很高
　　（vector和ArrayList区别？
　　Vector相对于线程时安全的，同步的。ArrayList是不安全的
　　）
　　|--Set:无序，不可以存储重复元素。Set接口的方法与collection方法一致。
　　Set没有特殊方法。Set接口取出元素方法只有迭代器。
　　|--HashSet:底层数据结构是哈希表。哈希表这种结构，就是对哈希值的存储。而且 每一个对象都有自己的哈希值。因为object类中有个hashCode方法。
　　（如何保证元素唯一性？
　　通过判断元素的hashCode方法，和equals方法来完成的。当hashCode值相同，会再判断一次equals方法的返回值是否为true。
　　如果hashCode值不同，就确定元素的哈希表中的位置，不同判断equals了。
　　哈希表中有一个桶结构，每一个桶都有一个哈希值，当哈希值相同，但是equals为false时，这些元素都放在同一个桶中。
　　）
　　|--TreeSet:可以对set集合中的元素进行排序。
　　数据结构是二叉树，这种结构，可以提高排序性能。
　　（如何保证元素唯一性？
　　是根据比较方法的返回值确定的，只要返回的是0，就代表元素重复。
　　）
　　
　　
　　
　　
　　
List:常用的共性方法。（继承了Collection接口）
1，添加元素。
　　Add(index,element);//在索引位添加元素，其他元素依次顺延。
2，删除元素。
　　Remove(index);//按照指定索引删除元素。被删除的元素会被返回。
3，修改元素。
　　Set(index,element);//按照索引修改元素，被修改的元素会被返回。
4，获取元素。
　　Get(index);//通过索引获取指定元素
　　Get(element);//通过元素获取元素第一次出现的位置
　　subList(fromIndex,lastIndex);//根据头尾角标获取子列表。
　　
　　通过List特有的方式，获取集合中所有的元素。(其实就是for循环)
　　For(int x = 0;x < list.size(); x++)
　　{
　　System.out.println(list.get(x));
　　}

**在进行迭代过程中，如果出现了迭代器和容器同时对元素进行操作的情况很容易引发
ConcurrentModificationException并发修改异常。
所以要么使用集合的方法操作元素，要么使用迭代器的方法操作元素，不要同时使用，
迭代器Iterator中只有三个操作，hasNext,next,remove,如果想进行添加，这个迭代器就不可以使用了，这时，可以使用一个新的迭代方式，ListIterator列表迭代器，ListIterator本身也是Iterator的接口，并且有更多的方法。

既然ArrayList底层是数组实现的，数组的长度是固定的，那么究竟是如何实现的呢？
ArrayList内部封装了一个默认长度为10的数组。当超出长度时，集合内部会自动生成一个新的数组，然后将原来的数组复制到新的数组中去。这就是导致ArrayList修改数据的效率比LinkedList慢的原因。

新的数组到底多长？
ArrayList 50%延长
Vector 100%延长

ArrayList判断元素是否相同，底层依据的是元素的equals方法。无论是contains还是remove都会去使用equals判断元素是否相同。所以在往ArrayList集合存储自定义元素时，最好建立该元素特有判断对象是否相同的依据。也就是需要覆盖equals方法。

LinkedList的特有方法：
1，
addFirst();
addLast();
在jdk1.6以后。
被offerFirst();
offerLast();替代
2,
getFirst(); 获取元素，集合的长度不改变
getLast();
在jdk1.6以后，被
peekFirst();
peekLast();替代。
3,
removeFirstt();获取元素，集合的长度改变
　　如果集合中没有元素，那么该方法会发生异常NoSuchElementException
removeFirst();
在jdk1.6以后，被
pollFirst();
pollLast();代替。
如果集合元素没有，不会抛异常，而是返回null


Vector：vector中提供了一个独特的取出方式，就是枚举
Enumeration。此接口Enumeration的功能与Iterator接口的功能是重复的。
Enumeration的名称和方法的名称过程，书写比较麻烦，并且Iterator有个移除的方法。
所以被Iterator取 代。


**如果在编译的时候如果出现了
{
注意：TestArrayList.java 使用了未经检查或不安全的操作。
注意：要了解详细信息，请使用 -Xlint:unchecked 重新编译。
}
的提醒，并不是编译失败，是因为类型的原因导致的，如果用了泛型，就没有该提示了。


HashSet：
HashSet集合元素保证唯一性，依赖的是元素的hashCode方法和equals方法。
当元素的哈希值不同时，元素都有自己的独立位置。不需要再判断元素的equals方法，当元素的哈希值相同时，这时元素在哈希表中位置相同，这时就需要再判断元素的内容是否相同，就需要调用元素的equals方法进行一次比较。如果equals返回true，那么视为两个元素重复。只存储一个。如果返回false，那么这两个元素不是重复元素，会存储在同一个哈希值上。
为了建立自定义对象判断元素是否重复的依据。
需要覆盖hashCode方法，和equals方法。
而且最好依据对象的特有条件来建立hashcode和equals的实现。

ArrayList：判断包含，以及删除，都是依据元素的equals方法。
HashSet：判断包含，以及删除，都是依据元素的hashCode方法。当hashCode值相同时，再判断一次equals方法。


TreeSet：
TreeSet集合是用于给元素进行排序的。那么自定义元素本身不具备比较性，treeSet集合是无法对元素进行排序的。所以，在自定义对象时，需要对象具备一个扩展功能，用于比较的，而java已经提供了接口，可以让实现它的对系那个具备比较性。
那么自定义类，要想被treeSet排序，就要实现Comparable接口，以具备比较功能。

也可以将一个实现了Comparato接口的子类对象作为参数传递给TreeSet集合的构造函数即可，这样该集合就具备了比较功能。

TreeSet排序方式有两种：
1，让元素自身具备比较性
  其实是让元素实现Comparable接口，覆盖CompareTo方法。这称为元素的自然排序。
2，当元素自身不具备比较性，或者元素具备的比较性不是所需要的，定义一个比较器。
  其实就是定义一个类，实现Comparator接口，覆盖Compare方法。将comparator接口的子类对象作为参数传递给TreeSet的构造函数。

当元素自身具备比较性，同时TreeSet集合也具备比较器，这时以比较器为主。
所以建议使用第二种方法，比较灵活。

**一般在描述一个对象时，如果该对象封装了具体的数据，会出现很多这样的对象，这时就需要进行容器的存储。

那么描述该类对象时，一般要复写几个方法：
1,hashCode()
2,equals()
3,toString()
4,最好实现Comparable接口让该类具备自然排序功能。

建立对象自身判断是否相同的依据，同时让对象具备基本的比较性。



泛型：
泛型其实就是jdk1.5版本以后出现的一个安全机制。，泛型其实是给编译器使用的。
Al.add(3);//al.add(new Integer(3));因为jdk1.5之后有自动装箱，所以会自动把3装成对象。

集合中存储了不同类型的对象，取出时，容易在运行时时期发生classCastException类型转换异常。为了避免这个问题的发生，如果在存储的时候名气了集合要操作的数据类型，这样取就没有问题了。
就需要在定义集合时，就立刻明确元素的类型。
其实借鉴于数组。
可以通过<>来明确元素的类型。
ArrayList<String> al = new ArrayList<String>();

泛型的好处：
1，将运行时期出现的classCastException问题，转移到编译时期。
2，泛型的出现避免了强制转换的麻烦。

泛型的表现形式是<>;

什么时候使用泛型？
只要用到的类或者接口的旁边有<>的时候，就要明确具体类型。
泛型的使用其实就是给<>传递实际参数，而这个参数就是一个具体的引用数据类型。

什么时候使用泛型类？
当类要操作的引用数据类型不确定的时候，可以使用泛型来定义。
也就是定义一个类型参数。
具体要操作什么类型的对象，有使用该类的使用者来明确，将具体的类型作为实际参数传递给<>;

Class Tool<Q>
{
Private Q obj;
Public void setObj(Q obj){
  This.obj = obj;
}
Public Q getObj(){
  Return obj;
}
}

当泛型定义在类上，该泛型作用于整个类。当该建立对象时，就明确了具体类型。那么凡是使用了类上定义的泛型的方法，操作的类也就固定了。
当希望类中的方法，可以操作任意类型而不受类中泛型限制。
可以将泛型定义在方法上。泛型方法。
Public <Q> void print(Q q){
   System.out.println(“print”+q);
}


当类中定义static方法时，静态方法是不可以直接访问类上的泛型。因为类上的泛型只有通过建立对象才能明确具体类型。
所以静态方法如果操作的引用数据类型不确定，只能将泛型定义在方法上。
(静态方法上定义泛型，必须定义在static关键字之后)
Public static<W> void method(W w){
System.out.prinln(method+”w”);
}

当方法中操作的应用数据类型不确定，而且和对应的对象执行的类型也不一定一致。
这时就将泛型定义在方法上。


泛型接口:
1，
Class InterImpl implements Inter<String>{
Public void show(String s){
  System.out.println(s);
}
}
2,
Class InterImpl<T> implements Inter<T>{
Public void show(T t){
  System.out.println(“show”+t);
}
}

泛型：通配符？代表任意类型。
Public static void show(Collection<?> coll){
Iterator<?> it = coll.iterator();
While(it.hasNext()){
  System.out.println(it.next());
}
}


定义集合时要保证左右两边的类型一致。两边只有一边定义泛型，也是可以支持，至少新老版本兼容，但是一样会出现提示信息。

泛型限定：
定义T只能固定一种类型，定义？可以是任意类型，只想操作该类或该类的子类。要使用泛型限定。
? extends E:接收E类型或者E的子类型。
? super E:接收E类型或者E类型的父类型。
例如：
Public static void show(Collection<? extends Person> coll){
  Iterator<? extends Person> it = coll.itrator();
  While(it.hasNext()){
    System.out.println(it.next());
  }
}

集合框架中的另一个顶层接口：Map
Map集合的特点：
1，是一个双列集合，collection是单例集合
2，Map一次存一对元素，同时键值对的形式。建和值有对应关系，collection是一次存一个元素。
3，Map集合必须保证集合中键的唯一性。

Map集合中常见的功能：
1，添加
v  put(k , v);将k和v作为元素存储如map集合，当存入相同的k时，
新的值会覆盖原来的值，并返回原来的值。
void  putAll(map);
2，删除
Clear();
V remove(k):按照键删除，并返回被删除的键对应的值。
3，判断
Boolean containsKey(Object key)
Boolean containsValue(Object value);
Boolean isEmpty();
4，获取
Int size();获取map集合的元素个数
V get(k);通过键获取值。
Collection values();获取map集合中所有的值。
Set keySet():获取map集合中所有的键。
Set entrySet():获取的是键值的映射关系，将映射关系存入到set集合中。

Map集合没有迭代器。迭代器是collection集合具备的，Map集合的取出元素的原理就是将map集合先转成set集合，然后再进行迭代。

Map
　　|--Hashtable：底层是哈希表数据结构（同步的，不允许null作为键，null作为值）
　　  |--properties：用于配置文件的定义和操作，使用频率非常高，同时键和值都是字符串。是集合中可以和IO技术相结合的对象。
　　|--HashMap：底层是哈希表数据结构（不同步的，允许null作为键，允许null作为值）
　　  |--LinkedHashMap:可以保证hashMap存入顺序和取出顺序一致
　　|--TreeMap：可以用来对map集合中的键进行排序。


如何获取集合中的所有元素？
一：
1，获取所有的键，再通过对所有的键进行遍历，在遍历中通过get方法获取每一个键的对应的值，使用keySet方法获取map集合中键的集合。
2，对set集合进行迭代器的操作。
Set<Integer> keySet = hm.keySet();
Iteraror it = keySet.itertor();
While(it.hasNext()){
Integer i = it.next();
String s = hm.get(i);
System.out.println(s+”...”+i);
}
二：
1，将map集合中的键值关系取出，并封装成一个键值关系对象，再存储到一个set集合中。
键值映射关系封装对象后的数据类型是map.entry(内部接口)
Entry就是一个map接口中的内部静态接口。
作为一个键值关系的数据类型存在。
使用entrySet获取map集合中的所有键值。
Set<Map.Entry<Integer,String>> entry = hm.entrySet();
Iterator<Map.Enrty<Integer,String>> it = entrySet.iterator();
While(it.hasNext()){
Map.Entry<Integer,String> me = it.next();
Integer key = me.getKey();
String value = me.getValue();
System.out.println(key+”...”+value);
}


hashMap:参考HashSet
存入的对象是无序的，想要保证有序。可以使用子类LinkedHashmap。存入和取出的顺序是一致的。

TreeMap：参考TreeSet


Utility:集合中的工具类：
如果有一堆元素。
要是元素重复，选择ArrayList集合，但是想要让元素按顺序排序，可以使用集合中的工具类。

工具类有两种。collections，Arrays
这两个工具类的特点：类中的方法都是静态的，不需要创建对象。


1，collections
Collections是集合对象的工具类，提供了操作集合的工具方法。

Fill(al,”kk”);将集合中的元素替换成指定的元素kk。

Reverse(al);集合元素反转，头尾对调

Swap(al,2,4);对集合中的元素进行位置的置换

Shuffle(al);对集合中的元素进行随机的位置置换

toArray();将集合变成数组
给toArray方法传递一个指定类型的数组。
当指定的长度小于集合的长度，该方法会自动创一个该类型的新数组长度和集合长度一致。用于存储集合中的元素，如果指定的数组长度大于集合的长度，那么该方法就不会创建新数组，而是使用传递进来的数组，存储完集合的元素后，其他的未存储的位置为null。
将集合变成数组后，限定了对元素的增删操作。

Xxx synchronizedList(xxx);可以将一个不同步的集合转成一个同步的list集合

2，Arrays
Arrays:是数组的工具类，提供了堆数组的工具方法。
asList(arr);将数组变成集合。
当数组变成集合后，就可以使用集合的方法来操作数组，而不用自己再定义指针进行数组的操作。（有些方法不可以用，只要是改变集合长度的方法都不能用，因为数组是固定长度的）

当数组中的元素时引用数据类型时，变成集合后，就将数组中的元素作为集合中的元素存在，当数组中的元素时基本数据类型时，变成集合后，会将这个数组变成集合中的元素。
List<int[]> list = Arrays.asList(arr);
System.out.println(list);