List
List常用方法
list删除元素
// 方式一
for(int i = list.size() - 1; i >= 0; i--){
list.remove(i);
i--;
}
// 方式二
Iterator<Entity> iterator = infoList.iterator();
while(iterator.hasNext()){
Entity info = iterator.next();
if (xxx!=info.getXXX()){
iterator.remove();
};
}
// 方式三
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>(list);
for (String str : list) {
if ("xxx".equals(str)) {
list.remove(str);
}
}
list转Set
new HashSet<>(Arrays.asList(list));
list中的匹配元素放在第一位
for (Entity info : list) {
if ("xxx".equals(info.getXXX)) {
list.remove(info);
list.add(0, info);
}
}
list获取最小值
int minId = infoList.stream().mapToInt(Entity -> Entity.getId()).min().getAsInt();
Collection 转 List
// 方式一
Collection<String> collection = new ArrayList<>();
List<String> list = new ArrayList<>(collection);
// 方式二
List<String> list = new ArrayList<>();
list.addAll(collection);
list获取对象中的一个属性并转为list
List<Entity> infoList = new ArrayList<>();
// getId的类型与List中<>的类型强关联，若是出现红色波浪线优先检查这两个地方
// 提取出list对象中的一个属性
List<Long> idList = infoList.stream().map(Entity::getId).collect(Collectors.toList());
// 提取出list对象中的一个属性并去重
idList = infoList.stream().map(Entity::getId).distinct().collect(Collectors.toList());
// list将一个类型的集合转换成另一种类型的集合
List<String> strList = infoList.stream().map(info->{return Entity.getId().toString();}).distinct().collect(Collectors.toList());
List<String> strList = infoList.stream().map(Entity::getId).map(Object::toString()).distinct().collect(Collectors.toList());
list按照条件获取对象
List<Entity> infoList = new ArrayList<>();
// 匹配name等于皮卡兵的数据
infoList = infoList.stream().filter(info -> info.getName().equals("皮卡兵")).collect(Collectors.toList());
// 按照某个字段去重得到list对象
infoList = infoList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Entity::getId))), ArrayList::new));
list转换map(弊端：转换过程中，若key重复，则异常)
// value 是字段
Map<String, String> map = list.stream().collect(Collectors.toMap(Entity::getId, Entity::getName));
// value 是实体
Map<String, Entity> paramCalcrateMap = paramCalcrates.stream().collect(Collectors.toMap(info -> info.getId(), Function.identity()));
list排序
stream 按照条件排序
List<Entity> infoList = infoList.stream()
.sorted(Comparator.comparingInt(Entity::getId))
.collect(Collectors.toList());
Collections.sort 按照条件排序
// 升序标识
boolean ascSortFlag = true;
List<Entry> list = new ArrayList<Entry>();
Collections.sort(list, new Comparator<Entry>() {
@Override
public int compare(Entry entry1, Entry entry2) {
if(ascSortFlag) {
// 名字升序
return entry1.getName().compareTo(entry2.getName());
} else {
// 添加时间降序
return entry2.getInsertTime().compareTo(entry1.getInsertTime());
}
}
});
List去重
去重效率比较
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.TreeSet;
/**
* @author 马家立
* @version 创建时间是：2019年8月16日上午9：35：11
* @Description： List去重效率比较
*/
public class listRemoveDuplicate {
/**
* @Title：removeDuplicateByEquals
* @author：马家立
* @date：2019年9月18日 @Description： 方式1：双重for_iterate循环_equals_remove去重
* @param <E>
* @param list
* void
*/
public static <E> void removeDuplicateByEquals(List<E> list) {
for (int i = 0; i < list.size(); i++) {
for (int j = i + 1; j < list.size(); j++) {
if (list.get(i).equals(list.get(j))) {
list.remove(j);
}
}
}
}
/**
* @Title：removeDuplicateByHashSet
* @author：马家立
* @date：2019年9月18日
* @Description： 方式2：HashSet无序去重
* @param <E>
* @param list
* void
*/
public static <E> void removeDuplicateByHashSet(List<E> list) {
// 初始化HashSet对象
HashSet<E> set = new HashSet<E>();
List<E> result = new ArrayList<E>();
for (E e : result) {
if (set.add(e)) {
result.add(e);
}
}
// 把List集合所有元素清空
list.clear();
// 把HashSet对象添加至List集合
list.addAll(result);
}
/**
* @Title：removeDuplicateByLinkedHashSet
* @author：马家立
* @date：2019年9月18日 @Description： 方式3：LinkedHashSet有序去重
* @param <E>
* @param list
* void
*/
public static <E> void removeDuplicateByLinkedHashSet(List<E> list) {
// 初始化LinkedHashSet对象，并把list对象元素赋值给LinkedHashSet对象
LinkedHashSet<E> set = new LinkedHashSet<E>(list);
// 把List集合所有元素清空
list.clear();
// 把LinkedHashSet对象添加至List集合
list.addAll(set);
}
/**
* @Title：removeDuplicateByTreeSet
* @author：马家立
* @date：2019年9月18日 @Description： 方式4：TreeSet去重
* @param <E>
* @param list
* void
*/
public static <E> void removeDuplicateByTreeSet(List<E> list) {
// 初始化TreeSet对象，并把list对象元素赋值给TreeSet对象
TreeSet<E> treeSet = new TreeSet<E>(list);
// 把List集合所有元素清空
list.clear();
// 把TreeSet对象添加至List集合
list.addAll(treeSet);
}
/**
* @Title：removeDuplicateByContains1
* @author：马家立
* @date：2019年9月18日
* @Description： 方式5：forEach方式循环_contains去重
* @param <E>
* @param list
* void
*/
public static <E> void removeDuplicateByContains1(List<E> list) {
List<E> result = new ArrayList<E>();
for (E e : list) {
if (!result.contains(e)) {
result.add(e);
}
}
// 把List集合所有元素清空
list.clear();
// 把所有对象添加至List集合
list.addAll(result);
}
/**
* @Title：removeDuplicateByContains2
* @author：马家立
* @date：2019年9月18日 @Description： 方式6：list.stream()方式循环_contains去重
* @param <E>
* @param list
* void
*/
public static <E> void removeDuplicateByContains2(List<E> list) {
List<E> result = new ArrayList<E>(list.size());
list.stream().forEach(p -> {
if (!result.contains(p)) {
result.add(p);
}
});
}
public static void main(String[] args) {
// 声明List
final List<String> list = new ArrayList<String>();
// List添加数据
for (int i = 0; i < 1000; i++) {
if (0 == (i % 50)) {
list.add("我是皮卡兵");
} else if (0 == (i % 25)) {
list.add("我是皮卡乒");
} else if (0 == (i % 10)) {
list.add("我是皮卡乓");
} else if (0 == (i % 5)) {
list.add("我是皮卡皮");
} else {
list.add("我是第-" + i + "个皮卡丘");
}
list.add("哇咔哇,电光一闪");
}
List<String> list1 = list;
List<String> list2 = list;
List<String> list3 = list;
List<String> list4 = list;
List<String> list5 = list;
List<String> list6 = list;
// 循环次数
int forTimes = 100;
// 纳秒级别
long time = System.nanoTime();
// 方式一
for (int i = 0; i < forTimes; i++) {
removeDuplicateByEquals(list1);
}
long time4 = System.nanoTime();
System.out.println("方式1：双重for_iterate循环_equals_remove去重的时间是：\t" + ((time1 - time)) + "纳秒");
// 方式二
for (int i = 0; i < forTimes; i++) {
removeDuplicateByHashSet(list2);
}
long time1 = System.nanoTime();
System.out.println("方式1：HashSet无序去重的时间是：\t" + ((time2 - time1)) + "纳秒");
// 方式三
for (int i = 0; i < forTimes; i++) {
removeDuplicateByLinkedHashSet(list3);
}
long time2 = System.nanoTime();
System.out.println("方式2：LinkedHashSet有序去重的时间是：\t" + ((time3 - time2)) + "纳秒");
// 方式四
for (int i = 0; i < forTimes; i++) {
removeDuplicateByTreeSet(list4);
}
long time3 = System.nanoTime();
System.out.println("方式4：TreeSet去重的时间是：\t" + ((time4 - time3)) + "纳秒");
// 方式五
for (int i = 0; i < forTimes; i++) {
removeDuplicateByContains1(list5);
}
long time5 = System.nanoTime();
System.out.println("方式5：forEach方式循环_contains去重的时间是：\t" + ((time5 - time4)) + "纳秒");
// 方式六
for (int i = 0; i < forTimes; i++) {
removeDuplicateByContains2(list6);
}
long time6 = System.nanoTime();
System.out.println("方式6：list.stream()方式循环_contains去重的时间是：\t" + ((time6 - time5)) + "纳秒");
}
}
结果：
方式1：双重for_iterate循环_equals_remove去重的时间是： 37300纳秒
方式2：HashSet无序去重的时间是： 330200纳秒
方式3：LinkedHashSet有序去重的时间是： 660500纳秒
方式4：TreeSet去重的时间是： 758700纳秒
方式5：forEach方式循环_contains去重的时间是： 146900纳秒
方式6：list.stream()方式循环_contains去重的时间是： 41510900纳秒
list便捷去重
List<String> list = list.stream().distinct();
list推荐去重
/**
* @Title:removeDuplicate
* @author:踏步
* @date:2019年5月23日 下午2:31:40
* @Description: List去重
* @param 需要去除重复项的list
* @return 返回去重后的list
*/
public static List removeDuplicate(List list) {
try {
for (int i = 0; i < list.size(); i++) {
for (int j = i + 1; j < list.size(); j++) {
if (list.get(i).equals(list.get(j))) {
list.remove(j);
}
}
}
} catch (Exception e) {
logger.error("去除List重复项removeDuplicate的方法 err", e);
e.printStackTrace();
}
return list;
}
CollectionUtils常用方法
// Collection转List
Collection<String> collection = CollectionUtils.union(aList, bList);
List<String> list = new ArrayList<>(collection);
- 是否存在交集：boolean isContained = CollectionUtils.containsAny(aList, bList);
- 并集：Collection<String> unionList = CollectionUtils.union(aList, bList);
- 交集：Collection<String> intersectionList = CollectionUtils.intersection(aList, bList);
- 交集的补集：Collection<String> disjunctionList = CollectionUtils.disjunction(aList, bList);
- 集合相减：Collection<String> subtractList = CollectionUtils.subtract(aList, bList);
代码测试
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.ArrayUtils;
/**
* @author 踏步
* @version 创建时间：2020年5月27日下午2:00:00
* @Description:测试类
*/
public class TestCollectionUtils {
public static void main(String[] args) {
String[] arrayA = new String[] { "A", "B", "C", "D", "E", "F" };
String[] arrayB = new String[] { "B", "D", "F", "G", "H", "K" };
List<String> aList = Arrays.asList(arrayA);
List<String> bList = Arrays.asList(arrayB);
// 是否存在交集
boolean isContained = CollectionUtils.containsAny(aList, bList);
// 并集
Collection<String> unionList = CollectionUtils.union(aList, bList);
// 交集
Collection<String> intersectionList = CollectionUtils.intersection(aList, bList);
// 交集的补集
Collection<String> disjunctionList = CollectionUtils.disjunction(aList, bList);
// 集合相减
Collection<String> subtractList = CollectionUtils.subtract(aList, bList);
// 排序
Collections.sort((List<String>) unionList);
Collections.sort((List<String>) intersectionList);
Collections.sort((List<String>) disjunctionList);
Collections.sort((List<String>) subtractList);
// 测试结果
System.out.println("集合--A: " + ArrayUtils.toString(aList.toArray()));
System.out.println("集合--B: " + ArrayUtils.toString(bList.toArray()));
System.out.println("是否存在交集--A has one of B? : " + isContained);
System.out.println("并集--Union(A, B): " + ArrayUtils.toString(unionList.toArray()));
System.out.println("交集--Intersection(A, B): " + ArrayUtils.toString(intersectionList.toArray()));
System.out.println("交集的补集--Disjunction(A, B): " + ArrayUtils.toString(disjunctionList.toArray()));
System.out.println("集合相减--Subtract(A, B): " + ArrayUtils.toString(subtractList.toArray()));
}
}
测试结果
I have a dream : Sandy beach B-J-N.
