google guava的基礎部分Demo實例（註釋詳盡）

package org.loda.guava;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.base.CharMatcher;
import com.google.common.base.Charsets;
import com.google.common.base.Joiner;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import com.google.common.collect.ComparisonChain;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

/**
 * 
* @ClassName: Basic 
* @Description: guava之基礎部分 
* @author minjun
* @date 2015年6月14日 下午7:06:31 
*
 */
public class Basic {

	private static final Logger logger = LoggerFactory
			.getLogger(Basic.class);

	/**
	 * 
	 * @Title: testJoiner
	 * @Description: 利用某個分隔符將一組字符串分隔開來
	 * 
	 *               輸出結果爲： 
	 *               傳統方法：loda,vigoss,merlini
	 *               採用joiner:loda,vigoss,merlini
	 * 
	 * @param 設定文件
	 * @return void 返回類型
	 * @throws
	 */
	@Test
	public void testJoiner() {
		List<String> list = Lists.newArrayList("loda", "vigoss", null,
				"merlini");

		String delimiter = ",";

		// 傳統方法，採用stringbuilder
		logger.info("傳統方法：{}", joinWithStringBuilder(list, delimiter));

		// 採用guava提供的Joiner類
		logger.info("採用joiner:{}", joinWithGuava(list, delimiter));
	}

	private String joinWithGuava(List<String> list, String delimiter) {
		return Joiner.on(delimiter)// 建立一個Joiner對象，將分隔符delimiter設爲全局變量
				.skipNulls()// 建立一個新的Joiner對象，複寫其appendTo方法，用來過濾list中的空值
				// .useForNull("nullText")// 使用nullText替換空字符串
				.join(list);// 將list中的內容一個個的與delimiter分隔符鏈接起來
	}

	private String joinWithStringBuilder(List<String> list, String delimiter) {
		StringBuilder sb = new StringBuilder();

		for (String s : list) {
			if (s != null) {
				sb.append(s).append(delimiter);
			}
		}
		// 將最後的delimiter去掉
		sb.setLength(sb.length() - delimiter.length());
		return sb.toString();
	}

	/**
	 * 
	 * @Title: testMapJoiner
	 * @Description: 將一個map型數據組合成一個由指定分隔符分開的key-value樣式
	 * 
	 *               輸出結果爲：
	 * 
	 *               貝克漢姆:中場;羅納爾多:前鋒;布馮:門將;齊達內:中場
	 * 
	 * @param 設定文件
	 * @return void 返回類型
	 * @throws
	 */
	@Test
	public void testMapJoiner() {
		Map<String, String> map = Maps.newLinkedHashMap();
		String delimiter = ";";

		map.put("貝克漢姆", "中場");
		map.put("羅納爾多", "前鋒");
		map.put("布馮", "門將");
		map.put("齊達內", "中場");

		String returnString = Joiner.on(delimiter)// 建立了一個以delimiter做爲分隔符的Joiner
				.withKeyValueSeparator(":")// 建立了一個以：做爲鍵值間隔符的MapJoiner
				.join(map);// 將這個指定了MapJoiner樣式的map鏈接成一個字符串

		logger.info(returnString);

	}

	/**
	 * 
	 * @Title: testSplitter
	 * @Description: 將含有指定分隔符的字符串分開
	 * @param 設定文件
	 * @return void 返回類型
	 * @throws
	 */
	@Test
	public void testSplitter() {
		String text = "英文|中文||韓文|法文|  xx   |";

		logger.info(Arrays.toString(text.split("\\|")));

		logger.info(Splitter.on("|")// 建立一個以"|"做爲切分的Splitter
				.trimResults()// 對切分全部結果，去掉兩邊空格
				.split(text)// 將字符串text按照"|"切分開來
				.toString());
	}

	/**
	 * 
	 * @Title: testMapSplitter
	 * @Description:使用MapSplitter能夠將按照鍵值對規則組合起來的字符串，拆分紅一個一個map中的鍵值對
	 * 
	 *  輸出結果爲：
	 *              key爲貝克漢姆,value爲中場
	 *		key爲羅納爾多,value爲前鋒
	 *		key爲布馮,value爲門將
	 *		key爲齊達內,value爲中場
  
	 * @param 設定文件
	 * @return void 返回類型
	 * @throws
	 */
	@Test
	public void testMapSplitter() {
		String text = "貝克漢姆:中場;羅納爾多:前鋒;布馮:門將;齊達內:中場";

		String delimiter = ";";

		Map<String, String> map = Splitter.on(delimiter)
				.withKeyValueSeparator(":").split(text);

		for (Entry<String, String> e : map.entrySet()) {
			logger.info("key爲{},value爲{}", e.getKey(), e.getValue());
		}
	}

