男女污污视频在线观看,亚洲每日在线,中文字幕一区二区三区乱码在线

教你如何�q�速秒杀掉：99%的�v量数据处理面试题 .

abin — Thu, 06 Dec 2012 07:06:00 GMT

摘要: 教你如何�q�速秒杀掉：99%的�v量数据处理面试题作者：July出处�Q�结构之法算法之道blog 前言一般而言�Q�标题含�?#8220;�U�杀”�Q?#8220;99%”�Q?#8220;史上最�?最�?#8221;�{�词汇的往往都脱不了哗众取宠之嫌�Q�但�q�一步来�Ԍ��如果读者读�|�此文，却无��M��收获�Q�那么，我也�?.. 阅读全文

abin 2012-12-06 15:06 发表评论

Java Map,List,Vector,Set遍历

abin — Mon, 19 Nov 2012 16:19:00 GMT

package chn.lass.liu.collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MapTest {
public static Map createMap(){
  Map map=new HashMap();
  map.put("a", "111");
  map.put("b", "222");
  return map;
}
public static void parseMap(Map map){
  for(Iterator it=map.entrySet().iterator();it.hasNext();){
   Map.Entry entry=(Map.Entry)it.next();
   System.out.println("key="+entry.getKey());
   System.out.println("value="+entry.getValue());
   if("a".equals(entry.getKey())){
    it.remove();
   }
  }
  for(Iterator it=map.entrySet().iterator();it.hasNext();){
   Map.Entry entry=(Map.Entry)it.next();
   System.out.println("key1="+entry.getKey());
   System.out.println("value1="+entry.getValue());
  }
}
public static void main(String[] args) {
  Map map=createMap();
  parseMap(map);
}
}

package chn.lass.liu.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListTest {
public static List createList(){
  List list=new ArrayList();
  for(int i=0;i<5;i++){
   list.add(""+i);
  }
  return list;
}
public static void ParseList(List list){
  for(Iterator it=list.iterator();it.hasNext();){
   String its=(String)it.next();
   System.out.println("list is:"+its);
   it.remove();
  }
}
public static void main(String[] args) {
   List list=createList();
   ParseList(list);
}
}

package chn.lass.liu.collection;

import java.util.Iterator;
import java.util.Vector;

public class VectorTest {
public static Vector createVector(){
  Vector vector=new Vector();
  vector.addElement("aa");
  vector.addElement("bb");
  return vector;
}
public static void parseVector(Vector vector){
  for(Iterator it=vector.iterator();it.hasNext();){
   String its=(String)it.next();
   System.out.println("its is:"+its);
  }
}
public static void main(String[] args) {
  Vector vector=createVector();
  parseVector(vector);
}
}

package chn.lass.liu.collection;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetTest {
public static Set createSet(){
  Set set=new HashSet();
  set.add("a");
  set.add("b");
  return set;
}
public static void parseSet(Set set){
  for(Iterator it=set.iterator();it.hasNext();){
   String its=(String)it.next();
   System.out.println("its is:"+its);
  }
}
public static void main(String[] args) {
  Set set=createSet();
  parseSet(set);
}
}

abin 2012-11-20 00:19 发表评论

Java 全局队列

abin — Mon, 20 Aug 2012 04:25:00 GMT

package com.abin.lee.queue;

import java.util.Queue;

public interface IMakeQueue {
public void addQueue(Object obj);
public boolean hasQueue();
public Object getQueueHeader();
public int queueSize();
public boolean delQueue();
}

package com.abin.lee.queue;

import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;

public class MakeQueue implements IMakeQueue{
private static Queue queue=new LinkedBlockingQueue();

public void addQueue(Object obj) {
queue.offer(obj);
}

public boolean hasQueue() {
  boolean flag=false;
  if(queue.isEmpty()){
   flag=true;
  }
  return flag;
}

public Object getQueueHeader() {
Object obj=queue.peek();
return obj;
}

public int queueSize() {
int queueSize=queue.size();
return queueSize;
}

public boolean delQueue() {
  boolean flag=false;
  Object obj=queue.poll();
  if(obj!=null){
   flag=true;
  }
  return flag;
}

}

package com.abin.lee.queue;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
*
* 获取spring容器�Q�以讉K��容器中定义的其他bean
*
* @author lyltiger
* @since MOSTsView 3.0 2009-11-16
*/
public class SpringContextUtil implements ApplicationContextAware {

// Spring应用上下文环�?br /> private static ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"com/abin/lee/spring/applicationContext-queue.xml");

/**
* 实现ApplicationContextAware接口的回调方法，讄��上下文环�?br /> *
* @param applicationContext
*/
public void setApplicationContext(ApplicationContext applicationContext) {
SpringContextUtil.applicationContext = applicationContext;
}

/**
* @return ApplicationContext
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}

/**
* 获取对象 �q�里重写了bean�Ҏ(gu��)��Q��v主要作用
*
* @param name
* @return Object 一个以所�l�名字注册的bean的实�?br /> * @throws BeansException
*/
public static Object getBean(String name) throws BeansException {
return applicationContext.getBean(name);
}

}

package com.abin.lee.queue;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class QueueServlet extends HttpServlet{

protected void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  Map map=request.getParameterMap();
  String name1=(String)((Object[])map.get("name1"))[0];
  String name2=(String)((Object[])map.get("name2"))[0];
  MakeQueue makeQueue = (MakeQueue)SpringContextUtil.getBean("makeQueue");//bean的名�U?
  System.out.println(makeQueue.queueSize());
  makeQueue.addQueue(name1);
  makeQueue.addQueue(name2);
  System.out.println(makeQueue.queueSize());

  ServletOutputStream out=response.getOutputStream();
  BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out));
  writer.write("success");
  writer.flush();
  writer.close();
}
}

package com.abin.lee.spring;

import java.util.ArrayList;
import java.util.List;

import junit.framework.TestCase;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

