java 容器使用

Java中有许多的容器集合。初一看起来有些糊涂,特别是对刚接触Java来说(至少我当初就是这样的)!其实稍微细心,深入一点点就会发现原来一切都是有规律的。我想别的事情也会是如此。
       Java
中的容器,接口都是由一些接口,抽象类及它们的实现类所组成。而它们全部封装在java.util
包中。


1Collection接口。

       大多数的集合都实现了此接口,它基本方法是add(没有get()方法,实现类中可能有如Arrylist),添加一对象。添加成功则返回true ,否则返回false。这是与Map不同的地方。还有一些常用的方法如iterator(),size(),toArray()(注:toArray()是返回一对象----object数组,而Arrays----也是java.util下的一个类,有一个asList方法它们通常认为是各集合之间转换的桥梁)等等!具体用法可以参考API文档。


2Map(映射)
       Map
接口跟Collection接口实际上没有半点关系。集合中的每一个元素都包含一对键对对象和值对象,集合中没有重复的键对象,值对象可以重复。它的有些实现类能对集合中的键对象进行排序。与Collection截然不同的是,它其中所存取的是一些值与名相对应的数据。也就是一个Key对应一个Value的方式来存储。所以它就有与之对应的一些方法如:put (K key, V value)等等,更多可以参考API文档。

3List(列表)
      
集合中的对象按索引位置排序,可以有重复对象,允许按照对象在集合中的索引位置检索对象

4Set()
      
集合中的对象中按特定的方式排序,并且没有重复对象。它的有些实现类能对集合中的对象
按特定的方式排序

5:迭代器:Iterator
      
它是一个接口,只有三个方法hasnext(),next(),remove()只有最后一个是可选的,也就是remove()是可选(在实现的时候)。其可选性也意味着它的实现类中,remove方法是可有可无的。例如,若有一个如下的List 实例。
        

    Arrylist al = new Arrylist();
    Object[] ob = al.toArray();
    List list = Arrays.asList(ob);
    Iterator itor = list.iterator();
    itor.remove();      
//Error 


       
当调用Ierator itr = list.iterator()方法返回一迭代器的时候,便不支持remove方法,所以当你再使用irt.remove()时程序就是异常!

       
使用此迭代器要注意的是remove()方法。它所删除的是指指针(暂这么叫着)上次所移经过的位置(Removes from the underlying collection the last element returned by the iterator (optional operation).)。我个人觉得有点象在JDBC中的ResultSet rs = ....;rs.last();rowsCount=rs.getRow();类似呢。
       
前面所讲的,由于clollection提供了iterator()方法,所以迭代器是很容易实现的!

6:常用实现类的一些继承关系:

       
Collections,它是Java.util下的一个类。它为我们提供了许多有用的方法,如sort(...),max()等其具体用法可以参考API文档,比如sort(List list);list内的所有元素都必须实现Comparable接口(All elements in the list must implement the Comparable interface)。

      
Arrylist ,它是List接口的实现类,而List则是继承于Collection
       
LinkedList,它也是间接对Colections的实现。用linkedlist的一些方法如addfirst(),removefirst(),addlast()等等可以用来实现如C中的堆栈,链表。(对于频繁使用插入与删除操作使用linkedlist是个不错的选择,对于经常进行索引操作则arrylist较好)。

       
HashSet(散列表),它实现了Set接口,也就意味着它的元素不能有重复值出现。并且在HashSet中没有get()方法,但可以通过iterator()来实现。要注意的是假如要在HasSet中存放一些对象,那么你得重定义hashCode()equals()二个方法来保不可以存放相同的内容的元素。对于hashcode()所返回的值,hashset用它来计算(通过特定的函数)该对象在内存中的存放位置;后者主要用来判断二个对象的内容是否相等而返回对应的boolen型。
      
