Java高级知识总结

资料整理于网络：参考http://blog.csdn.net/column/details/java0115.html，在此感谢

1.关于枚举的用法

Java中的Enum枚举类型却有着许多你意想不到的用法，下面让我们一起来看看。

1、可以在enum中添加变量和方法

先来看一段代码示例：

 public enum State {
         Normal("正常态", 1), Update("已更新", 2), Deleted("已删除", 3), Fired("已屏蔽", 4);
         // 成员变量
         private String name;
         private int index;

         // 构造方法，注意：构造方法不能为public，因为enum并不可以被实例化
         private State(String name, int index) {
             this.name = name;
             this.index = index;
         }

         // 普通方法
         public static String getName(int index) {
             for (State c : State .values()) {
                 if (c.getIndex() == index) {
                     return c.name;
                 }
             }
             return null;
         }

         // get set 方法
         public String getName() {
             return name;
         }

         public void setName(String name) {
             this.name = name;
         }

         public int getIndex() {
             return index;
         }

         public void setIndex(int index) {
             this.index = index;
         }
     }

从上面的代码中我们可以看到，定义完枚举值，然后在其后面加上分号，接着就可以定义其他的变量、方法了。另外需要特别说明的是，enum中的构造方法不可以用public标识，这样做是为了防止用户实例化enum。

2、可以用来定义常量

先来回顾一下Java中如何定义常量吧，看下面一段代码：

public static final int normalState = 1;
private static final int updateState = 2;

下面我们还可以用enum枚举来代替上面的常量定义，代码如下：

 public enum State {
   Normal, Update, Deleted, Fired
 }

在Java中用enum来定义常量在语法上没有什么优势，但是enum枚举类型可以提供更多的操作功能。

3、在enum中实现接口

先来看下面一段代码：

 public interface ICanReadState {
         void read();

         String getState();
 }

     public enum State implements ICanReadState {
         Normal("正常态", 1), Update("已更新", 2), Deleted("已删除", 3), Fired("已屏蔽", 4);

         private String name;
         private int index;

         private State(String name, int index) {
             this.name = name;
             this.index = index;
         }

         // 接口方法1

         @Override
         public String getState() {
             return this.name;
         }

         // 接口方法2
         @Override
         public void read() {
             System.out.println(this.index + ":" + this.name);
         }
     }

和一般的类中使用接口一样，enum枚举中同样可以继承接口，并实现接口中的所有方法，这样做的好处在于可以更方便地对枚举中的值进行排序、比较等操作，封装性更好。

总结

说白了，enum枚举类型是一个不可以被继承的final类，就以上面的State枚举为例，如果你查看enum类型的字节码，其实是State类型的类静态常量。

2.Java中操作Cookie对象

/**
 * @Description: 
 *
 * @Title: CookieUtil.java
 * @Package com.hupu.nac.util
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-1-15 上午10:17:51
 * @version V2.0
 */
package com.hupu.nac.util;

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

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @Description: Cookie读写
 *
 * @ClassName: CookieUtil
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-1-15 上午10:17:51
 * @version V2.0
 */
public class CookieUtil {
	
	/**
	 * @Description: 添加cookie 
	 *
	 * @param response
	 * @param name
	 * @param value
	 * @param maxAge
	 * @return
	 *
	 * @Title: CookieUtil.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-1-15 上午10:29:29
	 * @version V2.0
	 */
	public static Cookie addCookie(HttpServletResponse response,String name,String value,int maxAge){
	    Cookie cookie = new Cookie(name,value);
		cookie.setPath("/");
	    if(maxAge > 0){
	    	cookie.setMaxAge(maxAge);
	    }
	    response.addCookie(cookie);
	    return cookie;
	}
	
	/**
	 * @Description: 根据key获取Cookie对象
	 *
	 * @param request
	 * @param key
	 * @return
	 *
	 * @Title: CookieUtil.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-1-15 上午10:29:44
	 * @version V2.0
	 */
	public static Cookie getCookieByName(HttpServletRequest request,String key){
	    Map cookieMap = readCookieMap(request);
	    if(cookieMap.containsKey(key)){
	        Cookie cookie = (Cookie)cookieMap.get(key);
	        return cookie;
	    }else{
	        return null;
	    }   
	}
	
