javase集合框架

1. 1.集合中储存的对象的引用，不是对象本身
2. 结合算法类：Collections:提供用来处理集合的大量静态方法（可以直接用Collections.静态方法（）来使用），例如排序，乱序，反转，二分法查找等
   static void Collections.shuffle(list)乱序
   static void Collections.sort(list) 排序
   static void Collections.swap(list,int,int)指定两点调换
   static void Collections.reverse(list)反转
   boolean disjoint(list1,list2)如果两个集合没有相同元素则返回true
   慢慢补充。。。
3. Arrays类：对数组进行操作的算法类
   Arrays.sort()排序
   Arrays.asList()转换成集合
   慢慢补充
4. Comparable:这是一个按照自然顺序排序的接口，实现此接口的类就可以比较，使用Colletions.sort()和Arrays.sort（）时元素的类型需要实现此接口，唯一的方法是：

对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2)
具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals 一致。注意，null 不是任何类的实例，即使
e.equals(null) 返回 false，e.compareTo(null) 也将抛出 NullPointerException。

int compareTo(T t);

public class Student implements Comparable<Student>{
	//比较分数，分数相等时再比较姓名;
	@Override
	public int compareTo(Student o) {
		if(this.score==o.score) {
			return this.name.compareTo(o.getName());
		}
		return this.score-o.score;
	}
}

 1. Comparator比较器：可以定义一个比较方法使比较更灵活

>  注释：ClassCastException - 如果参数的类型不允许此 Comparator 对它们进行比较

Collection.sort(List,Comparator);
 2. Comparable 和Comparator的区别：Comparable按照自然顺序比较，Comparator按照自定义顺序比较；每个类只能使用一个Comparable使用方式，而能使用多个Comparator方式；Comparator的优先级较高
 3. List接口代表有序的可重复的集合，集合中每个元素都有其对应的顺序索引，可以通过索引来访问指定位置的元素集合，默认按照元素添加的顺序排序
add(String);
clear();
remove(int)移除相应位置的元素
removeAll()移除所有元素
remove(String)移除第一次出现的该元素
getItem(int);
 4. 泛型（数据类型参数化）
安全检查；直接完成类型转化
 9.ArraysList类型动态数组，实现List接口，可以随时扩容，
 **线程不安全Vector线程安全但是不经常使用**
 boolean add(E)添加指定元素到此列表的尾部
 add(int,E)将指定元素添加到列表的指定位置
 addAll(Collection)按照Collection迭代器制定的
