集合List，Set

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

 

和数组的区别：数组随想也可以存储对象，但是长度是固定的，集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。

 

集合特点，集合只能存储对象，长度可变，可以存储不同类型的对象。（集合和数组一样，里边存储的都是地址值）

 

集合框架，顶层的是Collection有两个常见的子接口，List和Set

 

ArrayList， LinkedList，Vector 向上抽取为List

HashSet，TreeSet向上抽取为 Set

Set和List向上抽取 就形成了Collection接口

上边的都是容器，为什么会出现这么多的容器呢，因为每一个容器对数据的存储方式都有不同。这个存储方式我们称为：数据结构

Collection 是根接口，顶层的。

1.       add方法的参数类型都是object的，可以便于接收任意类型的对象。

2.       集合中存储的都是对象的引用（地址）

Import java.util.*;

class CollectionDemo

{

       public static void main(String[] args)

       {     //创建一个集合容器，使用Collection接口的子类，ArrayList

              ArrayList  a1 = new  ArrayList()；

                     //1添加元素

                     al.add(“java01”);

al.add(“java02”);

al.add(“java03”);

al.add(“java04”);

//2获取个数，集合长度

sop(al.size());//结果为4

sop(a1);//打印集合，结果就是把java四个元素输出了

//3,删除元素

al.remove(“java02”);

al.clear();//清空集合

//4，判断元素，判断java03是否存在

sop(al.contains(“java03”));

sop(“集合是否为空？”+alisEmpty());

 

}    

 

 元素的取出。迭代器

 

Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。

       While(it.hasNext())  //hasNext（）如果后边还有可以迭代的元素的话，就结果为ture

       {

              sop(it.next());  //输出下一个元素。

}

什么是迭代器呢？其实就是集合的取出元素的方式，（遍历，）

因为不同的容器数据结构不同，它们里边取出元素的方式就不一样，于是向上抽取，吧共性的抽取方式定义在集合内部，这样取出方式就可以直接访问集合内部的元素，，所以，取出方式就被定义成了内部类，形成了一个借口，Iterator 通过一个对外提供的方法 iteroter();

 迭代器的另一种，书写方式。

       for(Iterator  it = al.iterator(); it.hasNext() ; )//这种写法，it用完之后释放内存

              {

                     sop(it.next());

}

Collection

       |--List :元素是有序的，元素可以重复，因为该集合体系有索引……

       |--Set ：元素是无序的，元素不可以重复

       List中常见的方法：凡是可以操作角标的方法都是该体系特有的方法

              增

                     add(index, element)//eg：al.add(1,”java01”):在角标1位置处添加元素（插入）

                     addAll(index,Collection);// 添加一堆元素进来

                    

              删

                     remove(index); //al.remove(2); 删除角标为2的元素

              改   

                     set(index element);// al.set(2,”java007”);把角标为2的的元素修改成java007

              查

                     get(index); //al.get(1);

                     subList(from,to);

                     listInterator();

                     获取所有元素

                     for(int x= 0;x<al.size();x++)

                            {

                                   System.out.println(al.get(x));

}                  

              用迭代器也可以。

                     Itetator it = al.iterator();

                            while(it.hasNext())

                            {

                                   sop(it.next)

}

 

List集合特有的迭代器，ListItrator是Iterator的子接口，在迭代时，不可以通过集合对象的方法操作集合中的元素，会发生异常

所以在迭代时，只能用迭代器的方法操作元素，可是Iterator方法时有限的，只能对元素进行判断，取出，删除操作，如果想要其他的操作添加，修改等，就需要使用子接口，ListIterator。该接口只能通过list集合的ListIterator方法获取。I

 

       在迭代器中进行增删改查

       ListIterator li = al.listIterator();

              While(li.hasNext)

                     {

                            object obj = li.next();

                            if(obj.equals(“java02”))

                                   //li.add(java009);

                                   li.set(“java006”)

}

 

 

       List集合中常见的三种子类对象

，ArrayList：底层的数据结构是数组结构，特点在于，查询速度很快，但是增加删除都很慢，因为变一个都变了，线程不同步，效率高，多线程自己加锁。

LinkedList：底层使用的链表数据结构，（一个元素记住它身边的）特点是，查询速度很慢，增删速度很快

Vector     底层也是数组数据结构，增删查都很慢。线程同步，被ArrayList替代了，项目部用它，

枚举：枚举就是    Vector特有的取出方式，发现枚举和迭代器很想，其实枚举和迭代时一样的。

因为枚举的名称以及方法的名称过长，所以被迭代取代了，枚举郁郁而终了。

LinkedList 链表结构

特有方法

addFirst();

addLast();

getFirst();

getLast();

removeFirst();

removeLast();

 

getFirst();

getLast();

是获取元素，但不删除元素，

removeFirst();

removeLast();也可以获取元素，但是元素被删除

 

 

 

ArrayList  LinkedList这两个容器可以用了，开发的时候用哪个呢？

看需求，对于增删操作很频繁的话就用LinkedList。

对于设计到了增删，而且涉及到了查询，建议用ArrayList。

 

Set：元素是无序的，（存入和取出的顺序不一定一致），元素不可以重复，想重复找List

       它常见的子类：|——HashSet：底层的数据结构是哈希表。

                                   是通过元素的两个方法hashCode和equals来完成，如果两个元素的hashcode值相同，才会判断equals来完成。如果元素的hascode值不同，不会调用equals

                            |——TreeSet：

Set集合的功能和Collection是一样的

哈希表，里边存的不是真正的元素，而是元素的地址值，（哈希值），然后如果两个元素的地址值相同的话，哈希表里就用用equesl比较一个元素是否一样，如果元素不一样，就放到同一个地址值顺延下一位，

Class HashSetDemo

{

 Public   static void sop(Object obj)

{

       System.out.println(obj);

}

 

       Public static void main (String args)

              {

              HashSet  hs = new HashSet();

              hs.add(“java01”);

              ha.add(“java02”);

             

              Iterator it = hs.iterator();

              while (it.hasNext())

              {sop(it.next);}

}

             

 

}