public class SpringUnit extends TestCase {
private static final String HTTP_URL="http://localhost:1010/WebService/servlet/QueueServlet";
public void testBean() {
  HttpClient client=new DefaultHttpClient();
  HttpPost post=new HttpPost(HTTP_URL);
  try {
   List nvps=new ArrayList();
   nvps.add(new BasicNameValuePair("name1", "lee"));
   nvps.add(new BasicNameValuePair("name2", "abin"));
   post.setEntity(new UrlEncodedFormEntity(nvps,HTTP.UTF_8));
   HttpResponse response=client.execute(post);
   HttpEntity entity=response.getEntity();
   String result=EntityUtils.toString(entity);
   System.out.println("result="+result);
  } catch (Exception e) {
   e.printStackTrace();
  }
}
}

xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
           http://www.springframework.org/schema/context

abin 2012-08-20 12:25 发表评论

Java 遍历嵌套Map

abin — Sat, 18 Aug 2012 07:51:00 GMT

package com.abin.lee.sort;

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class CollectionIterator {
/**
* 创徏二维MAP
*
* @return
*/
public static Map> createMap() {
  Map> map2 = Collections
    .synchronizedMap(new HashMap>());
  Map map1 = Collections
    .synchronizedMap(new HashMap());
  Map map3 = Collections
    .synchronizedMap(new HashMap());
  map1.put("abin", "varyall");
  map1.put("abing", "boy");
  map1.put("peng", "boy");
  map1.put("pengzi", "man");
  map2.put("user", map1);

  map3.put("chinese", "beijing");
  map3.put("china", "shanghai");
  map2.put("contury", map3);

  return map2;
}
/**
* 解析二维MAP
* @param map
* @return
*/

public static String getMap(Map> map) {
  for (Iterator iterator = map.entrySet().iterator(); iterator.hasNext();) {
   Map.Entry entry=(Map.Entry)iterator.next();
   //先遍历一�l�map
   System.out.println("one map name="+entry.getKey());
   System.out.println("one map name="+entry.getValue());
   Map map1=(Map)entry.getValue();
   if(entry.getValue() instanceof Map){
    for(Iterator it=map1.entrySet().iterator();it.hasNext();){
     Map.Entry entry2=(Map.Entry)it.next();
     //再遍历二�l�map
     System.out.println("two map name="+entry2.getKey());
     System.out.println("two map name="+entry2.getValue());
    }
   }
  }

  return null;
}
public static void main(String[] args) {
  Map> map=createMap();
  getMap(map);

}
}

abin 2012-08-18 15:51 发表评论

Java容器集合�cȝ��区别用法

abin — Fri, 23 Mar 2012 04:31:00 GMT

Java容器集合�cȝ��区别用法

