集合（1） list hash



因为容器中数据结构不同。
容器有很多种。
 不断的共性抽取
形成了集合体系..集合框架顶层就称之为Collection接口

***Collection接口中的共性功能
1，添加
  boolean add(Object e);一次添加一个
  boolean  addAll(Collection c);将容器的所有元素添加
2,删除
 void clear();
 boolean remove(object o);
 boolean removeAll(Collection c);//删除一批
3，获取长度
 int size();
4,判断
  boolean isEmpty();
boolean contains(object o)
boolean containsAll(Collection c)// 是否包含

5,集合转成数组
  toArray();
  toArray([]);
 
c1.addAll(c2); // 往c1中添加c2
boolean b=c1.containsAll(c2);//判断c1是否包含c2中的所有元素
c1.removeAll(c2);//将c1中和c2相同的元素从c1中删除
c1.retainAll(c2);//将c1中和c2不同的元素从c1中删除，保留c1中和c2相同的元素

6，取出集合元素
  Iterator iterator()
获取集合中元素迭代功能的迭代器对象
迭代： 取出元素的一种方式。 判断下一个是否存在，存在则取

迭代器： 具备迭代功能的对象
而迭代器对象不需要new 直接通过iterator()方法获取即可
** 迭代器是取出Collection集合的公共方法。
方法： for(Iterator it = coll.iterator();it.hasNext();){
   System.out.println(it.next());
}

Collection  List与Set的1区别
--List:有序（存入的顺序和取出的顺序一致）。有索引，允许重复元素
--Set：不允许重复元素。
重点List接口中特有的方法: 它的特有方法都是围绕索引定义的
支持增删改查。
增：
add(index,element)

删：remove(index);
改：set(index,newelement);
查：int indexOf(element);
   element get(index); // 知索引查元素

List list=new ArrayList();

//List集合特有的取出方式
 for(int i=0;i<list.size();i++){
  System.out.println(list.get(i));
}

异常：java.util.ConcurrentModificationException:
迭代过程中使用了集合对象同时对元素进行操作。导致了迭代的不确定性。引发了该异常。 

解决思想： 在迭代过程中，想要执行一些操作，使用迭代器的方法即可。
使用list集合的特有的迭代器。ListIterator 通过List集合的方法listIterator()获取该迭代对象
 ListIterator可以实现迭代过程的增删改查
  for(ListIteator it=list.listIterator();it.hasNext();){
       Object obj=it.next();
   if(obj.equals("abc2")){
    it.add("haha"); 
  }
  } System.out.println(list);

逆向遍历列表：hasPrevious();

List集合的具体子类： 子类之所以区分是因为内部的数据结构（存储数据的方式）不同。
    |--Vextor:数据结构是数组。数组是可变长度的（不断new新数组并将原数组元素复制到新数组）
             线程同步。增删和查询都慢

    |--ArrayList：也是数组结构，也是长度可变。线程不同步，不安全，替代了Vector。增删速度不快，查询速度快

    |--LinkedList：链表结构，线程不同步。增删速度很快，查询速度较慢。

*******ArrayList********

** 去除重复元素。
 public static void singleElement(List list)
   {
     for(int x=0;x<list.size()-1;x++){
    Object obj_x=list.get(x);
     for(int y=x+1;y<list.size();y++){
    if(obj_x.equals(list.get(y)){
     list.remove(y);
    y--;
 }
  }
  }
  }
****去除重复元素方式二：
 思路：
 1，最后唯一性的元素很多，可以先定义一个容器用于存储这些唯一性的元素
 2，对原有容器进行元素的获取，并到临时容器中去判断是否存在。容器本身就有这个功能，判断元素是否存在
3，存在就存储，不存在就存储
4，遍历完原容器后，临时容器中存储的就是唯一性的元素

List temp=new ArrayList();
for(Iterator it= list.iterator();it.hasNext();){
  Object obj=(Object) it.next();
if(!temp.contains(obj)){
  temp.add(obj);
}
}
list.clear();
list.addAll(temp);

***建立Person类自己的判断对象是否相同的依据，必须覆盖Object类的equals()方法
  public boolean equals(Object obj)
{
    if(this==obj)
          return true;
  if(!(obj instanceof Person)){
      throw new ClassCasException("类型错误");
 }
Person p =(Person)obj;
return this.name.equals(p.name) && this.age==p.age;
}
**********************************************************

***************LinkeList**************************************
创建一个链表对象：
 LinkedList link =new LinkedList();

添加方法： link.addFist("abc1");

获取元素：link.getFirst();
删除元素： link.removeFirst()
取出link中所有元素：
  while(!link.isEmpty())
   System.out.println(link.removeLast)

**堆栈：先进后出
** 队列： 先进先出

***********HashSet**************
Set集合：不允许重复元素。和collection的方法相同。set集合取出方法只有一个：迭代器
-- HashSet: 哈希（散列）表结构。
            如何保证唯一性？
             元素必须覆盖hashCode方法是为了根据元素自身的特点确定哈希值。
          覆盖equals方法，是为了解决哈希值的冲突。

--TreeSet:

Set set =new HashSet();
 set.add("abc");
//只能用迭代器取出
 for(Iterator it = set.iterator();it.hashNext();){
  system.out.print(it.next());
}

***************哈希表***************************

不允许存储重复元素，因为会发生查找的不确定性
 不保证存入和取出的顺序一致。
 比数组的查询效率高。

用于存储元素和哈希表对应的容器称之为哈希表

hash算法  hashcode
method(element)
{
  index=ascii%10;
  return index;
}

当哈希算法算出的两个元素的值相同时，称为哈希冲突。
解决方法：
冲突后，需要对元素进行进一步的判断。判断的是元素的内容，
equals,
哈希表在判断元素是否相同：依据哈希重复（哈希值相同），在判断元素的equals方法.如果equals返回true，不存，返回false，存储。

***LinkedHashSet
: 有序的哈希表