Java集合 最全工具

集合工具在以后公司开发必不可少,必须要牢牢掌握!

本文主要讲两个工具:

  • Collections工具
  • Apache Commons Collections CollectionUtils 工具

在今后的开发中,麻烦首先想到这些工具,不要重复造轮子。。。

Collections工具

Collections是JDK原生集合工具,下面我讲解几个重要方法。我先定义一个原生集合:

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 3, 5);

reverse

将集合进行反转。

Collections.reverse(list);
System.out.println(list);// [5, 3, 5, 4, 3, 2, 1]

shuffle

使用默认的随机源对指定的列表进行随机排列。可以用来进行发牌。

Collections.shuffle(list);  // [1, 5, 5, 4, 3, 2, 3]

sort

集合排序。

// 自然排序
Collections.sort(list);  //[1, 2, 3, 3, 4, 5, 5]
// 自定义比较器排序
Collections.sort(list, new Comparator<Integer>() {  //[5, 5, 4, 3, 3, 2, 1]
			@Override
			public int compare(Integer o1, Integer o2) {
				// 从大到小排序
				return o2 - o1;// Descending order
			}
		});

swap

交换集合中指定位置的元素。 (如果指定的位置相等,调用此方法将保持列表不变。)

// 0位置元素和3位置元素交换
Collections.swap(list, 0, 3); //[4, 2, 3, 1, 5, 3, 5]

rotate

将指定列表中的元素按指定的距离旋转。

// 把元素末尾2个元素搬到前面
Collections.rotate(list, 2);// [3, 5, 1, 2, 3, 4, 5]

max min

最大最小值。

Collections.max(list); //5
Collections.min(list); //1

fill

用指定的元素替换集合中的所有元素。

Collections.fill(list,0);  //[0, 0, 0, 0, 0, 0, 0]

frequency

查找集合中 元素有多少个。

Collections.frequency(list, 5); // 2   5有2个

indexOfSubList

从前往后找查找子集,找不到返回-1,找到第一个就返回位置。

//原始集合1, 2, 3, 4, 5, 3, 5    3,4 在原始集合2的位置
Collections.indexOfSubList(list, Arrays.asList(3,4));   // 2

lastIndexOfSubList 是从后往前找。

replaceAll

将集合中指定元素替换成另外一个。

Collections.replaceAll(list, 5, 0);   //[1, 2, 3, 4, 0, 3, 0]



Apache Commons Collections CollectionUtils 工具

由于不是原生jdk的工具,需要依赖maven:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.1</version>
</dependency>

addIgnoreNull

只添加非空元素

public class Main {
	public static void main(String args[]) {
		List<Integer> list = new ArrayList<Integer>();
		CollectionUtils.addIgnoreNull(list, null);
		CollectionUtils.addIgnoreNull(list, 2);
		System.out.println(list);  // [2]
	}
}

collate

将两个已排序的集合a和b合并为一个已排序的列表——这样元素的自然顺序就保留了下来。

List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(1,2,3));
List<Integer> list2 = new ArrayList<Integer>(Arrays.asList(3,2,1));
List<Integer> sortedList = CollectionUtils.collate(list1, list2);
System.out.println(sortedList);   // [1, 2, 3, 3, 2, 1]

Transforming Objects

按规则提取原集合中的元素,返回新集合。 比如我要提取Person集合中的姓名:

static class Person{
	String name ;
	int age ;
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

public static void main(String args[]) {
	List<Person> list1 = new ArrayList<>(Arrays.asList(new Person("hadluo", 10)
			,new Person("qiiq", 20),new Person("hadluo", 20)));
	Collection<String> names = CollectionUtils.collect(list1, new Transformer<Person, String>() {
		public String transform(Person customer) {
			return customer.name;
		}
	});
	System.out.println(names);
}

程序运行:

https://pic2.zhimg.com/v2-2963cf5abfc250c4c0552840e52fc9dd_b.jpg


filter

对每个元素 执行Predicate规则 来筛选集合。 如果执行Predicate规则返回false,则删除该元素。 比如下面过滤基数的例子:

public static void main(String args[]) {
	List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
	CollectionUtils.filter(list1, new Predicate<Integer>() {
		public boolean evaluate(Integer v) {
			return v % 2 == 0;
		}
	});
	System.out.println(list1);   //  [2, 4]
}


isNotEmpty

监测元素 不为null或者空集合。

System.out.println(CollectionUtils.isNotEmpty(list1)); //false
System.out.println(CollectionUtils.isNotEmpty(null)); // false

isSubCollection 子集

求集合1是否在集合2中。

List<Integer> list1 = new ArrayList<>(Arrays.asList(1,2,3,4,5,6));
List<Integer> list2 = new ArrayList<>(Arrays.asList(3,2,3));
List<Integer> list3 = new ArrayList<>(Arrays.asList(4,5,6));
// list2是否在list1中
System.out.println(CollectionUtils.isSubCollection(list2, list1)); //false
System.out.println(CollectionUtils.isSubCollection(list3, list1)); //true

intersection交集

返回一个集合,其中包含给定可迭代对象的交集。

List<Integer> list1 = new ArrayList<>(Arrays.asList(1,2,3));
List<Integer> list2 = new ArrayList<>(Arrays.asList(3,4,5,6));
System.out.println(CollectionUtils.intersection(list1, list2));  //[3]

subtract差集

接受两个集合作为输入,并返回一个新集合,该集合包含第一个集合中存在但第二个集合中不存在的元素:

List<Integer> list1 = new ArrayList<>(Arrays.asList(1,2,3));
List<Integer> list2 = new ArrayList<>(Arrays.asList(3,4,5,6));
// 在list1 中存在 且 在list2中不存在
System.out.println(CollectionUtils.subtract(list1, list2));  //[1,2]

union并集

返回包含第一个或第二个集合中存在的所有元素。

List<Integer> list1 = new ArrayList<>(Arrays.asList(1,2,3));
List<Integer> list2 = new ArrayList<>(Arrays.asList(3,4,5,6));
System.out.println(CollectionUtils.union(list1, list2));  //[1, 2, 3, 4, 5, 6]



强烈推荐一篇 干货,精华 博客:

java架构师修炼

支付宝打赏 微信打赏

如果文章对您有帮助,您可以鼓励一下作者