Set,List,Map,Vector,ArrayList的区�?
JAVA的容�?--List,Map,Set
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
　　Collection是最基本的集合接口，一个Collection代表一�l�Object�Q�即Collection的元素（Elements�Q�。一�?Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接��承自Collection的类�Q�Java SDK提供的类都是�l�承自Collection�?#8220;子接�?#8221;如List和Set�?
　　所有实现Collection接口的类都必��L��供两个标准的构造函敎ͼ�无参数的构造函数用于创��Z��个空的Collection�Q�有一�?Collection参数的构造函数用于创��Z��个新的Collection�Q�这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection�?
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个�P代子�Q��用该�q�代子即可逐一讉K��Collection中每一个元素。典型的用法如下�Q?
　　　　Iterator it = collection.iterator(); // 获得一个�P代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元�?
　　　　}
　　由Collection接口�z��的两个接口是List和Set�?
List接口
　　List是有序的Collection�Q��用此接口能够�_��的控制每个元素插入的位置。用戯��够��用烦引（元素在List中的位置�Q�类��g��数组下标�Q�来讉K��List中的元素�Q�这�c�M��于Java的数�l��?
和下面要提到的Set不同�Q�List允许有相同的元素�?
　　除了��h��Collection接口必备的iterator()�Ҏ(gu��)��外，List�q�提供一个listIterator()�Ҏ(gu��)��Q�返回一�?ListIterator接口�Q�和标准的Iterator接口相比�Q�ListIterator多了一些add()之类的方法，允许��d��Q�删除，讑֮�元素�Q�还能向前或向后遍历�?
　　实现List接口的常用类有LinkedList�Q�ArrayList�Q�Vector和Stack�?
LinkedList�c?
　　LinkedList实现了List接口�Q�允许null元素。此外LinkedList提供额外的get�Q�remove�Q�insert�Ҏ(gu��)��?LinkedList的首部或��N��。这些操作��LinkedList可被用作堆栈�Q�stack�Q�，队列�Q�queue�Q�或双向队列�Q�deque�Q��?
　　注意LinkedList没有同步�Ҏ(gu��)��。如果多个线�E�同时访问一个List�Q�则必须自己实现讉K��同步。一�U�解��x��法是在创建List时构造一个同步的List�Q?
　　　　List list = Collections.synchronizedList(new LinkedList(...));
ArrayList�c?
　　ArrayList实现了可变大��的数组。它允许所有元素，包括null。ArrayList没有同步�?
size�Q�isEmpty�Q�get�Q�set�Ҏ(gu��)��q�行旉��为常数。但是add�Ҏ(gu��)��开销为分摊的常数�Q�添加n个元素需要O(n)的时间。其他的�Ҏ(gu��)��q�行旉��为线性�?
　　每个ArrayList实例都有一个容量（Capacity�Q�，即用于存储元素的数组的大��。这个容量可随着不断��d��新元素而自动增加，但是增长��法�q�没有定义。当需要插入大量元素时�Q�在插入前可以调用ensureCapacity�Ҏ(gu��)��来增加ArrayList的容量以提高插入效率�?
　　和LinkedList一��P��ArrayList也是非同步的�Q�unsynchronized�Q��?
Vector�c?
　　Vector非常�c�M��ArrayList�Q�但是Vector是同步的。由Vector创徏的Iterator�Q�虽然和ArrayList创徏�?Iterator是同一接口�Q�但是，因�ؓVector是同步的�Q�当一个Iterator被创��且正在被��用，另一个线�E�改变了Vector的状态（例如�Q�添加或删除了一些元素）�Q�这时调用Iterator的方法时��抛出ConcurrentModificationException�Q�因此必��L��莯��异常�?
Stack �c?
　　Stack�l�承自Vector�Q�实��C��个后�q�先出的堆栈。Stack提供5个额外的�Ҏ(gu��)��使得Vector得以被当作堆栈��用。基本的push和pop �Ҏ(gu��)��Q�还有peek�Ҏ(gu��)��得到栈顶的元素，empty�Ҏ(gu��)��试堆栈是否为空�Q�search�Ҏ(gu��)��一个元素在堆栈中的位置。Stack刚创建后是空栈�?
Set接口
　　Set是一�U�不包含重复的元素的Collection�Q�即��L��的两个元素e1和e2都有e1.equals(e2)=false�Q�Set最多有一个null元素�?
　　很明显，Set的构造函数有一个约束条�Ӟ��传入的Collection参数不能包含重复的元素�?
　　��h��意：必须��心操作可变对象�Q�Mutable Object�Q�。如果一个Set中的可变元素改变了自�w�状态导致Object.equals(Object)=true��导致一些问题�?
Map接口
　　��h��意，Map没有�l�承Collection接口�Q�Map提供key到value的映��。一个Map中不能包含相同的key�Q�每个key只能映射一�?value。Map接口提供3�U�集合的视图�Q�Map的内容可以被当作一�l�key集合�Q�一�l�value集合�Q�或者一�l�key-value映射�?
Hashtable�c?
　　Hashtable�l�承Map接口�Q�实��C��个key-value映射的哈希表。�Q何非�I�（non-null�Q�的对象都可作�ؓkey或者value�?
　　��d��数据使用put(key, value)�Q�取出数据��用get(key)�Q�这两个基本操作的时间开销为常数�?
Hashtable通过initial capacity和load factor两个参数调整性能。通常�~�省的load factor 0.75较好地实��C��旉��和空间的均衡。增大load factor可以节省�I�间但相应的查找旉��增大，�q�会影响像get和put�q�样的操作�?
使用Hashtable的简单示例如下，��?�Q?�Q?攑ֈ�Hashtable中，他们的key分别�?#8221;one”�Q?#8221;two”�Q?#8221;three”�Q?
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取��Z��个数�Q�比�?�Q�用相应的key�Q?
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　�׃��作�ؓkey的对象将通过计算其散列函数来��定与之对应的value的位�|�，因此��M��作�ؓkey的对象都必须实现hashCode和equals�Ҏ(gu��)��。hashCode和equals�Ҏ(gu��)��l�承自根�c�Object�Q�如果你用自定义的类当作key的话�Q�要相当��心�Q�按照散列函数的定义�Q�如果两个对象相同，即obj1.equals(obj2)=true�Q�则它们的hashCode必须相同�Q�但如果两个对象不同�Q�则它们的hashCode不一定不同，如果两个不同对象的hashCode相同�Q�这�U�现象称为冲�H�，冲突会导致操作哈希表的时间开销增大�Q�所以尽量定义好的hashCode()�Ҏ(gu��)��Q�能加快哈希表的操作�?
　　如果相同的对象有不同的hashCode�Q�对哈希表的操作会出现意想不到的�l�果�Q�期待的get�Ҏ(gu��)��q�回null�Q�，要避免这�U�问题，只需要牢��C��条：要同时复写equals�Ҏ(gu��)��和hashCode�Ҏ(gu��)��Q�而不要只写其中一个�?
　　Hashtable是同步的�?
HashMap�c?
　　HashMap和Hashtable�c�M��Q�不同之处在于HashMap是非同步的，�q�且允许null�Q�即null value和null key。，但是��HashMap视�ؓCollection�Ӟ��values()�Ҏ(gu��)��可返回Collection�Q�，其�P代子操作旉��开销和HashMap 的容量成比例。因此，如果�q�代操作的性能相当重要的话�Q�不要将HashMap的初始化定w��讑־��q�高�Q�或者load factor�q�低�?
WeakHashMap�c?
　　WeakHashMap是一�U�改�q�的HashMap�Q�它对key实行“弱引�?#8221;�Q�如果一个key不再被外部所引用�Q�那么该key可以被GC回收�?
�ȝ��
　　如果涉及到堆栈，队列�{�操作，应该考虑用List�Q�对于需要快速插入，删除元素�Q�应该��用LinkedList�Q�如果需要快速随��问元素，应该使用ArrayList�?
　　如果�E�序在单�U�程环境中，或者访问仅仅在一个线�E�中�q�行�Q�考虑非同步的�c�，其效率较高，如果多个�U�程可能同时操作一个类�Q�应该��用同步的�c�R�?
　　要特别注意对哈希表的操作�Q�作为key的对象要正确复写equals和hashCode�Ҏ(gu��)��?
　　��量�q�回接口而非实际的类型，如返回List而非ArrayList�Q�这样如果以后需要将ArrayList换成LinkedList�Ӟ��客户端代码不用改变。这��是针对抽象�~�程�?
Java 集合�c?map set list arraylist hashmap hashtable(�?
Vector的方法都是同步的(Synchronized),是线�E�安全的(thread-safe)�Q�而ArrayList的方法不是，�׃��U�程的同步必然要影响性能�Q�因�?ArrayList的性能比Vector好�?
当Vector或ArrayList中的元素��过它的初始大小�?Vector会将它的定w��d�?而ArrayList只增�?0%的大��，�q�样,ArrayList��有利于节约内存�I�间�?
Hashtable和HashMap
它们的性能斚w��的比较类�?Vector和ArrayList�Q�比如Hashtable的方法是同步�?而HashMap的不是�?
ArrayList和LinkedList
�?于处理一列数据项,Java提供了两个类ArrayList和LinkedList,ArrayList的内部实现是��Z��内部数组Object[],所�?从概念上�?它更象数�l�，但LinkedList的内部实现是��Z��一�l�连接的记录,所�?它更象一个链表结构，所�?它们在性能上有很大的差别�?nbsp;
�Q?�Q?从上面的分析可知,在ArrayList的前面或中间插入数据�?你必��d��其后的所有数据相应的后移,�q�样必然要花费较多时��_��所�?当你的操作是在一�?数据的后面添加数据而不是在前面或中�?�q�且需要随机地讉K��其中的元素时,使用ArrayList会提供比较好的性能�?nbsp;
�Q?�Q�而访问链表中的某个元素时,��必��M��链表的一端开始沿着�q�接方向一个一个元素地��L��?直到扑ֈ�所需的元素�ؓ止，所�?当你的操作是在一列数据的前面或中间添加或删除数据,�q�且按照��序讉K��其中的元素时,��应该��用LinkedList了�?nbsp;
�Q?�Q�如果在�~�程�?1�Q?两种情�Ş交替出现,�q�时,你可以考虑使用List�q�样的通用接口,而不用关心具体的实现�Q�在具体的情形下,它的性能由具体的实现来保证�?
讄��集合�cȝ��初始大小
在Java 集合框架中的大部分类的大��是可以随着元素个数的增加而相应的增加的，我们��g��不用兛_��它的初始大小,但如果我们考虑�cȝ��性能问题�?��׃��定要考虑��可�?地设�|�好集合对象的初始大��?�q�将大大提高代码的性能�Q�比�?Hashtable�~�省的初始大��ؓ101,载入因子�?.75,卛_��果其中的元素个数��过 75�?它就必须增加大小�q��新组�l�元素，所�?如果你知道在创徏一个新的Hashtable对象时就知道元素的确切数目如�?10,那么,��应��其初始大小设�ؓ110/0.75=148,�q�样,��可以避免重新组�l�内存�ƈ增加大小�?
特别要理解的�Q?
Hashtable�c?
　　Hashtable�l�承Map接口�Q�实��C��个key-value映射的哈希表。�Q何非�I�（non-null�Q�的对象都可作�ؓkey或者value�?
　　��d��数据使用put(key, value)�Q�取出数据��用get(key)�Q�这两个基本操作的时间开销为常数�?
Hashtable 通过initial capacity和load factor两个参数调整性能。通常�~�省的load factor 0.75较好地实��C��旉��和空间的均衡。增大load factor可以节省�I�间但相应的查找旉��增大，�q�会影响像get和put�q�样的操作�?
使用Hashtable的简单示例如下，��?�Q?�Q?攑ֈ�Hashtable中，他们的key分别�?#8221;one”�Q?#8221;two”�Q?#8221;three”�Q?
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取��Z��个数�Q�比�?�Q�用相应的key�Q?
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　�׃��作�ؓkey的对象将通过计算其散列函数来��定与之对应的value的位�|�，因此��M��作�ؓkey的对象都必须实现hashCode和equals�?法。hashCode和equals�Ҏ(gu��)��l�承自根�c�Object�Q�如果你用自定义的类当作key的话�Q�要相当��心�Q�按照散列函数的定义�Q�如果两个对象相同，即obj1.equals(obj2)=true�Q�则它们的hashCode必须相同�Q�但如果两个对象不同�Q�则它们的hashCode不一定不同，�?果两个不同对象的hashCode相同�Q�这�U�现象称为冲�H�，冲突会导致操作哈希表的时间开销增大�Q�所以尽量定义好的hashCode()�Ҏ(gu��)��Q�能加快哈希表的操作�?
　　如果相同的对象有不同的hashCode�Q�对哈希表的操作会出现意想不到的�l�果�Q�期待的get�Ҏ(gu��)��q�回null�Q�，要避免这�U�问题，只需要牢��C��条：要同时复写equals�Ҏ(gu��)��和hashCode�Ҏ(gu��)��Q�而不要只写其中一个�?
　　Hashtable是同步的�?
HashMap�c?
　　HashMap和Hashtable�c�M��Q�不同之处在于HashMap是非同步的，�q�且允许null�Q�即null value和null key。，�?是将HashMap视�ؓCollection�Ӟ��values()�Ҏ(gu��)��可返回Collection�Q�，其�P代子操作旉��开销和HashMap的容量成�?例。因此，如果�q�代操作的性能相当重要的话�Q�不要将HashMap的初始化定w��讑־��q�高�Q�或者load factor�q�低�?
LinkedList�c?
　　LinkedList实现了List接口�Q�允许null元素。此外LinkedList提供额外的get�Q�remove�Q�insert�Ҏ(gu��)��?LinkedList的首部或��N��。这些操作��LinkedList可被用作堆栈�Q�stack�Q�，队列�Q�queue�Q�或双向队列�Q�deque�Q��?
　　注意LinkedList没有同步�Ҏ(gu��)��。如果多个线�E�同时访问一个List�Q�则必须自己实现讉K��同步。一�U�解��x��法是在创建List时构造一个同步的List�Q?
　　　　List list = Collections.synchronizedList(new LinkedList(...));
ArrayList�c?
　　ArrayList实现了可变大��的数组。它允许所有元素，包括null。ArrayList没有同步�?
size�Q�isEmpty�Q�get�Q�set�Ҏ(gu��)��q�行旉��为常数。但是add�Ҏ(gu��)��开销为分摊的常数�Q�添加n个元素需要O(n)的时间。其他的�Ҏ(gu��)��q�行旉��为线性�?
　　每个ArrayList实例都有一个容量（Capacity�Q�，即用于存储元素的数组的大��。这个容量可随着不断��d��新元素而自动增加，但是增长��法�q?没有定义。当需要插入大量元素时�Q�在插入前可以调用ensureCapacity�Ҏ(gu��)��来增加ArrayList的容量以提高插入效率�?
　　和LinkedList一��P��ArrayList也是非同步的�Q�unsynchronized�Q��?
Vector�c?
　　Vector非常�c�M��ArrayList�Q�但是Vector是同步的。由Vector创徏的Iterator�Q�虽然和ArrayList创徏�?Iterator是同一接口�Q�但是，因�ؓVector是同步的�Q�当一个Iterator被创��且正在被��用，另一个线�E�改变了Vector的状态（�?如，��d��或删除了一些元素）�Q�这时调用Iterator的方法时��抛出ConcurrentModificationException�Q�因此必��L��莯�� 异常�?
�l�说Java之util�c?
�U�性表�Q�链表，哈希表是常用的数据结构，在进行Java开发时�Q�JDK已经为我们提供了一�p�d��相应的类来实现基本的数据�l�构。这些类均在java.util包中。本文试��N��过��单的描述�Q�向读者阐�q�各个类的作用以及如何正��用这些类�?
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
　　Collection是最基本的集合接口，一个Collection代表一�l�Object�Q�即Collection的元素（Elements�Q�。一�?Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接��承自Collection的类�Q�Java SDK提供的类都是�l�承自Collection�?#8220;子接�?#8221;如List和Set�?br />　　所有实现Collection接口的类都必��L��供两个标准的构造函敎ͼ�无参数的构造函数用于创��Z��个空的Collection�Q�有一个Collection参数的构造函数用于创��Z��个新的Collection�Q�这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection�?br />　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个�P代子�Q��用该�q�代子即可逐一讉K��Collection中每一个元素。典型的用法如下�Q?br />　　　　Iterator it = collection.iterator(); // 获得一个�P代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元�?br />　　　　}
　　由Collection接口�z��的两个接口是List和Set�?
List接口
　　List是有序的Collection�Q��用此接口能够�_��的控制每个元素插入的位置。用戯��够��用烦引（元素在List中的位置�Q�类��g��数组下标�Q�来讉K��List中的元素�Q�这�c�M��于Java的数�l��?br />和下面要提到的Set不同�Q�List允许有相同的元素�?br />　　除了��h��Collection接口必备的iterator()�Ҏ(gu��)��外，List�q�提供一个listIterator()�Ҏ(gu��)��Q�返回一�?ListIterator接口�Q�和标准的Iterator接口相比�Q�ListIterator多了一些add()之类的方法，允许��d��Q�删除，讑֮�元素�Q?�q�能向前或向后遍历�?br />　　实现List接口的常用类有LinkedList�Q�ArrayList�Q�Vector和Stack�?
LinkedList�c?/strong>
　　LinkedList实现了List接口�Q�允许null元素。此外LinkedList提供额外的get�Q�remove�Q�insert�Ҏ(gu��)��?LinkedList的首部或��N��。这些操作��LinkedList可被用作堆栈�Q�stack�Q�，队列�Q�queue�Q�或双向队列�Q�deque�Q��?br />　　注意LinkedList没有同步�Ҏ(gu��)��。如果多个线�E�同时访问一个List�Q�则必须自己实现讉K��同步。一�U�解��x��法是在创建List时构造一个同步的List�Q?br />　　　　List list = Collections.synchronizedList(new LinkedList(...));
ArrayList�c?/strong>
　　ArrayList实现了可变大��的数组。它允许所有元素，包括null。ArrayList没有同步�?br />size�Q�isEmpty�Q�get�Q�set�Ҏ(gu��)��q�行旉��为常数。但是add�Ҏ(gu��)��开销为分摊的常数�Q�添加n个元素需要O(n)的时间。其他的�Ҏ(gu��)��q�行旉��为线性�?br />　　每个ArrayList实例都有一个容量（Capacity�Q�，即用于存储元素的数组的大��。这个容量可随着不断��d��新元素而自动增加，但是增长��法�q?没有定义。当需要插入大量元素时�Q�在插入前可以调用ensureCapacity�Ҏ(gu��)��来增加ArrayList的容量以提高插入效率�?br />　　和LinkedList一��P��ArrayList也是非同步的�Q�unsynchronized�Q��?
Vector�c?/strong>
　　Vector非常�c�M��ArrayList�Q�但是Vector是同步的。由Vector创徏的Iterator�Q�虽然和ArrayList创徏�?Iterator是同一接口�Q�但是，因�ؓVector是同步的�Q�当一个Iterator被创��且正在被��用，另一个线�E�改变了Vector的状态（�?如，��d��或删除了一些元素）�Q�这时调用Iterator的方法时��抛出ConcurrentModificationException�Q�因此必��L��莯�� 异常�?
Stack �c?/strong>
　　 Stack�l�承自Vector�Q�实��C��个后�q�先出的堆栈。Stack提供5个额外的�Ҏ(gu��)��使得Vector得以被当作堆栈��用。基本的push和pop�?法，�q�有peek�Ҏ(gu��)��得到栈顶的元素，empty�Ҏ(gu��)��试堆栈是否为空�Q�search�Ҏ(gu��)��一个元素在堆栈中的位置。Stack刚创建后是空栈�?
Set接口
　　Set是一�U�不包含重复的元素的Collection�Q�即��L��的两个元素e1和e2都有e1.equals(e2)=false�Q�Set最多有一个null元素�?br />　　很明显，Set的构造函数有一个约束条�Ӟ��传入的Collection参数不能包含重复的元素�?br />　　��h��意：必须��心操作可变对象�Q�Mutable Object�Q�。如果一个Set中的可变元素改变了自�w�状态导致Object.equals(Object)=true��导致一些问题�?
Map接口
　　��h��意，Map没有�l�承Collection接口�Q�Map提供key到value的映��。一个Map中不能包含相同的key�Q�每个key只能映射一�?value。Map接口提供3�U�集合的视图�Q�Map的内容可以被当作一�l�key集合�Q�一�l�value集合�Q�或者一�l�key-value映射�?
Hashtable�c?/strong>
　　Hashtable�l�承Map接口�Q�实��C��个key-value映射的哈希表。�Q何非�I�（non-null�Q�的对象都可作�ؓkey或者value�?br />　　��d��数据使用put(key, value)�Q�取出数据��用get(key)�Q�这两个基本操作的时间开销为常数�?br />Hashtable 通过initial capacity和load factor两个参数调整性能。通常�~�省的load factor 0.75较好地实��C��旉��和空间的均衡。增大load factor可以节省�I�间但相应的查找旉��增大，�q�会影响像get和put�q�样的操作�?br />使用Hashtable的简单示例如下，��?�Q?�Q?攑ֈ�Hashtable中，他们的key分别�?#8221;one”�Q?#8221;two”�Q?#8221;three”�Q?br />　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取��Z��个数�Q�比�?�Q�用相应的key�Q?br />　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　�׃��作�ؓkey的对象将通过计算其散列函数来��定与之对应的value的位�|�，因此��M��作�ؓkey的对象都必须实现hashCode和equals�?法。hashCode和equals�Ҏ(gu��)��l�承自根�c�Object�Q�如果你用自定义的类当作key的话�Q�要相当��心�Q�按照散列函数的定义�Q�如果两个对象相同，即obj1.equals(obj2)=true�Q�则它们的hashCode必须相同�Q�但如果两个对象不同�Q�则它们的hashCode不一定不同，�?果两个不同对象的hashCode相同�Q�这�U�现象称为冲�H�，冲突会导致操作哈希表的时间开销增大�Q�所以尽量定义好的hashCode()�Ҏ(gu��)��Q�能加快哈希表的操作�?br />　　如果相同的对象有不同的hashCode�Q�对哈希表的操作会出现意想不到的�l�果�Q�期待的get�Ҏ(gu��)��q�回null�Q�，要避免这�U�问题，只需要牢��C��条：要同时复写equals�Ҏ(gu��)��和hashCode�Ҏ(gu��)��Q�而不要只写其中一个�?br />　　Hashtable是同步的�?
HashMap�c?/strong>
　　HashMap和Hashtable�c�M��Q�不同之处在于HashMap是非同步的，�q�且允许null�Q�即null value和null key。，但是��HashMap视�ؓCollection�Ӟ��values()�Ҏ(gu��)��可返回Collection�Q�，其�P代子操作旉��开销和HashMap 的容量成比例。因此，如果�q�代操作的性能相当重要的话�Q�不要将HashMap的初始化定w��讑־��q�高�Q�或者load factor�q�低�?
WeakHashMap�c?/strong>
　　WeakHashMap是一�U�改�q�的HashMap�Q�它对key实行“弱引�?#8221;�Q�如果一个key不再被外部所引用�Q�那么该key可以被GC回收�?
�ȝ��
　　如果涉及到堆栈，队列�{�操作，应该考虑用List�Q�对于需要快速插入，删除元素�Q�应该��用LinkedList�Q�如果需要快速随��问元素，应该使用ArrayList�?br />　　如果�E�序在单�U�程环境中，或者访问仅仅在一个线�E�中�q�行�Q�考虑非同步的�c�，其效率较高，如果多个�U�程可能同时操作一个类�Q�应该��用同步的�c�R�?br />　　要特别注意对哈希表的操作�Q�作为key的对象要正确复写equals和hashCode�Ҏ(gu��)��?br />　　��量�q�回接口而非实际的类型，如返回List而非ArrayList�Q�这样如果以后需要将ArrayList换成LinkedList�Ӟ��客户端代码不用改变。这��是针对抽象�~�程�?

abin 2012-03-23 12:31 发表评论

abin — Fri, 16 Mar 2012 04:28:00 GMT

1. ArrayList概述�Q?/span>

ArrayList是List接口的可变数�l�的实现。实��C��所有可选列表操作，�q�允许包�?null 在内的所有元素。除了实�?List 接口外，此类�q�提供一些方法来操作内部用来存储列表的数�l�的大小�?br /> 每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大��。它��L��臛_��{�于列表的大��。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，因此�Q�如果可预知数据量的多少�Q�可在构造ArrayList时指定其定w��。在��d��大量元素前，应用�E�序也可以��用ensureCapacity操作来增加ArrayList实例的容量，�q�可以减��递增式再分配的数量�?
注意�Q�此实现不是同步的。如果多个线�E�同时访问一个ArrayList实例�Q�而其中至��一个线�E�从�l�构上修改了列表�Q�那么它必须保持外部同步�?/p>

2. ArrayList的实玎ͼ�

对于ArrayList而言�Q�它实现List接口、底层��用数�l�保存所有元素。其操作基本上是�Ҏ(gu��)��l�的操作。下面我们来分析ArrayList的源代码�Q?/p>

1) 底层使用数组实现�Q?/span>

Java代码

private transient Object[] elementData;

2) 构造方法：
ArrayList提供了三�U�方式的构造器�Q�可以构造一个默认初始容量�ؓ10的空列表、构造一个指定初始容量的�I�列表以及构造一个包含指定collection的元素的列表�Q�这些元素按照该collection的�P代器�q�回它们的顺序排列的�?/p>

Java代码

public ArrayList() {
this(10);
}
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
this.elementData = new Object[initialCapacity];
}
public ArrayList(Collectionextends E> c) {
elementData = c.toArray();
size = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}

3) 存储�Q?/span>
ArrayList提供了set(int index, E element)、add(E e)、add(int index, E element)、addAll(Collection c)、addAll(int index, Collection c)�q�些��d��元素的方法。下面我们一一讲解�Q?/p>