TreeSet,主要用来对元素进行排序操作,假如要往其中添加对象,则对象得实现Comparable接口。(假如不要对元素排序,则一般可选用HashSet)。

       HashMap,主要特点是存放的一个键值对,一些有用的方法是可返回视图(我觉得可以把它理解为一个集合)如:keyset(),values(),entyset()等。
       关于对HashMap的小步深入理解:
       HashMap是由键值对组成的,关于HashMap有二点要注意:1. 它的键只能是一个Object对象。 2. 当二个HashMapequals方法比较时,实际的比较是它的Key,而与Value无关。

       HashMap的主要特点是其底层的物理存放与查找用到了hash函数相关的原理。根据java窗口的查找原理,查找最快的应该是由数组经过工具类ArraysArrays.sort方法排序后,再用此工具类的Arrays.binarySearch方法进行查找。对于HashMap的数据查找就是用这个原理实现的,另外由于数组的致命缺点就是它是定长的,而HashMap却是可以动态增加,所以查找过程其实不是将Key本身放在一个Object[]的数组中,而是将与Key有密切相关的信息做为索引Object[]数组的下标,然后根据此下标去Object[]数组中查找数据,这个所谓密切相关的信息就是通过Key.hashCode()函数所产生的数字。可想而知,当HashMap中的Key很多时,各Key所产生的hashCode肯定会有重合的现象发生,为了防止此情况发生,所以根据这个索引在数组中得到的对象并不是最终要查找的数据,查到的其实是一个list列表,在这列表中列出了由于HashMap中的Key通过散列后具有相同hashCode的全部对像。可以想像得到,这个列表中的对像应该是相当少的。对于对Object[]数据下下标定位后,就得到了这个列表,接下来equals函数粉墨登场了,若能返回true则表示此对象已经存在,这时HashMap会用新的值覆盖旧值,若不存在则会做添加操作了。

       HashMap的初始化中,会涉及到二个比较重要的值,也是影响其性能的二个重要值:Object[]的长度(v1)Object[]中实际已经存放了多少object对象(v2)。在我们初始化HashMap时会有:HashMap(int initialCapacity, float loadFactor) 这个方法,initialCapacity表示object[]的初始化长度,loadFactor表示允许此在Object[]存放数据的百分比(loadFactorv2/v1),系统默认的是0.75(也就是可以存放占object[]数组3/4的数据)。当HashMap里的数据不断增加时,它会自动地按数量级扩展Object[]的长度(应该尽量阻止Object[]的自动增加,这样不但消费资源对于以后的查找、插入操作也不利)。
HashMap
结论:对于Key一定要实现hashCode() and equals方法,且尽量要让hashCode散布得均匀。这样才能充分利用Object[]数组,不然,会导致Object[]得不到充分利用,而在Object[index]具体对应的对象list列表中存放很多Key对像,而在list中进行查找操作是比较耗时的。

       根据以上原理,HashMap的简单实现:
import java.util.*;
import com.bruceeckel.util.*;

public class SimpleHashMap extends AbstractMap {
  // Choose a prime number for the hash table
  // size, to achieve a uniform distribution:
  private static final int SZ = 997;
  private LinkedList[] bucket = new LinkedList[SZ];
  public Object put(Object key, Object value) {
    Object result = null;
    int index = key.hashCode() % SZ;
    if(index < 0) index = -index;
    if(bucket[index] == null)
      bucket[index] = new LinkedList();
    LinkedList pairs = bucket[index];
    MPair pair = new MPair(key, value);
    ListIterator it = pairs.listIterator();
    boolean found = false;
    while(it.hasNext()) {
      Object iPair = it.next();
      if(iPair.equals(pair)) {
        result = ((MPair)iPair).getValue();
        it.set(pair); // Replace old with new
        found = true;
        break;
      }
    }
    if(!found)
      bucket[index].add(pair);
    return result;
  }
  public Object get(Object key) {
    int index = key.hashCode() % SZ;
    if(index < 0) index = -index;
    if(bucket[index] == null) return null;
    LinkedList pairs = bucket[index];
    MPair match = new MPair(key, null);
    ListIterator it = pairs.listIterator();
    while(it.hasNext()) {
      Object iPair = it.next();
      if(iPair.equals(match))
        return ((MPair)iPair).getValue();
    }
    return null;
  }
  public Set entrySet() {
    Set entries = new HashSet();
    for(int i = 0; i < bucket.length; i++) {
      if(bucket[i] == null) continue;
      Iterator it = bucket[i].iterator();
      while(it.hasNext())
        entries.add(it.next());
    }
    return entries;
  }
  public static void main(String[] args) {
    SimpleHashMap m = new SimpleHashMap();
    Collections2.fill(m, Collections2.geography, 25);
    System.out.println(m);
  }
} ///:~


       
TreeMap,它与HashMap差不多,不过是增加了对元素的排序功能,所以运行速度也就当然没有hashmap来得快了。
         
以下是HashMap的一个实例(在对DB进行操作的时候很有用):

HashMap valueMap;
//this function just get key-value form DB ,defined by yourself
valueMap = commondb.getElementStringValues("COMMENT_ID", "content");
java.util.Set tempkeys = valueMap.entrySet();
            java.util.Iterator keys = tempkeys.iterator();
