黑马程序员技术交流社区

标题: Collection和Map总结 [打印本页]

---

作者: 刘军亭    时间: 2013-1-29 21:17
标题: Collection和Map总结
/*
Collection
|--List:元素是有序的,元素可以重复.因为该集合体系有索引.
  |--ArrayList:底层使用的数组结构,特点:查询速度很快,但是增删稍慢.线程不同步.50%延长
  |--LinkedList:底层使用的链表数据结构.特点:增删速度很快,查询稍慢.
  |--Vector:底层使用的是数组数据结构,线程同步.被ArrayList替代了.100%延长


|--set:元素时无序(存入和取出的顺序不一定一致),元素不可以重复.Set的取出方式都用迭代器(Iterator)完成，
  |--HashSet:底层数据结构是哈希表.线程是同步的。
   HashSet是如何保证元素唯一性的呢?
   是通过元素的两个方法,hashCode和Equals来完成.
   如果元素的HashCode值相同,才会判断equals是否为true.
   如果元素的hashCode值不同,不会调用equals.

   注意:对于判断元素是否存在,以及删除等操作,用的方法是元素的hashCode和equals方法.

  |--TreeSet:可以对Set集合中的元素进行排序.
   底层的数据结构是二叉树,保证元素唯一性的依据:compareTo方法return 0;

   TreeSet排序的第一种方式:让元素自身具备比较性,元素需要实现Comparable接口,覆盖compareTo方法.
   这种方式也称为元素的自然顺序,或者叫默认顺序.
   CompareTo方法如果返回0是相等,1是大于,-1是小于.

   当元素自身不具备比较性,或者具备的比较性不是所需要的.
   这时就需要让容器自身具备比较性.
   定义了比较器,将比较器对象作为参数传递给TreeSet集合的构造函数.
   定义一个类,实现comparator接口,覆盖compare方法.

   当两种排序都存在时,以比较器为主.

   
   让容器具备比较性匿名内部类的写法
   TreeSet ts=new TreeSet(new Comparator());
   {
    public int compare(Object o1,Object o2)
    {
     String s1=(String)o1;
     String s1=(String)o2;
     int num=new Integer(s1.length()).compareTo(new Integer(s2.lrngth()));
     if(num==0)
      return s1.compareTo(s2);
     return num;


    }
   });

---

作者: 刘军亭    时间: 2013-1-29 21:18
Map集合:该集合存储键值对.是一对一对往里存.而且要保证键的唯一性.

  难学的方法:
  entrySet()
  keySet()
Map
  |--Hashtable:底层是哈希表数据结构,不可以存入null键null值,该集合是线程同步的.
  |--HashMap:底层是哈希表数据结构,允许使用null值null键.该集合是不同步的.效率高.
  |--TreeMap:底层是二叉树结构.线程不同步.可以用于该map集合中的键排序.

和Set很像.
其实Set底层就是使用了Map集合.


//ArrayList 迭代器取出方式

  ArrayList al=new ArrayList();
  al.add("java01");
  al.add("java01");
  al.add("java01");

  Iterator it=al.iterator();//获取迭代器,用于取出集合中的元素.用方法获取对象,不是new一个.
  while(it.hasNext())
  {
   sop(it.next());
  }
  
  for(Interator it=al.iterator();it.hasNext(); )
  {
   sop(in.next());//for循环结束后new的对象也就释放了
  }

  for(int x=0; x<al.size(); x++)
  {
   sop("al("+x+")="+al.get(x));
  }
  
  //ArrayList特有的迭代器，可以对集合有更多的操作。
  /*
  List集合特有的迭代器.ListIterator是Iterator的子接口.

  在迭代时,不可以通过集合对象的方法操作集合中的元素.
  因为会发生并发异常.ConcurrentModificationException异常.

  所以在迭代时只能用迭代器的方法操作元素,可是Iterator方法是有限的,
  只能对元素进行判断,取出,删除的操作.
  如果想要其他的操作如添加,修改,就需要使用其子接口,ListIterator.

  该接口只能通过List集合的ListIterator方法获取.
  */
  for(ListIterator li=al.ListIterator();li.hasNext(); )
  {
   sop("hasprevious():"+li.hasprevious);//反向索引判断前边有没有元素
   Object obj=li.next();
   
   if(obj.equals("java02"))//特有的方法，如果使用传统的迭代器没有该方法
    //li.add("java088");
    li.set("java088");

   sop("hasNext():"+li.hasNext());//判断后边有没有元素
   sop("hasprevious():"+li.hasprevious);

   for( ;li.hasprevious(); )//逆向遍历
   {
    sop("pre::"+li.previous())
   }
  }
  