Java代码

// 用指定的元素替代此列表中指定位置上的元素�Q��ƈ�q�回以前位于该位�|�上的元素�?/span>
public E set(int index, E element) {
RangeCheck(index);
E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}

Java代码

// ��指定的元素��d��到此列表的尾部�?/span>
public boolean add(E e) {
ensureCapacity(size + 1);
elementData[size++] = e;
return true;
}

Java代码

// ��指定的元素插入此列表中的指定位�|��?/span>
// 如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后�l�元素（��其索引�?�Q��?/span>
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
// 如果数组长度不��Q�将�q�行扩容�?/span>
ensureCapacity(size+1); // Increments modCount!!
// ��?nbsp;elementData中从Index位置开始、长度�ؓsize-index的元素，
// 拯��C��下标为index+1位置开始的新的elementData数组中�?/span>
// 卛_��当前位于该位�|�的元素以及所有后�l�元素右�U�M��个位�|��?/span>
System.arraycopy(elementData, index, elementData, index + 1, size - index);
elementData[index] = element;
size++;
}

Java代码

// 按照指定collection的�P代器所�q�回的元素顺序，��该collection中的所有元素添加到此列表的��N��?/span>
public boolean addAll(Collectionextends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}

Java代码

// 从指定的位置开始，��指定collection中的所有元素插入到此列表中�?/span>
public boolean addAll(int index, Collectionextends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}

