Lists、Sets、Maps和Collections2的使用

1、Lists

private static void list(){
	//ArrayList
	//ArrayList<String> arrayList = Lists.newArrayList();
	ArrayList<String> arrayList = Lists.newArrayListWithCapacity(10); //初始容量
	arrayList = Lists.newArrayList("D", "E", "F");
	arrayList.add("A");
	arrayList.add("B");
	arrayList.add("C");
	System.out.println(arrayList);
	
	//LinkedList 可以作为双端队列、堆栈使用
	LinkedList<String> linkedList = Lists.newLinkedList();
	linkedList.add("A");  
	linkedList.add("B");  
	linkedList.add("C");  
	System.out.println(linkedList);

	linkedList.addFirst("0");
	linkedList.addLast("1");
	System.out.println(linkedList);
	
	System.out.println(linkedList.getFirst());
	System.out.println(linkedList.getLast());
	System.out.println(linkedList.get(0));
	System.out.println(linkedList);
	
	linkedList.poll(); //从list头取元素
	linkedList.pop(); //出栈：取出list的第一个元素
	linkedList.push("D"); //入栈：将元素放入list的前面
	System.out.println(linkedList);
	
	//CopyOnWriteArrayList
	CopyOnWriteArrayList<String> copyOnWriteArrayList = Lists.newCopyOnWriteArrayList();
	copyOnWriteArrayList.add("A");
	copyOnWriteArrayList.addIfAbsent("A");
	System.out.println(copyOnWriteArrayList);
	
	//集合分割，指定子集合的最大大小
	List<List<String>> subList = Lists.partition(arrayList, 2);
	subList.stream().forEach(System.out::println);
	
	//集合翻转
	Lists.reverse(arrayList).stream().forEach(System.out::print);
	System.out.println();
	Lists.reverse(linkedList).stream().forEach(System.out::print);
}

 

2、Sets

private static void set(){
	//HashSet
//		HashSet<String> set1 = Sets.newHashSet();
	HashSet<String> set1 = Sets.newHashSet("A", "B", "C");
	set1.add("D");
	set1.add("E");
	set1.add("F");
	System.out.println(set1);
	
	//LinkedHashSet
	LinkedHashSet<String> set2 = Sets.newLinkedHashSet();
	set2.add("D");
	set2.add("E");
	set2.add("F");
	set2.add("G");
	set2.add("H");
	System.out.println(set2);
	
	SetView<String> setView1 = Sets.union(set1, set2); //并集
	System.out.println(setView1); //[A, B, C, D, E, F, G, H]
	
	SetView<String> setView2 = Sets.intersection(set1, set2); //交集
	System.out.println(setView2); //[D, E, F]
	
	SetView<String> setView3 = Sets.difference(set1, set2); //返回set1中不在set2的元素
	System.out.println(setView3); //[A, B, C]
	
	//笛卡尔积 cartesianProduct
	//[[gerbil, apple], [gerbil, orange], [gerbil, banana], [hamster, apple], [hamster, orange], [hamster, banana]]
	Set<String> animals = ImmutableSet.of("gerbil", "hamster");
	Set<String> fruits = ImmutableSet.of("apple", "orange", "banana");
	Set<List<String>> product = Sets.cartesianProduct(animals, fruits);

//[[gerbil, apple], [gerbil, orange], [gerbil, banana], [hamster, apple], [hamster, orange], [hamster, banana]]
	System.out.println(product);
	
	//ConcurrentHashMap
	Set<String> set11 = Sets.newConcurrentHashSet();
	
	//CopyOnWriteArraySet
	CopyOnWriteArraySet<String> set22 = Sets.newCopyOnWriteArraySet();
	
	//TreeSet
	TreeSet<String> treeSet = Sets.newTreeSet();
}

 

3、Maps

private static void map(){
	//两个map比较
	Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3, "d", 4);
	Map<String, Integer> right = ImmutableMap.of("c", 30, "d", 4, "e", 5, "f", 6);
	MapDifference<String, Integer> diff = Maps.difference(left, right);
	
	System.out.println(diff.entriesDiffering()); //返回键相同而值不同的两边的值  {c=(3, 30)}
	System.out.println(diff.entriesInCommon()); //交集：键值都匹配  {d=4}
	System.out.println(diff.entriesOnlyOnLeft()); //返回只存在于左边Map的项，匹配key  {a=1, b=2}
	System.out.println(diff.entriesOnlyOnRight()); //返回只存在于右边Map的项，匹配key  {e=5, f=6}
	System.out.println(diff.areEqual()); //两个map是否相等  false
	
	//ConcurrentMap
	ConcurrentMap<String, String> concurrentMap = Maps.newConcurrentMap();
	
	//HashMap
	HashMap<String, String> hashMap = Maps.newHashMap();
	
	//LinkedHashMap
	LinkedHashMap<String, String> linkedHashMap = Maps.newLinkedHashMap();
	
	//TreeMap
	TreeMap<String, String> treeMap = Maps.newTreeMap();
}

 

4、Collections2

private static void collections2() {
	//集合数据过滤：apply方法等于true时返回
	ImmutableList<String> list = ImmutableList.of("A", "B", "BC", "D", "AE");
	Collection<String> collection1 = Collections2.filter(list, new Predicate<String>() {
		public boolean apply(String input) {
			return input.indexOf("A") >= 0;
		};
	});
	System.out.println(collection1); //[A, AE]
	
	//集合数据转换：  
	Collection<String> collection2 = Collections2.transform(list, new Function<String, String>() {
		@Override
		public String apply(String input) {
			return input.toLowerCase();
		}
	});
	System.out.println(collection2); //[a, b, bc, d, ae]
}