guava框架应用

guava是google的一个开源框架，很好用。以下为我学习过程中的单元测试代码：

字符串匹配


import com.google.common.base.CharMatcher;
import junit.framework.Assert;
import org.eclipse.jetty.util.StringUtil;
import org.junit.Test;

/**
 * Created by IntelliJ IDEA.
 * User: admin
 * Date: 11-11-24
 * Time: 上午11:11
 * To change this template use File | Settings | File Templates.
 * CharMatcher是字符串表达式匹配类,很实用
 */
public class CharMatcherTest {

    @Test
    public void test() {
        Assert.assertTrue(CharMatcher.is('x').apply('x'));
        // 以下表达式表示保留数字和-字符，其它都清掉   运行结果：-888-999082342
        String seriesId = CharMatcher.DIGIT.or(CharMatcher.is('-'))
                            .retainFrom("abcdef-888-999*(*082342ab");
        System.out.println(seriesId);

        // 表示只保留字符串中的数字 运行结果：1065889998123
        String numOnly = CharMatcher.DIGIT.retainFrom("1065889998abcd123L");
        System.out.println(numOnly);

        // 以下表示匹配传参是否均小写 且均是英文字符
        boolean low = CharMatcher.JAVA_LOWER_CASE.matchesAllOf("abcd");
        System.out.println("全是英文且全小写:" + low);

        // 以下表示匹配传参是否均小写且允许是数字的 且均是英文字符
        low = CharMatcher.JAVA_LOWER_CASE.or(CharMatcher.DIGIT).matchesAllOf("abcd3233");
        System.out.println("只允许小写英文和数字:" + low);

        // 从表达式中匹配出所有英文字符  negate()表示取非(不允许)
        System.out.println(CharMatcher.JAVA_LETTER.retainFrom("abcdeABabCD989asdf/2323(*()*&(&"));
        String englistOnly = CharMatcher.JAVA_LETTER_OR_DIGIT.and(CharMatcher.DIGIT.negate())
                .retainFrom("abcdeABabCD989asdf/2323(*()*&(&");
        System.out.println("只允许英文字符：" + englistOnly);

        // 定义成常量以便别的地方调用 一般定义在全局变量中作为一个对像存在
        final CharMatcher SERIES_ID_CHARS = CharMatcher.DIGIT.or(CharMatcher.is('-'));

    }
}

package org.springside.examples.miniweb.guava;

import com.google.common.base.Joiner;
import com.google.common.collect.Maps;
import org.junit.Test;

import java.util.Map;

/**
 * Created by IntelliJ IDEA.
 * User: admin
 * Date: 11-11-24
 * Time: 下午1:37
 * To change this template use File | Settings | File Templates.
 * Joiner主要用于map/字符串数组等的 连接字符串操作
 * 例如将数组以某个字符串分隔并组成新的字符串等
 */
public class JoinerTest {

    @Test
    public void test() {

        // 对数组的每个对像加|分隔开
        String result = Joiner.on("|").join(new String[] {"abc", "陈国道", "张兴强"});
        System.out.println(result);

        // 将null值过滤，并用,号隔开连接后的字符串
        String r2 = Joiner.on(",").skipNulls().join(new String[]{null, "陈陈", "李四", "张三"});
        System.out.println(r2);

        // 允许使用空值的，将字符串用,号隔开进行连接，并将null值替换成null
        String r3 = Joiner.on(",").useForNull("null").join(new String[]{null, "陈陈", "李四", "张三"});
        System.out.println(r3);

        // 匹配这个表达式join(@Nullable Object first, @Nullable Object second, Object... rest)
        r3 = Joiner.on(",").skipNulls().join(null, "陈陈", "李四", "张三", "guo");
        System.out.println(r3);

        // 将MAP的key/value为null值时替换为NODATA,然后用,号分隔,key和value间用:分隔
        // 以下执行结果为：NODATA:aa,sex:男,address:福建省厦门市思明区,tel:NODATA,name:guoguo
        final Joiner.MapJoiner MAP_JOINER = Joiner.on(",").useForNull("NODATA").withKeyValueSeparator(":");
        Map map = Maps.newHashMap();    // 相当于
        map.put("name", "guoguo");
        map.put("sex", "男");
        map.put("address", "福建省厦门市思明区");
        map.put("tel", null);
        map.put(null, "aa");
        String mapResult = MAP_JOINER.join(map);
        System.out.println("对map的处理结果:\n" + mapResult);

    }
}

Object

import com.google.common.base.Objects;
import com.sun.istack.internal.NotNull;
import junit.framework.Assert;
import org.junit.Test;
import org.springside.examples.miniweb.entity.account.User;

import javax.annotation.Nullable;


/**
 * Created by IntelliJ IDEA.
 * User: admin
 * Date: 11-11-24
 * Time: 上午10:02
 * To change this template use File | Settings | File Templates.
 * Objects主要是对像操作类，常用于比较对像是否相等，计算hashcode,打印对像所有内容等
 */
public class ObjectTest {

