Guava 集合工具类

Java provides a Set of operation, the List and Map Collections of tools such as classes, Collections, the tool class provides a number of methods are available for collection, query and modify etc operation, also provides the collection object is immutable, synchronous control method to realize the collection objects. _ _ _

排序操作

方法：

static void reverse(List<?> list): 反转列表中元素的顺序。
static void shuffle(List<?> list) : 对List集合元素进行随机排序。
static void sort(List list) :根据元素的自然顺序对指定列表按升序进行排序
static void sort(List list, Comparator<? super T> c) : 根据指定比较器产生的顺序对指定列表进行排序。
static void swap(List<?> list, int i, int j) :在指定List的指定位置i,j处交换元素。
static void rotate(List<?> list, int distance) :当distance为正数时，将List集合的后distance个元素“整体”移到前面；当distance为负数时，将list集合的前distance个元素“整体”移到后边。该方法不会改变集合的长度。

public class TestSort{
	public static void main(String[] args) 	{
    	ArrayList nums = new ArrayList();
        nums.add(2);
        nums.add(-5);
        nums.add(3);
        nums.add(0);
        //输出:[2, -5, 3, 0]
        System.out.println(nums);
        //将List集合元素的次序反转
        Collections.reverse(nums);
        //输出:[0, 3, -5, 2]
        System.out.println(nums);
        //将List集合元素的按自然顺序排序
        Collections.sort(nums);
        //输出:[-5, 0, 2, 3]
        System.out.println(nums);
        //将List集合元素的按随机顺序排序
        Collections.shuffle(nums);
        //每次输出的次序不固定
        System.out.println(nums);
        //后两个整体移动到前边
        Collections.rotate(nums,2);
        System.out.println(nums);
        }
    }

输出结果：

[2, -5, 3, 0]
[0, 3, -5, 2]
[-5, 0, 2, 3]
[2, 3, -5, 0]
[-5, 0, 2, 3]

查找、替换操作：

static int binarySearch(List<? extends Comparable<? super T>> list, T key):使用二分搜索法搜索指定列表，以获得指定对象在List集合中的索引。

**此前必须保证List集合中的元素已经处于有序状态。
static Object max(Collection coll): 根据元素的自然顺序，返回给定collection 的最大元素。
static Object max(Collection coll,Comparator comp): 根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static Object min(Collection coll): 根据元素的自然顺序，返回给定collection 的最小元素。
static Object min(Collection coll,Comparator comp): 根据指定比较器产生的顺序，返回给定 collection 的最小元素。
static void fill(List<? super T> list, T obj) : 使用指定元素替换指定列表中的所有元素。
static int frequency(Collection<?> c, Object o) :返回指定 collection 中等于指定对象的出现次数。
static int indexOfSubList(List source, List target) : 返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
static int lastIndexOfSubList(List source, List target) :返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
static boolean replaceAll(List list, T oldVal, T newVal) :使用一个新值替换List对象的所有旧值oldVal。

示例：

public class TestSearch{
	public static void main(String[] args) 	{
    ArrayList nums = new ArrayList();
    nums.add(2);
    nums.add(-5);
    nums.add(3);
    nums.add(0);
    //输出:[2, -5, 3, 0]
    System.out.println(nums);
    //输出最大元素，将输出3
    System.out.println(Collections.max(nums));
    //输出最小元素，将输出-5
    System.out.println(Collections.min(nums));
    //将nums中的0使用1来代替
    Collections.replaceAll(nums , 0 , 1);
    //输出:[2, -5, 3, 1]
    System.out.println(nums);
    //判断-5 在List集合中出现的次数，返回1
    System.out.println(Collections.frequency(nums , -5));
    //对nums集合排序
    Collections.sort(nums);
    //输出:[-5, 1, 2, 3]
    System.out.println(nums);
    //只有排序后的List集合才可用二分法查询，输出3
    System.out.println(Collections.binarySearch(nums , 3));
    }
  }

输出结果：

[2, -5, 3, 0]
3
-5
[2, -5, 3, 1]
1
[-5, 1, 2, 3]
3

同步控制：

Collectons提供了多个synchronizedXxx()方法·，该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。

正如前面介绍的HashSet，TreeSet，arrayList,LinkedList,HashMap,TreeMap都是线程不安全的。Collections提供了多个静态方法可以把他们包装成线程同步的集合。

方法如下：

static Collection synchronizedCollection(Collection c) :返回指定 collection 支持的同步（线程安全的）collection。
static List synchronizedList(List list) :返回指定列表支持的同步（线程安全的）列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) :返回由指定映射支持的同步（线程安全的）映射。
static Set synchronizedSet(Set s) : 返回指定 set 支持的同步（线程安全的）set。

示例：

public class TestSynchronized{
	public static void main(String[] args)	{
    //下面程序创建了四个同步的集合对象		Collection c = Collections.synchronizedCollection(new ArrayList());
    List list = Collections.synchronizedList(new ArrayList());
    Set s = Collections.synchronizedSet(new HashSet());
    Map m = Collections.synchronizedMap(new HashMap());
    }
  }

　　多个线程访问同一个集合时设置。。

Collections还可以设置不可变集合，提供了如下三类方法：

emptyXxx(): 返回一个空的、不可变的集合对象，此处的集合既可以是List，也可以是Set，还可以是Map。
singletonXxx(): 返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，此处的集合可以是：List，Set，Map。
unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。

上面三类方法的参数是原有的集合对象，返回值是该集合的”只读“版本。