4) ��d��Q?/span>

Java代码

// �q�回此列表中指定位置上的元素�?/span>
public E get(int index) {
RangeCheck(index);
return (E) elementData[index];
}

5) 删除�Q?/span>
ArrayList提供了根据下标或者指定对象两�U�方式的删除功能。如下：

Java代码

// �U�除此列表中指定位置上的元素�?/span>
public E remove(int index) {
RangeCheck(index);
modCount++;
E oldValue = (E) elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
elementData[--size] = null; // Let gc do its work
return oldValue;
}

Java代码

// �U�除此列表中首次出现的指定元素（如果存在�Q�。这是应为ArrayList中允许存��N��复的元素�?/span>
public boolean remove(Object o) {
// �׃��ArrayList中允许存放null�Q�因此下面通过两种情况来分别处理�?/span>
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
// �c�M��remove(int index)�Q�移除列表中指定位置上的元素�?/span>
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}

注意�Q�从数组中移除元素的操作�Q�也会导致被�U�除的元素以后的所有元素的向左�U�d��一个位�|��?br /> 6) 调整数组定w��Q?/span>
从上面介�l�的向ArrayList中存储元素的代码中，我们看到�Q�每当向数组中添加元素时�Q�都要去��查添加后元素的个数是否会��出当前数组的长度，如果��?出，数组��会�q�行扩容�Q�以满��d��数据的需求。数�l�扩定w��过一个公开的方法ensureCapacity(int minCapacity)来实现。在实际��d��大量元素前，我也可以使用ensureCapacity来手动增加ArrayList实例的容量，以减��递增式再分配的数量�?/p>