    /**
     * objects.firstNonNull返回两对像中第一个不为空的对像 从左到右
     */
    @Test
    public void testFirstNonNull() {
        User u = new User();
        u.setName("guoguo");
        User uUser = new User();
        uUser.setName("陈陈");
        User result = Objects.firstNonNull(u, uUser);
        Assert.assertNotNull(result);
        System.out.println(result.getName());
    }

    /**
     * Objects.equals(a, b)   这个挺实用可以减少代码
     * 用于比较a和b是否相等
     * 可以是简单类型也可以是对像
     */
    @Test
    public void testEquals() {
        int a = 100;
        int b = 100;
        Assert.assertTrue(Objects.equal(a, b));
        User u = new User();
        u.setName("guoguo");
        User ub = new User();
        ub.setName("guoguo");

        Long l1 = 1l;
        Long l2 = 1l;
        Assert.assertTrue(Objects.equal(l1, l2));
        //ub = u;
        Assert.assertTrue(Objects.equal(u, ub));
    }

    /**
     * 计算对像或多属性的hashcode(Object... objects)允许1到多参
     */
    @Test
    public void tsetHashCode() {
        User ub = new User();
        ub.setName("guoguo");
        System.out.println(Objects.hashCode(ub));
        System.out.println(Objects.hashCode(ub, ub));
        System.out.println(Objects.hashCode(ub, ub, ub));
    }

    /**
     * Objects.toStringHelper(Object self)
     * 一般用于显示一个实体对像的所有属性时可以用到
     * 输出结果形如：TestClass{name=namesss, address=address, sex=男}
     */
    @Test
    public void testtoStringHelper() {
        String result = Objects.toStringHelper(TestClass.class).add("name", "namesss")
                .add("address", "address")
                .add("sex", "男").toString();
        System.out.print(result);
    }

    /**
     * simpleName 这个应该是显示类的简名，比如去掉包之类的，
     * 但我一直测试不通过，主要是参数实参是什么样的一直搞不清楚
     */
    @Test
    public void testsimpleName() {
        //System.out.println(Objects.simpleName(TestClass.class));
    }
}

class TestClass {
    String name = "陈陈";
    String sex = "男";
    private String address = "福建省厦门市";
}

import com.google.common.base.Preconditions;
import org.junit.Test;

/**
 * Created by IntelliJ IDEA.
 * User: admin
 * Date: 11-11-24
 * Time: 上午10:53
 * To change this template use File | Settings | File Templates.
 * Preconditions主要用于状态检测抛出异常和数组范围检测
 */
public class PreconditionsTest {

    /**
     * checkState根据表达式结果，抛出状态异常（是一个RuntimeException:IllegalStateException）
     * IllegalStateException
     */
    @Test
    public void testcheckState() {
        //
        Preconditions.checkState(true); // 表达式为TRUE不抛异常
        int state = 0;
        Preconditions.checkState(state == 1, "播放异常，当前状态值为: %s", state);
        //Preconditions.checkState(state == 1, "播放异常，当前状态值为: %s - %s", state, state + 100);
    }

    /**
     * Preconditions.checkPositionIndex(int index, int size)
     * 防止出现数组的越界访问等
     */
    @Test
    public void testcheckPositionIndex() {
        String[] a = new String[] {"aa", "bb", "33", "44"};
        Preconditions.checkPositionIndex(0, a.length - 1);
    }
}

mport com.google.common.base.CharMatcher;
import com.google.common.base.Splitter;
import org.junit.Test;

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

/**
 * Created by IntelliJ IDEA.
 * User: admin
 * Date: 11-11-24
 * Time: 下午2:06
 * To change this template use File | Settings | File Templates.
 * Splitter类主要用于字符串处理里的分割处理
 */
public class SplitterTest {

    @Test
    public void test() {
        String result;
        // 将字符串分隔形成一个Iterable实现
        Iterable<String> itResult = Splitter.on(",").split("待处理的字符串,这是一个完整的字符串,分割后将变成一个数组。");
        Iterator<String> it = itResult.iterator();
        while (it.hasNext()) {
            System.out.println("" + it.next());
        }

        // 将字符串分隔后形成一个map  keyvale的分隔字符为: 每个键值对间用,号分隔
        String waitToTreat = "[name: bb, address: \n福建省 厦门市, sex:男]";
        System.out.println("处理前：\n" + waitToTreat);
        // 去掉[] 去掉空格 去掉回车\n
        CharMatcher cm = CharMatcher.ANY.and(CharMatcher.is('[').negate()).and(CharMatcher.is(']').negate())
                .and(CharMatcher.WHITESPACE.negate()).and(CharMatcher.is('\n').negate());
        waitToTreat = cm.retainFrom(waitToTreat);
        System.out.println("处理后：\n" + waitToTreat);

        Splitter.MapSplitter mapSplitter = Splitter.on(",").trimResults().withKeyValueSeparator(":");
        // 将字符串分析后形成MAP
        Map mapResult = mapSplitter.split(waitToTreat);
        for (Iterator iter = mapResult.entrySet().iterator(); iter.hasNext();) {
            Map.Entry element = (Map.Entry) iter.next();
            System.out.println("Key:" + element.getKey().toString().trim() + "，Value:"
                    + element.getValue().toString().trim());
        }
    }
}