//Vector集合的取出方式：
  /*
  枚举就是Vector特有的取出方式.
  发现枚举和迭代器很像.
  其实枚举和迭代是一样的.

  因为枚举的名称以及方法的名称过长.
  所以被迭代器取代了.
  枚举就被替代了.

  */

  import java.util.*
  class VectorDemo
  {
   public static void main(String[] args)
   {
    Vector v=new Vector();

    v.add("java01");
    v.add("java02");
    v.add("java03");
    v.add("java04");

    Enumeration en= v.elements();

    while(en.hasMoreElements())
    {
     System.out.println(en.nextElement());
    }
   }
  }

//LinkedList集合取出方式
  LinkedList link=new LinkedList();
  
  link.addFirst("java01");
  link.addFirst("java01");
  link.addLast("java01");
  link.addLast("java01");

  sop(link.getFirst());
  sop(link.getLast());

  while(!link.isEmpty)
  {
   sop(link.removeFirst());
   //sop(link.removeLast());
  }

  
/*
map集合的两种取出方式:
1,Set<k> keySet:将map中的所有的键存入到Set集合.因为Set具备迭代器.
  所以可以迭代的方式取出所有的键.再根据get方法.获取每一个键对应的值.

  Map集合的取出原理:将map集合转成set集合.再通过迭代器取出.

   
2,Set<Map.Entry<K,V>> entrySet:将map集合中的映射关系存入到了Set集合中,
         而这个关系的数据类型就是:Map.Entry.
*/

import java.util.*;

class  MapDemo2
{
  public static void sop(Object obj)
  {
   System.out.println(obj);
  }
  public static void main(String[] args)
  {
   Map<String,String> map=new HashMap<String,String>();

   map.put("01","zhangsan1");
   map.put("04","zhangsan4");
   map.put("02","zhangsan2");
   map.put("03","zhangsan3");

   //先获取map集合的所有键的Set集合,keySet();
   Set<String> keySet =map.keySet();

   //有了Set集合就可以获得迭代器了
   Iterator<String> it= keySet.iterator();//调用迭代器

   while (it.hasNext())
   {
    String key=it.next();
    //有了键就可以通过map集合的get方法获取其对应的值了
    String value=map.get(key);
    sop("key:"+key+",value:"+value);
   }
  }
}
-------------------------------------------------
//2,Set<Map.Entry<K,V>> entrySet

import java.util.*;

class  MapDemo2
{
  public static void sop(Object obj)
  {
   System.out.println(obj);
  }
  public static void main(String[] args)
  {
   Map<String,String> map=new HashMap<String,String>();

   map.put("01","zhangsan1");
   map.put("04","zhangsan4");
   map.put("02","zhangsan2");
   map.put("03","zhangsan3");

   //将Map集合中的映射关系取出,存入到Set集合中.
   Set<Map.Entry<String,String>> entrySet=map.entrySet();

   Iterator<Map.Entry<String,String>> it= entrySet.iterator();//定义迭代器

   while (it.hasNext())
   {
    Map.Entry<String,String> me=it.next();//取得时候返回的是Map.Entry对象

    String key=me.getKey();
    String value=me.getValue();

    sop(key+"::"+value);
   }



   }
  }
}

---

作者: 杨玲    时间: 2013-1-29 22:33
呵呵,顶一个!

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2