indexof(String）返回首次出现词元素的索引，若不存在返回-1	
toArray()
size()
10. ArrayList源代码

> 重要属性：
elementData:用来存储数据的Object[]数组
size:元素的个数
构造方法
三个构造方法；
():空的数组
(int)：固定长度
(Collection)：与集合中元素个数相同的数组
重要方法
add():增加一个元素或多个元素，根据新增加的元素判断空间是否够用，如够不，不扩容，不够则采有两种算法扩容，
size+size>>1:即1.5倍
size+新增加元素的长度（如果增加的是多个元素时(Collection)）

 11. 链表
链表是数据结构中线性结构中的一种；
	链表中由多个存储在不同位置的节点(元素)组成，每个节点由三部分级成；
		数据
		前驱节点:上一个节点是谁 （引用）
		后继节点:下一个节点是谁(引用)
源代码

> 源代码
	内部类
	private static class Node<E> {
        E item;   //元素
        Node<E> next;   //后一个节点
        Node<E> prev;   //前一个节点

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
	重要属性：
		size:元素个数;
		first:指向头节点
		last:指向尾节点
	构造方法；
		（）：空链表
		(Collection):将集合中的数据取出存在链表中
	方法：
		add():
创建一个新节点（前驱，后继，元素）
将上一个节点的next指向它；last指向它
		get();
			size/2后，判断从前向后找，还是从后向前找;
	

 12. 栈
栈（Stack）：
	特点:先进后出;FILO(first in last out)
	三个方法：
		push(数据)：入栈
		pop():出栈（获取栈顶元素，并删除）
		peek():获得栈顶元素的引用，但不删除;

	

> 例题.比如说，入栈的顺序是 a b c ,以下哪个选择不可能是出栈的顺序 	
> A  a,b,c 	B  c,b,a 	C  b,a,c 	D 
> c,a,b

 1. 队列接口Queue
队列;先进先出的集合，FIFO:first in first out;
	操作；
		offer():向队列尾部插入一个元素
		poll();从队列头部获得一个元素，并从队列中删除此元素
		peek()：获得队列头部的元素;	
 2. Deque双端队列
实现类：
			ArrayDeque
			LinkedList
 3. set接口
 Set是Collection的子接口
 Set集合不允许添加相同的元素，否则添加不成功，判断两个对象相同使用equals
 4. HashSet是使用Set的常用接口，使用Hash算法储存元素便于查找和插入。
**特点：不能保证元素顺序
		不是线程安全
		集合元素可以使用NULL
**
当向HashSet中存数据时，HashSet会调用HashCode()方法来得到对象的HashCode值然后根据HashCode值来决定对象在HashSet中的储存位置，如果两个元素的equals（)返回为TRUE但是HashCode()不等，会把他们储存在不同位置，但是可以添加成功
什么算是重复：Object类判断相等是根据equals（）,相等对象必须有相等的哈希码
			HashSet中先判断hashCode，不相等则不判断equals()
			
List<E> list=new ArrayList<E>(set);可以转换为LIst
HashMap Node类型的数组，每个元素都是一个链表，长度是16，哈西冲突通过链表解决但是
equals不相等hashcode可能相等
 5. Iterator:迭代器
	作用：从集合(Collection)中遍历数据
	操作步骤;
获得集合的迭代器   Iterator<String> ite=set.iterator();
从迭代器取出每条数据
	while(ite.hasNext()){
		String s=ite.next();
	}
 6.TreeSet:实现了SortedSet接口，是一个排序的集合，内部通过红黑树实现，实现Comparable接口，或者传递一个Comparator类，根据这两项判断数据是否相同。
 first()
 pollfirst();
 subSet();
 headSet();
 
 6. Map集合框架的另一个顶层接口，Map中元素成对出现，形式是<Key,Vaklue>,Key不重复，每个Key对应一个Value.
clear();
containsKey();
containsValue();
entrySet()返回映射中的Set视图（键值对的集合）

Set<Entry<K,V>> set=map.entrySet();
for(Entry<K,E>e:sets){
System.out.println(e.getKey()+":"+e.getValue());
}

keySet()键的集合

Set keys=map.keySet();
System.out.println(keys);
Itreator ite=set.Iterator();
while(ite,.itenext()){
System.out.prinltn(ite.next());
}
for(String s:keys){
System.out.println(s+":"+map.get(s));
}

values()键值的集合

Collection e=map.values();
for(E s:e){
System.out.println(s);
}

putAll()将指定映射放到该映射中
remove()
get()得到指定键所对应的映射
put(K,V)
 1. hashMap：Map最常用的实现类
源码分析：
Node类，此类实现Map.Entry接口，此类是对key,和value的封装；同时它也是一个单向链表;
	它的属性有；
		hash;哈希值
		key :键
		value：值
		next: 下一个节点的引用;
	属性：
		size:元素个数
		loadfactor:加载因子，默认为0.75;当(元素的个数/数组长度超)过这个值是，将会扩容;
		table:内部用来存储键值(Node)对的数组;
	构造方法：
		():初始长度16，加载因子是0.75
		(int):指定初始长度;  建议2的次方
		(int,double);指定初始长度和加载因子
		(map):有初始值;
		方法；
		put(key,value):
重新计算hash值
判断容量是否扩容，并完成扩容
计算存储位置;     (table.legth-1)&hash  ==   hash%table.legth;
存储新元素
		如果此位置没有元素，直接存到此位置
		如果此位置的key与新key相等，替换
		如果不相等，则遍历单向链表;
		
 2. HashTable(哈希表)
早期版本遗留的Map实现，属于Dictinary类
**线程安全,而HashMap线程不安全**
对于null来说，HashMap支持null(key,value),而Hashtable不支持null
 3. TreeMap：是SortedMap的实现类，具备了排序功能，它TreeMap中的元素（Key）按照Comparable或Comparator进行排序；
TreeMap内部是一个红黑树（平衡二叉树）
 4. TreeMap源码
内部类
		Entry
			K 键
			V value
			parent :父元素
			left: 左子元素
			right:右子元素
属性；
		comparator:比较器
		size:元素的个数
		root:根元素
put方法
找到root元素，判断是否为null,如果为null,将些元素赋给root;
如果root不为空，获得comparator,如果comparator不会 null,使用比较器进行，否则用comparable进行比较
与entry进行比较，如果<0,找left进行比较，如果>0，与rigth进行比较，如果=0，给entry 的value重新赋值
重复步骤3，直到entry为null,将此元素放到此节点中;