Java代码

public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
}

从上�q�C��码中可以看出�Q�数�l�进行扩�Ҏ(gu��)��Q�会��老数�l�中的元素重新拷贝一份到新的数组中，每次数组定w��的增长大�U�是其原定w��?.5倍。这�U�操作的代�h(hu��n)是很高的�Q�因此在实际使用�Ӟ��我们应该��量避免数组定w��的扩张。当我们可预知要保存的元素的多少�Ӟ��要在构造ArrayList实例�Ӟ��指定其定w��Q�以避免数组扩容的发生。或者根据实际需求，通过调用ensureCapacity�Ҏ(gu��)��来手动增加ArrayList实例的容量�?br /> ArrayList�q�给我们提供了将底层数组的容量调整�ؓ当前列表保存的实际元素的大小的功能。它可以通过trimToSize�Ҏ(gu��)��来实现。代码如下：

Java代码

public void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (size < oldCapacity) {
elementData = Arrays.copyOf(elementData, size);
}
}

7) Fail-Fast机制�Q?/span>
ArrayList也采用了快速失败的机制�Q�通过记录modCount参数来实现。在面对�q�发的修�Ҏ(gu��)��Q��P代器很快��׃��完全��p�|�Q�而不是冒着在将来某个不��定旉��发生��L��不确定行为的风险。具体介�l�请参考我之前的文章深入Java集合学习�p�d��Q�HashMap的实现原�?中的Fail-Fast机制�?br /> 8) 关于其他的一些方法的实现都很��单易懂，读者可参照API文档和源代码�Q�一看便知，�q�里��׃��再多说�?/p>