while(keys.hasNext())
                
{
                    java.util.Map.Entry me=(java.util.Map.Entry)keys.next();
String value = me.getValue();
int key = me.getKey();
}


       
要注意的是entrySet()所返回的每一个元素都是Map.Entry类型的!(Returns a collection view of the mappings contained in this map. Each element in the returned collection is a Map.Entry.)      
 
       Properties,继承于hashtable。这个东东相信我们比较的喜欢了(在i18n,ant中可以是常见得很),呵呵。它可以从外部导入属性文件。文件中的键值都是String类型。just like this:
        

company=study
author=Jkallen
copyright=2005-2006

       
         
操作如下:
       

import java.util.*;
import java.io.*;
class PropTest
{
    
public static void main(String[] args)
    
{
        
/**//*Properties pps=System.getProperties();
        pps.list(System.out);*/

        Properties pps=
new Properties();
        
try
        
{
            pps.load(
new FileInputStream("winsun.ini"));
            Enumeration 
enum=pps.propertyNames();
            
while(enum.hasMoreElements())
            
{
                String strKey=(String)
enum.nextElement();
                String strValue=pps.getProperty(strKey);
                
                System.out.println(strKey+"="+strValue);
            }
        }
        
catch(Exception e)
        
{
            e.printStackTrace();
        }
    }
}


       

其用法可以查看API文档呢。

        Java
中的集合容器确实不少呢...其中有些我们也许一直都用不到,(我也是查看了些相关的资料再加上自己的一些想法整理了一下,希望对相关朋友有用!)可是重要的是知道我们在实现一个功能时应该选用哪种集合类来实现就OK

 

 

 

数组数组和其它容器的区别主要有三方面:效率,类型,和保存基本类型的能力.在Java中,数组是一种效率很高的存储和随机访问对象引用序列的方式.数组是一 个简单的线性序列,因此访问速度很快,但也损失了其它一些特性.创建一个数组对象后,大小就固定了,如果空间不够,通常是再创建一个数组,然后把旧数组中 的所有引用移到新数组中.数组可可以保存基本类型,容器不行.
容器类不以具体的类型来处理对象,而是将所有的对象都以Object类型来处理,所以我们可以只创建一个容器,任意的Java对象都可以放进去.容器类可 以使用包装类(Integer,Double等),以便把基本类型放入其中. List Set Map 都可以自动调整容量,数组不能.

Collection表示一组对象,这些对象也称为collection的元素。一些 collection允许有重复的元素,而另一些则不允许。一些collection是有序的,而另一些则是无序的。JDK中不提供此接口的任何直接实 现,它提供更具体的子接口(如 Set 和 List)实现.

Map 将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射一个值.Map 接口提供三种collection视图,允许以键集、值集合或键值映射关系集的形式查看某个映射的内容。某些映射实现可明确保证其顺序,如 TreeMap(有序) 类;某些映射实现则不保证顺序,如 HashMap(无序) 类。Map可以像数组那样扩展成多维数组,只要把每个值也做成一个Map就行了.

Collection和Map是Java容器中的两种基本类型. 区别在于容器中每个位置保存的元素个数.Collection每个位置只能保存一个元素,包括List和Set.其中List以进入的顺序保存一组元素; 而Set中的元素不能重复.ArrayList是一种List,HashSet是一种Set,将元素添加入任意Collection都可以使用add() 方法.Map保存的是健值对.使用put()为Map添加元素,它需要一个健和一个值作参数.

ArrayList和LinkedList都实现了List接口,ArrayList底层由数组支持LinkedList由双向链表支持,因此,如果经常在表中插入或删除元素LinkedList比较适合,如果经常查询ArrayList比较适合.
Set的实现有TreeSet,HashSet,LinkedHashSet,HashSet查询速度最快,LinkedHashSet保持元素插入次序,TreeSet基于TreeMap,生成一个总是处于排序状态的Set.

  Collection<--List<--Vector
  Collection<--List<--ArrayList
  Collection<--List<--LinkedList
  Collection<--Set<--HashSet
  Collection<--Set<--HashSet<--LinkedHashSet
  Collection<--Set<--SortedSet<--TreeSet

Vector : 基于Array的List,其实就是封装了Array所不具备的一些功能方便我们使用,它不可能走入Array的限制。性能也就不可能超越Array。所以,在可能的情况下,我们要多运用Array。另外很重要的一点就是Vector“sychronized”的,这个也是Vector和ArrayList的唯一的区别。

ArrayList:同Vector一样是一个基于Array上的链表,但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些,但是当运行到多线程环境中时,可需要自己在管理线程的同步问题。

