《java》笔记<十>

集合

Collection：

         |--list：元素有序的，元素可以重复，因为该集合体系有索引

 

                  |--ArrayList：底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢，线程不同步，1.2才有。默认长度为10，如果超过，就自动增加长度，50%的延长；

                  |--LinkedList:底层使用的链表数据结构，特点：增删很快，查询稍慢

                  |--Vector：底层是数组数据结构，线程同步的，1.0就有了。被ArrayList替代。默认长度为10,100%的延长。

+++

         |--set：元素是无序的，元素不可以重复，该集合体系没有索引

 

 

Collection是集合中的一个超级接口，下面有很多的子接口，但是每一个子接口中都有共性的方法：

add();添加元素

clear();删除所有元素

remove();删除指定元素

contains();判断是否包含指定元素，Boolean

equals();比较元素

size();数组的长度

iterator();取出方法，迭代器

 

 

每一个集合都有自己独特的取出方式

就把取出方式定义在集合的内部

这样取出方式就可以直接访问集合内容的元素

那么取出方式就被定义成立内部类，

而每一个容器的数据结构不同

所有出去的动作细节和不一样，但是都有共性内容

判断和取出，那么可以将这些共性抽取

 

那么这些内部类都符合一个规则，该规则是Iterator

如何获取集合的取出对象呢

 

通过一个对外提供的方法iterator();

 

 

import java.util.*;

class CollectionDemo

{

         publicstatic void main(String[] args)

         {

                  method_get();

         }

         publicstatic void method_get()

         {

                 

                  ArrayListal = new ArrayList();

                 

                  al.add("java01");

                  al.add("java02");

                  al.add("java03");

                  al.add("java04");

        

                  Iteratorit = al.iterator();

                  while(it.hasNext())//hasNext（）是判断集合中是否还有元素，用while循环，迭代器取出

                  {

                          sop(it.next());

                  }

                 

         }

         publicstatic void method_2()

         {

                  ArrayListal1 = new ArrayList();

                 

                  al1.add("java01");

                  al1.add("java02");

                  al1.add("java03");

                  al1.add("java04");

                  ArrayListal2 = new ArrayList();

                 

                  al2.add("java01");

                  al2.add("java02");

                  al2.add("java07");

                  al2.add("java08");

 

                 

                  //al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素

                  al1.removeAll(al2);//取交集，al1中只会保留和al2中不相同的元素

                  sop("al1:"+al1);

                  sop("al2:"+al2);

         }

         publicstatic void base_method()

         {

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

                  ArrayListal = new ArrayList();

                 

                  al.add("java01");

                  al.add("java02");

                  al.add("java03");

                  al.add("java04");

 

                  //打印集合

                  sop(al);

                          //获取个数，集合长度

                  sop("size:"+al.size());

 

                  //删除元素

                  //al.remove("java02");

                  //清空元素

                  al.clear();

 

                  //判断元素

                  sop("java03是否存在："+al.contains("java03"));

                  sop("集合是否为空："+al.isEmpty());

                  sop(al);

         }

         publicstatic void sop(Object obj)

         {

                  System.out.println(obj);

         }

}

 

List

List:

特有的方法，凡是可以操作角标的方法都是该体系特有的方法

 

增

         add(index,element);在指定位置添加元素

         addAll(index,Collection);

 

删

         remove(index);删除指定位置元素

 

改

         set(index,deelement);修改元素

 

 

查

         get(index);通过角标获取元素

 

         subList(forn,to);

         listIterator();

 

 

 

List集合特有的迭代器。ListIterator是Iterator是子接口

 

在迭代时，不可以通过集合对象的方法操作集合中的元素

因为会发生ConcurrentModificationException异常

 

所以在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的

只能对元素进行判断，取出，删除的操作

如果想要其他的操作如添加，修改等，就需要使用其子接口ListIterator

 

该接口只能通过List的集合ListIterator方法获取

 

import java.util.*;

class ListDemo

 

{

         publicstatic void sop(Object obj)

         {

                  System.out.println(obj);

         }

         publicstatic void method()

         {

                  ArrayListal = new ArrayList();

                 

                  al.add("java01");

                  al.add("java02");

                  al.add("java03");

                  al.add("java04");

 

                  sop("原集合是："+al);

 

                  //在指定位置添加元素                         

                  al.add(2,"java05");

 

                  //删除指定位置元素

                  //al.remove(3);

 

                  //修改元素

                  //al.set(2,"java06");

                 

                  //通过角标获取元素

                  sop("get(1):"+al.get(1));

 

 

                  sop(al);

 

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

                  {

                          System.out.println("al("+x+")="+al.get(x));

                  }

 

                  Iteratorit = al.iterator();

 

                  while(it.hasNext())

                  {

                          sop("next:"+it.next());

                  }

                  //通过indexOf获取对象的位置

                  sop("index="+al.indexOf("java04"));

 

                  Listsub = al.subList(1,3);

                  sop("sub="+sub);

         }

         publicstatic void main(String[] args)

         {

                  ArrayListal = new ArrayList();

                 

                  al.add("java01");

                  al.add("java02");

                  al.add("java03");

                  al.add("java04");

 

                  sop(al);

 

                  ListIteratorli = al.listIterator();

 

                  while(li.hasNext())

                  {

                          Objectobj = li.next();

                          if(obj.equals("java02"))

                          //li.add("java12");//在迭代的过程中添加元素

                          it.set("java012");//在迭代过程中修改元素

                  }

                  //反向取值

                  while(li.hasPrevious())

                  {

                          sop(li.previous());

                  }

 

                  sop(al);

 

         /*     while (it.hasNext())

                  {

                          Objectobj = it.next();

                          if(obj.equals("java02"));

                                   //al.add("java0001");

 

                                   it.remove();

                          sop("obj="+obj);

                  }

                  sop(al);

                  */

         }

}

 

LinkedList

LinkedList:特有方法

addFirst();把元素添加到最前端

addLast();把元素添加到最后端

 

getFirst();

getLast();

获取元素，但不删除元素，如果集合中没有元素会出现NoSuchElementException

 

removeFirst();

removeLast();

获取元素  但是元素被删除，如果集合中没有元素会出现NoSuchElementException

 

 

在JDK1.6出现了替代方法

 

offerFirst();

offerLast();

添加元素

 

peekFirst()

peekLast()

获取元素，但不删除元素，如果集合中没有元素，会返回null

 

pollFirst();

pollLast();

获取元素，但是元素被删除，如果集合中没有元素，会返回null

 

Import java.util.*;

class LinkedListDemo

{

         publicstatic void main(String[] args)

         {

                  LinkedListlink= new LinkedList();

                  link.addLast("java01");

                  link.addLast("java02");

                  link.addLast("java03");

                  link.addLast("java04");

 

                  //sop(link);

                  //sop(link.getFirst());//打印第一个元素

                  //sop(link.getLast());//打印最后一个元素

                  //sop(link.removeFirst());

                  //sop(link.removeLast());

                 

                  //sop("size="+link.size());

 

                  while(!link.isEmpty())//不为空的时候就取

                  {

                          sop(link.removeLast());//倒着取

                          //sop(link.removeFirst());//正着取

                  }

 

 

         }

         publicstatic void sop(Object obj)

         {

                  System.out.println(obj);

         }

}