hbw-utils - guava基本数据类型工具类常用方法的整理

世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。

正如标题第一个字段所写，我正在致力于开发一款全新的工具类。工具类应该是程序中最最基础、最最稳定的类，所以要开发有自己特色的工具类，如果完全手写，那是不可能的，没有经过验证或是只经过简单测试的代码是不能用在生产中的。因此我决定集成现有成熟的工具类体系并在一定程度上加上自己的想法，使其变成统一的更加易于使用的工具。并且在此基础上，通过工具组合形成一个个成形的开箱即用的组件，这样以工具类为基础的组件库就成形了，那么以后开发效率也就会成百上千倍的提高。当然最高理想是，一个人就可以顶一个公司，这样才能实现一个程序员的真正自由。
好了，还得从基础开始，要研究工具类，guava是不能跳过的。所以在封装的过程中，对于基础数据类型的操作，我选择了guava中以下常用方法：

asList ： 将基本数据类型转为List
checkedCast ： long类型向低阶类型的强转
concat ： 多个基本类型数组拼接为一个数组
contains ： 数组中是否包含某个元素
ensureCapacity ： 数组扩容
fromByteArray ： 将byte[]转为对应的基本数据类型
hashCode : 基本数据类型的封装类对应的hashCode值
indexOf ：某个元素或是某个子数组在数组中的正向第一次出现的位置下标
lastIndexOf ：某个元素在数组中反向第一次出现的位置下标
reverse ： 数组元素的反转
sortDescending ： 数组元素从大到小倒叙排序
toArray ： 将集合转为对应的基本数据类型的数组
toByteArray ： 将基本数据类型转为byte[]

以典型的int为例展示一下其使用：

	@Test
    public void intTest() {

        int[] is = {1, 3, 5, 7, 9};
        int[] iss = {3, 5};
        int i = 5;
        long l = 10L;

        List<Integer> ls = Ints.asList(is);
        assert 5 == ls.size();
        System.out.println("asList : " + ls);

        int ckc = Ints.checkedCast(l);
        assert 10 == ckc;

        int[] ris = Ints.concat(is, iss);
        assert 7 == ris.length;
        for (int ris1 : ris) {
            System.out.println("concat : " + ris1);
        }

        boolean cns = Ints.contains(is, i);
        assert cns;

        int[] ext = Ints.ensureCapacity(is, 6, 1);
        assert 7 == ext.length;
        for (int i1 : ext) {
            System.out.println("ensureCapacity : " + i1);
        }

        byte[] bytes = Ints.toByteArray(i);
        for (byte b : bytes) {
            System.out.println("toByteArray : " + b);
        }

        int ri = Ints.fromByteArray(bytes);
        assert i == ri;

        int hc = Ints.hashCode(i);
        System.out.println("hashCode : " + hc);

        int idx = Ints.indexOf(is, i);
        assert 2 == idx;

        int idx1 = Ints.indexOf(is, iss);
        assert 1 == idx1;

        int idx2 = Ints.lastIndexOf(is, i);
        assert idx == idx2;

        int[] rev = {1, 3, 5, 7, 9};
        Ints.reverse(rev);
        for (int i1 : rev) {
            System.out.println("reverse : " + i1);
        }

        int[] sd = {1, 5, 3, 7, 9 };
        Ints.sortDescending(sd);
        for (int i1 : sd) {
            System.out.println("sortDescending : " + i1);
        }

        int[] arr = Ints.toArray(Arrays.asList(1, 3, 5, 7, 9));
        for (int i1 : arr) {
            System.out.println("toArray : " + i1);
        }
    }

输出结果：

asList : [1, 3, 5, 7, 9]
concat : 1
concat : 3
concat : 5
concat : 7
concat : 9
concat : 3
concat : 5
ensureCapacity : 1
ensureCapacity : 3
ensureCapacity : 5
ensureCapacity : 7
ensureCapacity : 9
ensureCapacity : 0
ensureCapacity : 0
toByteArray : 0
toByteArray : 0
toByteArray : 0
toByteArray : 5
hashCode : 5
reverse : 9
reverse : 7
reverse : 5
reverse : 3
reverse : 1
sortDescending : 9
sortDescending : 7
sortDescending : 5
sortDescending : 3
sortDescending : 1
toArray : 1
toArray : 3
toArray : 5
toArray : 7
toArray : 9

以上可见，如果是只有一种数据类型，其实使用起来是比较方便的，但是在实际中，我们会面对各种各样的数据类型的选取以及来自于不同引用源的相似方法的选用，使用起来是不太方便并且容易造成引用错误导致的异常，并且这种异常可能是很难排查的，毕竟方法名相同、输入输出一致。甚至在开发中引用时也得花费较长时间查找所需的方法及选取所用的包。针对这种情况以及我的伟大理想，我正在开发一款全新的集成工具类，现在能透露的就是这个工具类与平常使用的直接的Class.method是有区别的。大家敬请期待吧！