示例：

    public class TestUnmodifiable{
        public static void main(String[] args)	{

        //创建一个空的、不可改变的List对象
        List<String> unmodifiableList = Collections.emptyList();
        //unmodifiableList.add("java");
        //添加出现异常：java.lang.UnsupportedOperationException
        System.out.println(unmodifiableList);// []
        //创建一个只有一个元素，且不可改变的Set对象
        Set unmodifiableSet = Collections.singleton("Struts2权威指南");
        //[Struts2权威指南]
        System.out.println(unmodifiableSet);
        //创建一个普通Map对象
        Map scores = new HashMap();
        scores.put("语文" , 80);
        scores.put("Java" , 82);
        //返回普通Map对象对应的不可变版本
        Map unmodifiableMap = Collections.unmodifiableMap(scores);
        //下面任意一行代码都将引发UnsupportedOperationException异常
        unmodifiableList.add("测试元素");
        unmodifiableSet.add("测试元素");
        unmodifiableMap.put("语文",90);
        }
     }

Guava Multimap类

多重映射接口扩展映射，使得其键一次可被映射到多个值。

接口声明

	以下是com.google.common.collect.Multimap<K，V>接口的声明：
	@GwtCompatible
		public interface Multimap<K,V>

接口方法

Map<K,Collection> asMap()

返回此multimap中的视图，从每个不同的键在键的关联值的非空集合映射。

void clear()

将删除所有multimap中的键值对，留下空。

boolean containsEntry(Object key, Object value)

返回true如果此多重映射包含至少一个键 - 值对用键键和值value。

boolean containsKey(Object key)

返回true，如果这个multimap中至少包含一个键值对的键key。

boolean containsValue(Object value)

返回true，如果这个multimap至少包含一个键值对的值值。

Collection<Map.Entry<K,V» entries()

返回包含在此multimap中，为Map.Entry的情况下，所有的键 - 值对的视图集合。

boolean equals(Object obj)

比较指定对象与此多重映射是否相等。

Collection get(K key)

返回，如果有的话，在这个multimap中键关联的值的视图集合。

int hashCode()

返回此多重映射的哈希码。

boolean isEmpty()

返回true，如果这个multimap中未包含键 - 值对。

Multiset keys()

返回一个视图集合包含从每个键值对这个multimap中的关键，没有折叠重复。

Set keySet()

Returns a view collection of all distinct keys contained in this multimap.

boolean put(K key, V value)

存储键 - 值对在这个multimap中。

boolean putAll(K key, Iterable<? extends V> values)

存储一个键 - 值对在此multimap中的每个值，都使用相同的键 key。

boolean putAll(Multimap<? extends K,? extends V> multimap)

存储了所有键 - 值对多重映射在这个multimap中，通过返回 multimap.entries() 的顺序.

boolean remove(Object key, Object value)

删除一个键 - 值对用键键，并从该多重映射的值的值，如果这样的存在。

Collection removeAll(Object key)

删除与键键关联的所有值。

Collection replaceValues(K key, Iterable<? extends V> values)

存储与相同的键值，替换任何现有值的键的集合。

int size()

返回此多重映射键 - 值对的数量。

Collection values()

返回一个视图集合包含从包含在该multimap中的每个键 - 值对的值，而不发生重复 (so values().size() == size()).

Multimap 示例

使用所选择的任何编辑器创建下面的java程序 C:/> Guava

GuavaTester.java
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;

public class GuavaTester {
   public static void main(String args[]){
      GuavaTester tester = new GuavaTester();
      Multimap<String,String> multimap = tester.getMultimap();

      List<String> lowerList = (List<String>)multimap.get("lower");
      System.out.println("Initial lower case list");
      System.out.println(lowerList.toString());
      lowerList.add("f");
      System.out.println("Modified lower case list");
      System.out.println(lowerList.toString());

      List<String> upperList = (List<String>)multimap.get("upper");
      System.out.println("Initial upper case list");
      System.out.println(upperList.toString());
      upperList.remove("D");
      System.out.println("Modified upper case list");
      System.out.println(upperList.toString());

      Map<String, Collection<String>> map = multimap.asMap();
      System.out.println("Multimap as a map");
      for (Map.Entry<String,  Collection<String>> entry : map.entrySet()) {
         String key = entry.getKey();
         Collection<String> value =  multimap.get("lower");
         System.out.println(key + ":" + value);
      }

      System.out.println("Keys of Multimap");
      Set<String> keys =  multimap.keySet();
      for(String key:keys){
         System.out.println(key);
      }

      System.out.println("Values of Multimap");
      Collection<String> values = multimap.values();
      System.out.println(values);
   }

   private Multimap<String,String> getMultimap(){
      //Map<String, List<String>>
      // lower -> a, b, c, d, e
      // upper -> A, B, C, D

      Multimap<String,String> multimap = ArrayListMultimap.create();

      multimap.put("lower", "a");
      multimap.put("lower", "b");
      multimap.put("lower", "c");
      multimap.put("lower", "d");
      multimap.put("lower", "e");

      multimap.put("upper", "A");
      multimap.put("upper", "B");
      multimap.put("upper", "C");
      multimap.put("upper", "D");
      return multimap;
   }
}

验证结果

使用javac编译器编译如下类

C:\Guava>javac GuavaTester.java 现在运行GuavaTester看到的结果

C:\Guava>java GuavaTester 看到结果。

Initial lower case list
[a, b, c, d, e]
Modified lower case list
[a, b, c, d, e, f]
Initial upper case list
[A, B, C, D]
Modified upper case list
[A, B, C]
Multimap as a map
upper:[a, b, c, d, e, f]
lower:[a, b, c, d, e, f]
Keys of Multimap
upper
lower
Values of Multimap
[A, B, C, a, b, c, d, e, f]