	/**
	 * 
	 * @Title: testCharsets
	 * @Description: 字符集處理
	 * @param 設定文件
	 * @return void 返回類型
	 * @throws
	 */
	@SuppressWarnings("unused")
	@Test
	public void testCharsets() {
		String text = "編碼問題";

		// 獲取該字符串指定編碼字符集的時候，若是傳遞參數爲string類型，則須要強行捕捉異常，由於這個spring類型可能填寫錯誤
		try {
			byte[] b = text.getBytes("utf-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}

		// 可是使用Charset類型做爲參數卻沒有問題，因此guava幫咱們封裝了幾種經常使用的編碼，並以Charset類型返回，讓咱們直接當作參數傳遞進去
		// 這裏無需捕捉任何異常狀況，由於使用了guava封裝的字符集，根本不可能報錯
		byte[] bt = text.getBytes(Charsets.UTF_8);

	}

	/**
	 * 
	 * @Title: testStrings
	 * @Description: 給指定的字符串後添加字符
	 * @param 設定文件
	 * @return void 返回類型
	 * @throws
	 */
	@Test
	public void testStrings() {
		StringBuilder text = new StringBuilder("helloworld");
		char c = 'x';

		for (int i = 0; i < 3; i++) {
			text.append(c);
		}

		Assert.assertEquals(text.toString(), "helloworldxxx");

		// 給字符串helloworld後面不斷添加'x'字符，直到整個字符串長度達到了13。若是該長度沒有helloworld長度大，則直接返回helloworld
		String result = Strings.padEnd("helloworld", 13, c);

		Assert.assertEquals(result, "helloworldxxx");

		// 若是是null，則轉成""空字符串；不然返回原始字符串。這是一個推薦使用的函數
		Assert.assertEquals(Strings.nullToEmpty(null), "");

		// 若是字符串是""空字符串，則直接返回null
		Assert.assertNull(Strings.emptyToNull(""));

		// 若是字符串是""空串，或者是null，則返回true
		Assert.assertTrue(Strings.isNullOrEmpty("")
				&& Strings.isNullOrEmpty(null));
	}

	@Test
	public void testCharMatcher() {
		String text = "My name is    loda,  I'm a IT guy!";

		// 將多個空格合併爲一個空格
		String after = CharMatcher.WHITESPACE.collapseFrom(text, ' ');

		Assert.assertEquals(after, "My name is loda, I'm a IT guy!");

		String charWithNumber = "12xabd34";

		Assert.assertEquals(CharMatcher.JAVA_DIGIT.retainFrom(charWithNumber),
				"1234");
	}

	@Test
	public void testPreconditions() {
		int a = 10;
		Preconditions.checkArgument(a > 10, "參數必須大於10");
		Preconditions.checkNotNull(null, "不能爲空");

	}

	@Test
	public void testMoreObjects() {
		Student s = new Student(1, null, "male", 13);

		// 利用guava的toString格式化對象
		Assert.assertEquals(s.toString(), "Student{id=1, sex=male, age=13}");

		// 查找第一個不爲空的元素，若是都是null，則拋出空指針異常
		Assert.assertEquals(MoreObjects.firstNonNull(null, "jack"), "jack");

		Student s1 = new Student(1, "jack", "female", 13);
		Student s2 = new Student(1, "jack", "male", 14);
		Assert.assertTrue("檢查s1是否小於s2", s1.compareTo(s2) < 0);
	}

	private class Student implements Comparable<Student> {
		public Student(int id, String name, String sex, int age) {
			super();
			this.id = id;
			this.name = name;
			this.sex = sex;
			this.age = age;
		}

		private int id;

		private String name;

		private String sex;

		private int age;

		@Override
		public String toString() {
			return MoreObjects.toStringHelper(this)// 建立ToStringHelper對象
					.omitNullValues()// 忽略空值
					.add("id", id)// 將id添加入內
					.add("name", name)// 將name添加入內
					.add("sex", sex)// 將sex添加入內
					.add("age", age)// 將age添加入內----guava採用鏈表鏈接全部屬性
					.toString();// 將ToStringHelper格式化爲字符串內容
		}

		@Override
		public int compareTo(Student s) {
			// 若是須要對多個值進行進行比較，以完成排序過程，典型寫法爲:
			// return typicalCompare(s);

			// 使用了guava，你就能夠這樣寫了
			return ComparisonChain.start().compare(this.id, s.id)// 將id加入比較器
					.compare(this.name, s.name)// 將name加入比較器
					.compare(this.sex, s.sex)// 將sex加入比較器
					.compare(this.age, s.age)// 將age加入比較器
					.result();// 得出比較結果
		}

		@SuppressWarnings("unused")
		public int typicalCompare(Student s) {
			int result = this.id - s.id;
			// 優先級從高到低，若是某個屬性比較結果相等，則繼續將後面的元素進行比較
			if (result != 0)
				return result;
			result = this.name.compareTo(s.name);

			if (result != 0)
				return result;

			result = this.sex.compareTo(s.sex);

			if (result != 0)
				return result;

			return this.age - s.age;
		}
	}

}