java代码（9） ---guava之Lists、Maps

---

 guava之Lists、Maps

---

谷歌提供了guava包里面有很多的工具类，Lists和Maps集合工具，集合操作做了些优化提升

一、概述

1、静态工厂方法

　　（1）Guava提供了能够推断泛型的静态工厂方法

　　List<Person>   list = Lists.newArrayList();

　　Map<keyType,Person> map = Maps.newLinkedHashMap();

　　（2）用工厂方法模式，我们可以方便地在初始化时就指定起始元素

　　Set(Type)  copySet = Sets.newHashSet(elements);

　　List<String>  theseElements = Lists.newArrayList("alpha","beta","gamma");

　　（3）通过为工厂方法命名，我们可以提高集合初始化大小的可读性

　　List<Type> exactly100=Lists.newArrayListWithCapacity(100);

　    List<Type> approx100=Lists.newArrayListWithExpectedSize(100);

　    Set<Type> approx100Set=Sets.newHashSetWithExpectedSize(100);

 2、Lists案例

public class ListsTest {

    public static void main(String[] args) {

        List<String> list1 = Lists.newArrayList();

        for (int i = 0; i < 10; i++) {

            list1.add(i+"");

        }

        System.out.println("list1:"+list1);

        //传入多参数

        List<String> list2 = Lists.newArrayList("1", "2", "3");

        System.out.println("list2:"+list2);

        //传入数组

        List<String> list3=Lists.newArrayList(new String[]{"22","33"});

        System.out.println("list3:"+list3);

        //传入集合

        List<String> list4=Lists.newArrayList(list1);

        System.out.println("list4:"+list4);

        //使用条件：你确定你的容器会装多少个，不确定就用一般形式的

        //说明：这个容器超过10个还是会自动扩容，不用担心容量不够用，默认是分配一个容量为10的数组，不够将扩容

        //整个来说的优点有：节约内存，节约时间，节约性能，代码质量提高

        List<String> list=Lists.newArrayListWithExpectedSize(10);

        //这个方法就是直接返回一个10的数组

        List<String>  list5=Lists.newArrayListWithCapacity(10);

    }

}

三、Maps案例

public class MapsTest {

    public static void main(String[] args) {

        //1 Maps.newHashMap() 获得HashMap();

        Map<Integer,Integer> map1= Maps.newHashMap();

        for (int i = 0; i < 10; i++) {

            map1.put(i,i);

        }

        System.out.println("map1:"+map1);

        //输出：map1:{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9}

        //2、传入map1参数构建map

        Map<Integer,Integer> map2 = Maps.newHashMap(map1);

        map2.put(10,10);

        System.out.println("map2:"+map2);

        //输出 ：map2:{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9, 10=10}

        //3、使用条件，你确定你的容器会装多少个，不确定就用一般形式的

        //说明：这个容器超过3个还是会自动扩容，不用担心容量不够用，默认是分配一个容量为16的数组，不够将扩容

        Map<Integer,Integer> map3 = Maps.newHashMapWithExpectedSize(3);

        map3.put(1,1);

        map3.put(2,2);

        map3.put(3,3);

        System.out.println(map3);

        //输出： {1=1, 2=2, 3=3}

        //4、LinkedHashMap<K, V> 有序map

        //Map<Integer,Integer> map4 = Maps.newLinkedHashMap();

        //Map<Integer,Integer> map4 = Maps.newLinkedHashMapWithExpectedSize(11);

        Map<Integer, Integer> map4 = Maps.newLinkedHashMap(map1);

        map4.put(11, 11);

        System.out.println("map3：" + map4);

        //输出：map3：{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9, 10=10, 11=11}

        outMapKeyValue(map4);

    }

    /**

     * 遍历map的四种方法

     * @param map4

     */

    private static void outMapKeyValue(Map<Integer,Integer> map4){

        //1:通过Map.entrySet遍历key和value

        for (Map.Entry<Integer, Integer> integerEntry : map4.entrySet()) {

            System.out.println("key:"+integerEntry.getKey()+"value:"+integerEntry.getValue());

        }

        //2:通过Map.entrySet使用iterator遍历key和value --不推荐，直接使用上面的for each循环替代此方法

        Iterator<Map.Entry<Integer, Integer>> it = map4.entrySet().iterator();

        while (it.hasNext()) {

            Map.Entry<Integer, Integer> entry = it.next();

            System.out.println("key:"+entry.getKey()+"value:"+entry.getValue());

        }

        //3,通过Map.keySet遍历key,根据key得到value

        for (Integer integer : map4.keySet()) {

            System.out.println("key:"+integer+"value:"+map4.get(integer));

        }

        //4通过Map.values遍历所有的value,但不能遍历key

        for (Integer integer : map4.values()) {

            System.out.println("value:"+integer);

        }

    }

}