3. 相关阅读�Q?/span>
本系列的文章之前�q�整理了以下几篇�Q�有兴趣的可以参考，望与大家分��n心得�Q�共同进步：
1) 深入Java集合学习�p�d��Q�HashMap的实现原�?�?br /> 2) 深入Java集合学习�p�d��Q�LinkedHashMap的实现原�?�?br /> 3) 深入Java集合学习�p�d��Q�HashSet的实现原�?�?br /> 4) 深入Java集合学习�p�d��Q�LinkedHashSet的实现原�?�?/p>

转蝲自：http://www.cnblogs.com/batys/archive/2011/11/02/2233597.html

abin 2012-03-16 12:28 发表评论

Java枚�D�c�d��enum使用详解

abin — Thu, 15 Mar 2012 03:16:00 GMT

java的Enum枚�D�c�d��l�于在j2se1.5出现了。之前觉得它只不�q�是鸡肋而已�Q�可有可无。毕竟这么多�q�来�Q�没有它�Q�大家不都过得很好吗�Q�今日看《Thinking in Java�?th edition�Q�里面有一句话“有时恰恰因�ؓ它，你才能够"优雅而干净"地解决问题。优雅与清晰很重要，正式它们区别了成功的解决�Ҏ(gu��)��与失败的解决�Ҏ(gu��)��。而失败的解决�Ҏ(gu��)��是因�ؓ其他人无法理他�?使用Enum枚�D�c�d��Q�可以将以前�W�拙的代码变得优雅简单？但是�Q�我同时也在思考另外一个问题，使用新的技术，会不会给技术�h员带来更多的负担呢？

"学习新版语言的一个危险就是疯狂��用新的语法结�?

先学习一下enum的简单应用，以下��z�的代码已经包括enum所提供的绝大部分功能�?/p>