	/**
	 * @Description: 封装Cookie读取方法
	 *
	 * @param request
	 * @return
	 *
	 * @Title: CookieUtil.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-1-15 上午10:30:05
	 * @version V2.0
	 */
	private static Map readCookieMap(HttpServletRequest request){  
	    Map cookieMap = new HashMap();
	    Cookie[] cookies = request.getCookies();
	    if(null != cookies){
	        for(Cookie cookie : cookies){
	            cookieMap.put(cookie.getName(), cookie);
	        }
	    }
	    return cookieMap;
	}
}

3.使用JAXB对XML和Java对象进行转换

package com.advanced.JAXB完成XML与Java对象的互转;

import java.io.ByteArrayOutputStream;
import java.io.File;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

/**
 * @Description:JAXB对象和XML转换util 
 *  
 * @ClassName: JAXBUtil 
 * @Copyright: Copyright (c) 2014 
 * 
 * @author He
 *
 */
public class JAXBUtil {
	
	/**
	 * 将对象转换为XML
	 * 
	 * @param ojb
	 * @param beanClass
	 * @return
	 * @throws Exception
	 */
	public String objectToXmlStr(Object obj, Class beanClass) throws Exception{
		
		JAXBContext context = JAXBContext.newInstance(beanClass);
		//根据上下文获取marshaller对象
		Marshaller marshaller = context.createMarshaller();
		//设置编码集
		marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
		//格式化XML输出，有分行和缩进
		marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
		//打印到控制台
//		marshaller.marshal(obj, System.out);
		
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		marshaller.marshal(obj, baos);
		String xmlObj = new String(baos.toByteArray());
		
		return xmlObj.replace(" standalone=\"yes\"", "");
	}
	