LinkedList:LinkedList不同于前面两种List,它不是基于Array的,所以不受Array性能的限制。它每一个节点(Node)都包含两方面的内容:1.节点本身的数据(data);2.下一个节点的信息(nextNode)。所以当对LinkedList做添加,删除动作的时候就不用像基于Array的List一样,必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了。这就是LinkedList的优势。

List总结:

1. 所有的List中只能容纳单个不同类型的对象组成的表,而不是Key-Value键值对。例如:[ tom,1,c ];

2. 所有的List中可以有相同的元素,例如Vector中可以有 [ tom,koo,too,koo ];

3. 所有的List中可以有null元素,例如[ tom,null,1 ];

4. 基于Array的List(Vector,ArrayList)适合查询,而LinkedList(链表)适合添加,删除操作。

HashSet:虽然Set同List都实现了Collection接口,但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的,这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。看看HashSet的add(Object obj)方法的实现就可以一目了然了。

  public boolean add(Object obj)
  {
  return map.put(obj, PRESENT) == null;
  }

这个也是为什么在Set中不能像在List中一样有重复的项的根本原因,因为HashMap的key是不能有重复的。

LinkedHashSet:HashSet的一个子类,一个链表。

TreeSet:SortedSet的子类,它不同于HashSet的根本就是TreeSet是有序的。它是通过SortedMap来实现的。

Set总结:

1. Set实现的基础是Map(HashMap);

2. Set中的元素是不能重复的,如果使用add(Object obj)方法添加已经存在的对象,则会覆盖前面的对象;

trace: http://hi.baidu.com/xusulong/blog/item/bc99048facd8eaebf01f36bd.html




List接口对Collection进行了简单的扩充,它的具体实现类常用的有ArrayList和LinkedList。你可以将任何东西放到一个List容器中,并在需要时从中取出。ArrayList从其命名中可以看出它是一种类似数组的形式进行存储,因此它的随机访问速度极快,而LinkedList的内部实现是链表,它适合于在链表中间需要频繁进行插入和删除操作。在具体应用时可以根据需要自由选择。前面说的Iterator只能对容器进行向前遍历,而ListIterator则继承了Iterator的思想,并提供了对List进行双向遍历的方法。 

Set接口也是Collection的一种扩展,而与List不同的时,在Set中的对象元素不能重复,也就是说你不能把同样的东西两次放入同一个Set容器中。它的常用具体实现有HashSet和TreeSet类。HashSet能快速定位一个元素,但是你放到HashSet中的对象需要实现hashCode()方法,它使用了前面说过的哈希码的算法。而TreeSet则将放入其中的元素按序存放,这就要求你放入其中的对象是可排序的,这就用到了集合框架提供的另外两个实用类Comparable和Comparator。一个类是可排序的,它就应该实现Comparable接口。有时多个类具有相同的排序算法,那就不需要在每分别重复定义相同的排序算法,只要实现Comparator接口即可。集合框架中还有两个很实用的公用类:Collections和Arrays。Collections提供了对一个Collection容器进行诸如排序、复制、查找和填充等一些非常有用的方法,Arrays则是对一个数组进行类似的操作。 


Map是一种把键对象和值对象进行关联的容器,而一个值对象又可以是一个Map,依次类推,这样就可形成一个多级映射。对于键对象来说,像Set一样,一个Map容器中的键对象不允许重复,这是为了保持查找结果的一致性;如果有两个键对象一样,那你想得到那个键对象所对应的值对象时就有问题了,可能你得到的并不是你想的那个值对象,结果会造成混乱,所以键的唯一性很重要,也是符合集合的性质的。当然在使用过程中,某个键所对应的值对象可能会发生变化,这时会按照最后一次修改的值对象与键对应。对于值对象则没有唯一性的要求。你可以将任意多个键都映射到一个值对象上,这不会发生任何问题(不过对你的使用却可能会造成不便,你不知道你得到的到底是那一个键所对应的值对象)。Map有两种比较常用的实现:HashMap和TreeMap。HashMap也用到了哈希码的算法,以便快速查找一个键,TreeMap则是对键按序存放,因此它便有一些扩展的方法,比如firstKey(),lastKey()等,你还可以从TreeMap中指定一个范围以取得其子Map。键和值的关联很简单,用pub(Object key,Object value)方法即可将一个键与一个值对象相关联。用get(Object key)可得到与此key对象所对应的值对象。


 

发布了23 篇原创文章 · 获赞 18 · 访问量 59万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览