1.enum的应用，包括定义�Q�遍历，switch�Q�enumset�Q�enummap�{?/p>

Java代码

import java.util.EnumMap;
import java.util.EnumSet;
public class EnumTest {
// 定义一个enum枚�D�c�d��Q�包括两个实例ON�Q�OFF
public enum State {
  ON, OFF
};
// ��试函数
public static void main(String[] args) {
  // 直接变量enum
  for (State s : State.values())
   System.out.println(s.name());
  // switch与enum的结合��?br />  State switchState = State.OFF;
  switch (switchState) {
  case OFF:
   System.out.println("OFF");
   break;
  case ON:
   System.out.println("ON");
   break;
  }
  // EnumSet的��?br />  EnumSet stateSet = EnumSet.allOf(State.class);
  for (State s : stateSet) {
   System.out.println(s);
  }
  // EnumMap的��?br />  EnumMap stateMap = new EnumMap(State.class);
  stateMap.put(State.ON, "is On");
  stateMap.put(State.OFF, "is off");
  for (State s : State.values()) {
   System.out.println(s.name() + ":" + stateMap.get(s));
  }
}
}

package com.aicent.test;
public enum TestEnumMathod {
// 为每个enum实例��d��不同的实现方�?br /> SAMPLE1 {
  String getInfo() {
   return "SAMPLE1";
  }
},
SAMPLE2 {
  String getInfo() {
   return "SAMPLE2";
  }
};
abstract String getInfo();
// ��试
public static void main(String args[]) {
  for (TestEnumMathod method : values()) {
   System.out.println(method.getInfo());
  }
}
}

以下内容可能有些无聊�Q�但�l�对值得一�H?br />1.代码�Q?br />public class State {
public static final int ON = 1;
public static final Int OFF= 0;
}

有什么不好了�Q�大安��q�样用了很长旉��了，没什么问题啊�?br />首先�Q�它不是�c�d��安全的。你必须��保是int
其次�Q�你�q�要��保它的范围�?�?
最后，很多时候你打印出来的时候，你只看到 1 �? �Q?/p>

但其没有看到代码的�h�q�不知道你的企图�Q�抛弃你所有旧的public static final帔R��?/p>

2.可以创徏一个enum�c�，把它看做一个普通的�c�R��除了它不能�l�承其他�c�M��?java是单�l�承�Q�它已经�l�承了Enum),
可以��d��其他�Ҏ(gu��)��Q�覆盖它本��n的方�?/p>

3.switch()参数可以使用enum�?/p>

4.values()�Ҏ(gu��)��是编译器插入到enum定义中的static�Ҏ(gu��)��Q�所以，当你��enum实例向上转型为父�c�Enum是，values()��׃��可访问了。解军_��法：在Class中有一个getEnumConstants()�Ҏ(gu��)��Q�所以即便Enum接口中没有values()�Ҏ(gu��)��Q�我们仍然可以通过Class对象取得所有的enum实例

5.无法从enum�l�承子类�Q�如果需要扩展enum中的元素�Q�在一个接口的内部�Q�创建实现该接口的枚举，以此��元素进行分�l�。达到将枚�D元素�q�行分组�?/p>

6.使用EnumSet代替标志。enum要求其成员都是唯一的，但是enum中不能删除添加元素�?/p>

7.EnumMap的key是enum�Q�value是�Q何其他Object对象�?/p>

8.enum允许�E�序员�ؓeunm实例�~�写�Ҏ(gu��)��。所以可以�ؓ每个enum实例赋予各自不同的行为�?/p>

9.使用enum的职责链(Chain of Responsibility) .�q�个关系到设计模式的职责链模式。以多种不同的方法来解决一个问题。然后将他们链接在一赗��当一个请求到来时�Q�遍历这个链�Q�直到链中的某个解决�Ҏ(gu��)��能够处理该请求�?/p>

10.使用enum的状态机

11.使用enum多�\分发

转蝲自：http://blog.csdn.net/mqboss/article/details/5647851

abin 2012-03-15 11:16 发表评论

Java Enum�c�d��Ҏ(gu��)��使用

abin — Mon, 12 Mar 2012 14:29:00 GMT

package com.abin.inter.service;

public interface UserService {

public static enum UserType{
  UserBasic("Basic Information"),
  UserName("Name Of User"),
  UserSex("Sex Of User"),
  UserAge("Age Of User"),
  UserInitialize("Initialize Of User");

  private String info;
  private UserType(String _info){
   this.info=_info;
  }

  public String getObject(){
   return info;
  }
};

int UserSum(int one,int two,UserType userInfo);
String Welcome(String username,UserType userInfo);
}

package com.abin.inter.serviceImpl;

import com.abin.inter.service.UserService;

public class UserServiceImpl implements UserService{
@Override
public int UserSum(int one, int two,UserType userInfo) {
  UserType user=UserType.UserInitialize;
  System.out.println("Enum Info:"+user.getObject());
  if(userInfo.equals(UserType.UserAge)){
   System.out.println("UserInfo:"+userInfo);
   return one+two;
  }
  return 0;
}

@Override
public String Welcome(String username,UserType userInfo) {
  UserType user=UserType.UserInitialize;
  System.out.println("Enum Info:"+user);
  if(userInfo.equals(UserType.UserName)){
   System.out.println("UserInfo:"+userInfo);
   return "�Ƣ迎"+username;
  }
  return "NOT WELCOME";
}

@Override
public String toString() {
// TODO Auto-generated method stub
return super.toString();
}

}

package com.abin.inter.test;

import com.abin.inter.service.UserService;
import com.abin.inter.service.UserService.UserType;
import com.abin.inter.serviceImpl.UserServiceImpl;

import junit.framework.TestCase;

public class TestUser extends TestCase{

public void test(){
  UserService service=new UserServiceImpl();
  UserType userInfo=UserType.UserAge;
  int result=service.UserSum(10, 17, userInfo);
  System.out.println("UserSum="+result);
  UserType userInfo1=UserType.UserName;
  String result1=service.Welcome("abin", userInfo1);
  System.out.println("Welcome="+result1);

}
}

�q�行�l�果�Q?br />Enum Info:Initialize Of User
UserInfo:UserAge
UserSum=27
Enum Info:UserInitialize
UserInfo:UserName
Welcome=�Ƣ迎abin

abin 2012-03-12 22:29 发表评论

男女污污视频在线观看,亚洲每日在线,中文字幕一区二区三区乱码在线

教你如何�q�速秒杀掉：99%的�v量数据处理面试题 .

Java Map,List,Vector,Set遍历

Java 全局队列

Java 遍历嵌套Map

Java容器集合�cȝ��区别用法

Java枚�D�c�d��enum使用详解

Java Enum�c�d���Ҏ(gu��)��使用

Java Enum�c�d��Ҏ(gu��)��使用