	/** 
     * @Description: 将对象转换为XML并且写入文件 
     * 
     * @param obj 
     * @param beanClass 
     * @param file 
     * @throws Exception 
     * 
     * @Title: JAXBUtil.java 
     * @Copyright: Copyright (c) 2014 
     */  
    @SuppressWarnings("unchecked")  
    public void objectToXmlStr(Object obj, Class beanClass, File file) throws Exception {  
        JAXBContext context = JAXBContext.newInstance(beanClass);  
        // 根据上下文获取marshaller对象  
        Marshaller marshaller = context.createMarshaller();  
        // 设置编码字符集  
        marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");  
        // 格式化XML输出，有分行和缩进  
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);  
        // 打印到控制台  
        marshaller.marshal(obj, System.out);  
        marshaller.marshal(obj, file);  
    }  
      
	
	/**
	 * 解析XML文件并转换为对象
	 * 
	 * @param file
	 * @param beanClass
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public  T xmlStrToObject(File file, Class beanClass) throws Exception{
		T bean = beanClass.newInstance();
		JAXBContext context = JAXBContext.newInstance(beanClass);
		Unmarshaller unmarshaller = context.createUnmarshaller();
		bean = (T) unmarshaller.unmarshal(file);
		return bean;
	}
	
}

4.任务调度开源框架Quartz动态添加、修改和删除定时任务

 Quartz 是个开源的作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz框架包含了调度器监听、作业和触发器监听。你可以配置作业和触发器监听为全局监听或者是特定于作业和触发器的监听。Quartz 允许开发人员根据时间间隔（或天）来调度作业。它实现了作业和触发器的多对多关系，还能把多个作业与不同的触发器关联。整合了 Quartz 的应用程序可以重用来自不同事件的作业，还可以为一个事件组合多个作业。并且还能和Spring配置整合使用。Quartz在功能上远远超越了JDK自带的Timer，很好很强大！好啦，直接上代码：

 /**
  * @Description:
  *
  * @Title: QuartzManager.java
  * @Package com.joyce.quartz
  * @Copyright: Copyright (c) 2014
  *
  * @author Comsys-LZP
  * @date 2014-6-26 下午03:15:52
  * @version V2.0
  */
 package com.joyce.quartz;

 import org.quartz.CronTrigger;
 import org.quartz.JobDetail;
 import org.quartz.Scheduler;
 import org.quartz.SchedulerFactory;
 import org.quartz.impl.StdSchedulerFactory;

 /**
  * @Description: 定时任务管理类
  *
  * @ClassName: QuartzManager
  * @Copyright: Copyright (c) 2014
  *
  * @author Comsys-LZP
  * @date 2014-6-26 下午03:15:52
  * @version V2.0
  */
 public class QuartzManager {
     private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
     private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME";
     private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME";

     /**
      * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
      *
      * @param jobName
      *            任务名
      * @param cls
      *            任务
      * @param time
      *            时间设置，参考quartz说明文档
      *
      * @Title: QuartzManager.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 下午03:47:44
      * @version V2.0
      */
     @SuppressWarnings("unchecked")
     public static void addJob(String jobName, Class cls, String time) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, cls);// 任务名，任务组，任务执行类
             // 触发器
             CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组
             trigger.setCronExpression(time);// 触发器时间设定
             sched.scheduleJob(jobDetail, trigger);
             // 启动
             if (!sched.isShutdown()) {
                 sched.start();
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * @Description: 添加一个定时任务
      *
      * @param jobName
      *            任务名
      * @param jobGroupName
      *            任务组名
      * @param triggerName
      *            触发器名
      * @param triggerGroupName
      *            触发器组名
      * @param jobClass
      *            任务
      * @param time
      *            时间设置，参考quartz说明文档
      *
      * @Title: QuartzManager.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 下午03:48:15
      * @version V2.0
      */
     @SuppressWarnings("unchecked")
     public static void addJob(String jobName, String jobGroupName,
             String triggerName, String triggerGroupName, Class jobClass,
             String time) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             JobDetail jobDetail = new JobDetail(jobName, jobGroupName, jobClass);// 任务名，任务组，任务执行类
             // 触发器
             CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组
             trigger.setCronExpression(time);// 触发器时间设定
             sched.scheduleJob(jobDetail, trigger);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
      *
      * @param jobName
      * @param time
      *
      * @Title: QuartzManager.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 下午03:49:21
      * @version V2.0
      */
     @SuppressWarnings("unchecked")
     public static void modifyJobTime(String jobName, String time) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName,TRIGGER_GROUP_NAME);
             if (trigger == null) {
                 return;
             }
             String oldTime = trigger.getCronExpression();
             if (!oldTime.equalsIgnoreCase(time)) {
                 JobDetail jobDetail = sched.getJobDetail(jobName,JOB_GROUP_NAME);
                 Class objJobClass = jobDetail.getJobClass();
                 removeJob(jobName);
                 addJob(jobName, objJobClass, time);
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * @Description: 修改一个任务的触发时间
      *
      * @param triggerName
      * @param triggerGroupName
      * @param time
      *
      * @Title: QuartzManager.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 下午03:49:37
      * @version V2.0
      */
     public static void modifyJobTime(String triggerName,
             String triggerGroupName, String time) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName,triggerGroupName);
             if (trigger == null) {
                 return;
             }
             String oldTime = trigger.getCronExpression();
             if (!oldTime.equalsIgnoreCase(time)) {
                 CronTrigger ct = (CronTrigger) trigger;
                 // 修改时间
                 ct.setCronExpression(time);
                 // 重启触发器
                 sched.resumeTrigger(triggerName, triggerGroupName);
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
      *
      * @param jobName
      *
      * @Title: QuartzManager.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 下午03:49:51
      * @version V2.0
      */
     public static void removeJob(String jobName) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器
             sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器
             sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * @Description: 移除一个任务
      *
      * @param jobName
      * @param jobGroupName
      * @param triggerName
      * @param triggerGroupName
      *
      * @Title: QuartzManager.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 下午03:50:01
      * @version V2.0
      */
     public static void removeJob(String jobName, String jobGroupName,
             String triggerName, String triggerGroupName) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器
             sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器
             sched.deleteJob(jobName, jobGroupName);// 删除任务
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * @Description:启动所有定时任务
      *
      *
      * @Title: QuartzManager.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 下午03:50:18
      * @version V2.0
      */
     public static void startJobs() {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             sched.start();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * @Description:关闭所有定时任务
      *
      *
      * @Title: QuartzManager.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 下午03:50:26
      * @version V2.0
      */
     public static void shutdownJobs() {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             if (!sched.isShutdown()) {
                 sched.shutdown();
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 }

以上就是quartz任务调度对于任务的常用操作，封装起来以便在外部调用！这样我们就需要任务的执行了：

 /**
  * @Description:
  *
  * @Title: QuartzJob.java
  * @Package com.joyce.quartz
  * @Copyright: Copyright (c) 2014
  *
  * @author Comsys-LZP
  * @date 2014-6-26 下午03:37:11
  * @version V2.0
  */
 package com.joyce.quartz;

 import java.text.SimpleDateFormat;
 import java.util.Date;

 import org.quartz.Job;
 import org.quartz.JobExecutionContext;
 import org.quartz.JobExecutionException;

 /**
  * @Description: 任务执行类
  *
  * @ClassName: QuartzJob
  * @Copyright: Copyright (c) 2014
  *
  * @author Comsys-LZP
  * @date 2014-6-26 下午03:37:11
  * @version V2.0
  */
 public class QuartzJob implements Job {

     @Override
     public void execute(JobExecutionContext arg0) throws JobExecutionException {
         System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+ "★★★★★★★★★★★");
     }
 }

Ok，我们来测试一下：

 /**
  * @Description:
  *
  * @Title: QuartzTest.java
  * @Package com.joyce.quartz.main
  * @Copyright: Copyright (c) 2014
  *
  * @author Comsys-LZP
  * @date 2014-6-26 下午03:35:05
  * @version V2.0
  */
 package com.joyce.quartz.main;

 import com.joyce.quartz.QuartzJob;
 import com.joyce.quartz.QuartzManager;

 /**
  * @Description: 测试类
  *
  * @ClassName: QuartzTest
  * @Copyright: Copyright (c) 2014
  *
  * @author Comsys-LZP
  * @date 2014-6-26 下午03:35:05
  * @version V2.0
  */
 public class QuartzTest {
     public static void main(String[] args) {
         try {
             String job_name = "动态任务调度";
             System.out.println("【系统启动】开始(每1秒输出一次)...");
             QuartzManager.addJob(job_name, QuartzJob.class, "0/1 * * * * ?");

             Thread.sleep(5000);
             System.out.println("【修改时间】开始(每2秒输出一次)...");
             QuartzManager.modifyJobTime(job_name, "10/2 * * * * ?");
             Thread.sleep(6000);
             System.out.println("【移除定时】开始...");
             QuartzManager.removeJob(job_name);
             System.out.println("【移除定时】成功");

             System.out.println("【再次添加定时任务】开始(每10秒输出一次)...");
             QuartzManager.addJob(job_name, QuartzJob.class, "*/10 * * * * ?");
             Thread.sleep(60000);
             System.out.println("【移除定时】开始...");
             QuartzManager.removeJob(job_name);
             System.out.println("【移除定时】成功");
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

运行一下，看看效果图：

至于定时的配置的话，有兴趣的各位可以去看看Quartz的cron表达式

5.使用Google的Guava简化处理IO

/**
 * @Description: 
 *
 * @Title: FileGuava.java
 * @Package com.joyce.guava.main
 * @Copyright: Copyright (c) 2014
 *
 * @author Comsys-LZP
 * @date 2014-6-26 下午01:18:18
 * @version V2.0
 */
package com.joyce.guava.main;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.google.common.base.Charsets;
import com.google.common.io.Files;

/**
 * @Description:Guava的文件
 * 
 * @ClassName: FileGuava
 * @Copyright: Copyright (c) 2014
 * 
 * @author Comsys-LZP
 * @date 2014-6-26 下午01:18:18
 * @version V2.0
 */
public class FileGuava {
	public static void main(String[] args) {
		try {
			File readFile = new File(System.getProperty("user.dir") + "/src/resources/showarp.txt");
			StringBuilder content = new StringBuilder();
			if (readFile.exists()) {
				List lines = readFile(readFile);
				for (String string : lines) {
					System.out.println(string);
					content.append(string + "\n");
				}
			}
			File writeFile = new File(System.getProperty("user.dir") + "/src/resources/showarp" + new SimpleDateFormat("yyyyMMdd").format(new Date())+ ".txt");
			writeFile(content.toString(), writeFile);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * @Description: Guava文件读取
	 * 
	 * @param file
	 * @return
	 * 
	 * @Title: FileGuava.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-6-26 下午01:20:50
	 * @version V2.0
	 */
	private static List readFile(File file) throws Exception {
		if (!file.exists()) {
			return null;
		}
		return Files.readLines(file, Charsets.UTF_8);
	}
	
	/**
	 * @Description: 从文件中获取有规则的数据 
	 *
	 * @param file
	 * @return
	 *
	 * @Title: FileGuava.java
	 * @Copyright: Copyright (c) 2014
	 *
	 * @author Comsys-LZP
	 * @date 2014-6-26 下午01:56:42
	 * @version V2.0
	 */
	public List readFileData(File file) throws Exception {
		List list = new ArrayList();
		for (String rLine : readFile(file)) {
			list.add(rLine.split("\\s+"));
		}
		return list;
	}

	/**
	 * @Description: Guava写文件
	 * 
	 * @param content
	 * @param file
	 * 
	 * @Title: FileGuava.java
	 * @Copyright: Copyright (c) 2014
	 * 
	 * @author Comsys-LZP
	 * @date 2014-6-26 下午01:32:06
	 * @version V2.0
	 */
	private static void writeFile(String content, File file) throws Exception {
		if (!file.exists()) {
			file.createNewFile();
		}
		Files.write(content, file, Charsets.UTF_8);
	}
}

6. 使用Guava处理Collection集合

Guava 中文是石榴的意思，该项目是 Google 的一个开源项目，包含许多 Google 核心的 Java 常用库。

1. 基本工具 [Basic utilities]
    让使用Java语言变得更舒适
    1.1 使用和避免null：null是模棱两可的，会引起令人困惑的错误，有些时候它让人很不舒服。很多Guava工具类用快速失败拒绝null值，而不是盲目地接受
    1.2 前置条件: 让方法中的条件检查更简单
    1.3 常见Object方法: 简化Object方法实现，如hashCode()和toString()
    1.4 排序: Guava强大的”流畅风格比较器”
    1.5 Throwables：简化了异常和错误的传播与检查

2. 集合[Collections]
    Guava对JDK集合的扩展，这是Guava最成熟和为人所知的部分
    2.1 不可变集合: 用不变的集合进行防御性编程和性能提升。
    2.2 新集合类型: multisets, multimaps, tables, bidirectional maps等
    2.3 强大的集合工具类: 提供java.util.Collections中没有的集合工具
    2.4 扩展工具类：让实现和扩展集合类变得更容易，比如创建Collection的装饰器，或实现迭代器

3. 缓存[Caches]
    Guava Cache：本地缓存实现，支持多种缓存过期策略

4. 函数式风格[Functional idioms]
    Guava的函数式支持可以显著简化代码，但请谨慎使用它

5. 并发[Concurrency]
    强大而简单的抽象，让编写正确的并发代码更简单
    5.1 ListenableFuture：完成后触发回调的Future
    5.2 Service框架：抽象可开启和关闭的服务，帮助你维护服务的状态逻辑

6. 字符串处理[Strings]
    非常有用的字符串工具，包括分割、连接、填充等操作

7. 原生类型[Primitives]
    扩展 JDK 未提供的原生类型（如int、char）操作， 包括某些类型的无符号形式

8. 区间[Ranges]
    可比较类型的区间API，包括连续和离散类型

9. I/O
    简化I/O尤其是I/O流和文件的操作，针对Java5和6版本

10. 散列[Hash]
    提供比Object.hashCode()更复杂的散列实现，并提供布鲁姆过滤器的实现

11. 事件总线[EventBus]
    发布-订阅模式的组件通信，但组件不需要显式地注册到其他组件中

12. 数学运算[Math]
    优化的、充分测试的数学工具类

13. 反射[Reflection]
    Guava 的 Java 反射机制工具类 

至于Guava这个这里就不多说了，上一篇已经讲得很详细了！这次主要是分享一下Guava对集合的一些升华处理，好啦，不多说，直接上代码：

 package com.joyce.guava.bean;

 /**
  * 学生实体类
  *
  * @author Joyce.Luo
  * @date 2014-6-19 下午02:37:19
  */
 public class Student {
     /**
      * 学号
      */
     private Integer stuId;
     /**
      * 姓名
      */
     private String stuName;
     /**
      * 年龄
      */
     private Integer stuAge;

     /**
      * @return the stuId
      */
     public Integer getStuId() {
         return stuId;
     }

     /**
      * @param stuId
      *            the stuId to set
      */
     public void setStuId(Integer stuId) {
         this.stuId = stuId;
     }

     /**
      * @return the stuName
      */
     public String getStuName() {
         return stuName;
     }

     /**
      * @param stuName
      *            the stuName to set
      */
     public void setStuName(String stuName) {
         this.stuName = stuName;
     }

     /**
      * @return the stuAge
      */
     public Integer getStuAge() {
         return stuAge;
     }

     /**
      * @param stuAge
      *            the stuAge to set
      */
     public void setStuAge(Integer stuAge) {
         this.stuAge = stuAge;
     }

     /**
      *
      */
     public Student() {
         super();
     }

     /**
      * @param stuId
      * @param stuName
      * @param stuAge
      */
     public Student(Integer stuId, String stuName, Integer stuAge) {
         super();
         this.stuId = stuId;
         this.stuName = stuName;
         this.stuAge = stuAge;
     }
 }

实体类有了，主要是为了在集合中使用提供方便！关键在于：

 /**
  * @Description:
  *
  * @Title: SetGuava.java
  * @Package com.joyce.guava.main
  * @Copyright: Copyright (c) 2014
  *
  * @author Comsys-LZP
  * @date 2014-6-26 上午11:03:53
  * @version V2.0
  */
 package com.joyce.guava.main;

 import java.util.Collections;
 import java.util.List;
 import java.util.Map;

 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.ClassToInstanceMap;
 import com.google.common.collect.HashBasedTable;
 import com.google.common.collect.HashBiMap;
 import com.google.common.collect.HashMultiset;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Multiset;
 import com.google.common.collect.MutableClassToInstanceMap;
 import com.google.common.collect.Ordering;
 import com.google.common.collect.Table;
 import com.joyce.guava.bean.Student;

 /**
  * @Description: Guava的集合
  *
  * @ClassName: SetGuava
  * @Copyright: Copyright (c) 2014
  *
  * @author Comsys-LZP
  * @date 2014-6-26 上午11:03:53
  * @version V2.0
  */
 public class SetGuava {
     public static void main(String[] args) {
         /**
          * Guava API 提供了有用的新的集合类型， 协同已经存在的java集合工作的很好。 分别是 Multimap， Multiset，
          * Table， BiMap， ClassToInstanceMap
          */
         System.out.println("Multimap：一种key可以重复的map，子类有ListMultimap和SetMultimap，对应的通过key分别得到list和set");
         testMultimap();
         System.out.println("Multiset：不是集合，可以增加重复的元素，并且可以统计出重复元素的个数");
         testMulitiset();
         System.out.println("Table：相当于有两个key的map");
         testTable();
         System.out.println("BiMap: 是一个一一映射，可以通过key得到value，也可以通过value得到key");
         testBitMap();
         System.out.println("ClassToInstanceMap：map的key并不是只是一种类型");
         testClassToInstanceMap();
         System.out.println("排序，是guava一份非常灵活的比较类，可以被用来操作，扩展，当作比较器，排序提供了集合排序的很多控制 ");
         testOrder();
     }

     /**
      * @Description: Multimap：一种key可以重复的map，子类有ListMultimap和SetMultimap，对应的通过key分别得到list和set
      *
      *
      * @Title: SetGuava.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 上午11:19:50
      * @version V2.0
      */
     private static void testMultimap() {
         Multimap customersByType = ArrayListMultimap.create();
         customersByType.put("abc", new Student(1, "Joyce", 20));
         customersByType.put("abc", new Student(1, "Joyce One", 20));
         customersByType.put("abc", new Student(1, "Joyce Two", 20));
         customersByType.put("abc", new Student(1, "Joyce Three", 20));
         customersByType.put("abcd", new Student(1, "Joyce Four", 20));
         customersByType.put("abcde", new Student(1, "Joyce Five", 20));
         System.out.println(customersByType.get("abc").size());
         for (Student stu : customersByType.get("abc")) {
             System.out.println(stu.getStuName());
         }
     }

     /**
      * @Description: Multiset：不是集合，可以增加重复的元素，并且可以统计出重复元素的个数
      *
      *
      * @Title: SetGuava.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 上午11:19:59
      * @version V2.0
      */
     private static void testMulitiset() {
         Multiset multiSet = HashMultiset.create();
         multiSet.add(10);
         multiSet.add(30);
         multiSet.add(30);
         multiSet.add(40);
         System.out.println(multiSet.count(30)); // 2 -- 统计XX出现的次数
         System.out.println(multiSet.size()); // 4 -- 元素的个数
     }

     /**
      * @Description: Table：相当于有两个key的map
      *
      *
      * @Title: SetGuava.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 上午11:24:43
      * @version V2.0
      */
     private static void testTable() {
         Table personTable = HashBasedTable.create();
         personTable.put(1, 20, new Student(1, "46546", 20));
         personTable.put(0, 30, new Student(2, "46546", 30));
         personTable.put(0, 25, new Student(3, "46546", 25));
         personTable.put(1, 50, new Student(4, "46546", 50));
         personTable.put(0, 27, new Student(5, "46546", 27));
         personTable.put(1, 29, new Student(6, "46546", 29));
         personTable.put(0, 38, new Student(7, "46546", 38));
         personTable.put(1, 66, new Student(8, "46546", 66));

         // 得到行集合
         Map rowMap = personTable.row(0);
         Integer rowMax = Collections.max(rowMap.keySet());
         System.out.println(rowMax);
     }

     /**
      * @Description: BiMap: 是一个一一映射，可以通过key得到value，也可以通过value得到key
      *
      *
      * @Title: SetGuava.java
      * @Copyright: Copyright (c) 2014
      *
      * @author Comsys-LZP
      * @date 2014-6-26 上午11:36:59
      * @version V2.0
      */
     private static void testBitMap() {
         // 双向map
         BiMap biMap = HashBiMap.create();
         biMap.put(1, "hello");
         biMap.put(2, "helloa");
         biMap.put(3, "world");
         biMap.put(4, "worldb");
         biMap.put(5, "my");
         biMap.put(6, "myc");
         // 通过key取value
         String value = biMap.get(5);
         System.out.println("key -- [5] ; value -- [" + value + "]");
         // 通过value取key
         Integer key = biMap.inverse().get("my");
         System.out.println("value -- [my] ; key -- [" + key + "]");
     }

     /**
      * @Description: ClassToInstanceMap：有的时候，你的map的key并不是一种类型，他们是很多类型，你想通过映射他们得到这种类型，
      *               guava提供了ClassToInstanceMap满足了这个目的。
      *
      *               除了继承自Map接口，ClassToInstaceMap提供了方法 T getInstance(Class) 和
      *               T putInstance(Class, T),消除了强制类型转换。
      *
      *               该类有一个简单类型的参数，通常称为B，代表了map控制的上层绑定，例如：
      *               ClassToInstanceMap numberDefaults =
      *               MutableClassToInstanceMap.create();
      *               numberDefaults.putInstance(Integer.class,
      *               Integer.valueOf(0));
      *
      *               从技术上来说，ClassToInstanceMap 实现了Map,

效果如图：

相信大家伙对上面的代码如果理解深入了的话，会明白了的！！！其实Guava在集合上面还提供了其他方法，这里

7.递归遍历某个文件夹下所有文件

/*
  * 通过递归得到某一路径下所有的目录及其文件
  */
 static void getFiles(String filePath){
  File root = new File(filePath);
    File[] files = root.listFiles();
    for(File file:files){     
     if(file.isDirectory()){
      /*
       * 递归调用
       */
      getFiles(file.getAbsolutePath());
      filelist.add(file.getAbsolutePath());
      System.out.println("显示"+filePath+"下所有子目录及其文件"+file.getAbsolutePath());
     }else{
      System.out.println("显示"+filePath+"下所有子目录"+file.getAbsolutePath());
     }     
    }
 }