目录
list集合初始化
map初始化
获取list集合中的最大最小值
list排序
list对象时间排序
treeMap 中（基于key的排序）
TreeMap的按value排序
Map按value排序2
去掉一个list中包含的另一个list数据
String数组转换成List
list对象转对象某属性的list
list对象转成Map
map转list
JSON中string转List
list集合从前面追加数据
list与list互转
将list集合，元素随机打乱
根据下标替换元素
stream api对象过滤空
list使用 stream api去重
List根据某属性删除对象
List获取某属性重复的对象
List根据某属性去重
list根据某属性分组
List分割数据, 例每次请求500条数据
List转map重复key报错java.lang.IllegalStateException: Duplicate key 0
list求交集
list集合初始化
- 常用的
import java.util.ArrayList;
import java.util.List;
/**
* @Author: szw
* @Date: 2020/6/3 9:23
*/
public class ListTest {
public static void main(String[] args) {
List<String> languages = new ArrayList<>();
languages.add("Java");
languages.add("List");
languages.add("ArrayList");
}
}
- 匿名内部类，
import java.util.ArrayList;
import java.util.List;
/**
* @Author: szw
* @Date: 2020/6/3 9:23
*/
public class ListTest {
static String str = "112233";
// {{}} 双括号, 外层的 {} 定义了一个匿名内部类。内层的 {} 的定义了一个实例初始化代码块
static List<String> list = new ArrayList<String>() {
{ // 这个大括号 就是 构造代码块 会在构造函数前 调用
this.add("11"); //this 可以省略
add("21");
add("31");
add(str);
}
};
public static void main(String[] args) {
System.out.println(list);
}
}
- Arrays 工具类和Collections 工具类，不可变的 List
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* @Author: szw
* @Date: 2020/6/3 9:23
*/
public class ListTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("Java", "Jdk", "Jre");
List<String> list2 = Collections.nCopies(3, "apple");
}
}
这种得到的是不可变的 List, 不能增删，如果要可变，那就使用 ArrayList 再包装一下
List<String> list = new ArrayList<>(Arrays.asList("1", "2", "3"));
List<String> dogs = new ArrayList<>(Collections.nCopies(3, "dog"));
- JDK8 Stream，以下都是不常用的了
List<String> colors = Stream.of("blue", "red", "yellow").collect(toList());
- JDK 9 List.of
List<String> cups = List.of("A", "B", "C");
- guava
// 不可变集合
List<String> list = ImmutableList.of("Hollis", "hollis", "HollisChuang", "H");map初始化
public final static Map<String, String> DUANWEN_MAP_MINGYAN = new HashMap<String, String>() {
{
put("1","励志名言");
put("2","爱情名言");
put("3","爱国名言");
}
};获取list集合中的最大最小值
Collections.min(list);//获取最小值
Collections.max(list);//获取最大值list排序
// JDK1.8以前的老用法，之前一直这样写
Collections.sort(books,new Comparator<Book>() {
@Override
public int compare(Book o1, Book o2) {
// TODO Auto-generated method stub
return o1.getBookPrice() - o2.getBookPrice();
}
});
// JDK1.8
Collections.sort(books,(Book a, Book b) -> { return a.getBookPrice()-b.getBookPrice(); });
// 简写1
Collections.sort(books,(Book a, Book b) -> a.getBookPrice()-b.getBookPrice()); // 正序
Collections.sort(books,(Book a, Book b) -> b.getBookPrice()-a.getBookPrice()); // 倒序
// 简写2
Collections.sort(list, Comparator.comparingInt(Channel::getChnumber)); // 正序
list.sort(Comparator.comparing(User::getSex)); // 正序
list.sort(Comparator.comparing(User::getSex, Comparator.reverseOrder()) // 倒叙
.thenComparing(User::getLevel, Comparator.reverseOrder())); // 倒叙list对象时间排序
static void getSort(List<StatisticsVo> totalList) {
Collections.sort(totalList, (StatisticsVo a, StatisticsVo b) -> {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date aParse = null;
Date bParse = null;
try {
aParse = sdf.parse(a.getDayTimeString());
bParse = sdf.parse(b.getDayTimeString());
} catch (ParseException e) {
e.printStackTrace();
}
return bParse.compareTo(aParse); // 倒叙
});
}treeMap 中（基于key的排序）
treeMap默认的是基于key的从小到大 的排列
自定义排序也是基于key的，如果key object类型 可以自定义各种排序
TreeMap<String, Person> treeMap = new TreeMap<>((String a,String b)-> b.compareTo(a));//降序
TreeMap<String, Person> treeMap = new TreeMap<>((String a,String b)-> a.compareTo(b));//升序TreeMap的按value排序
（转换成entry list 然后排序）汉字是按ascii码排序的，不是汉语拼音
User p1 = new User(1, "A小红");
User p2 = new User(5, "D赵明");
User p3 = new User(2, "W孙宇");
User p4 = new User(9, "C黎明");
TreeMap<String, User> treeMap = new TreeMap<>();
treeMap.put("45", p1);
treeMap.put("12", p2);
treeMap.put("85", p3);
treeMap.put("33", p4);
List<Map.Entry<String, User>> entries = new ArrayList<>(treeMap.entrySet());
Collections.sort(entries,
(Map.Entry<String, User> e1, Map.Entry<String, User> e2) -> ((User) e1.getValue()).getUserName()
.compareTo(((User) e2.getValue()).getUserName()));
System.out.println("按名字顺序排列");
for (Entry<String, User> entry : entries) {
System.out.println(entry.getValue());
}Map按value排序2
JSONObject parse = (JSONObject) JSONObject.parse(data.getOptionName());
Map<String, Object> innerMap = parse.getInnerMap();
List<Map.Entry<String, Object>> entries = new ArrayList<>(innerMap.entrySet());
Collections.sort(entries, Comparator.comparing((Map.Entry<String, Object> e) -> (Integer.valueOf((String) e.getValue()))));去掉一个list中包含的另一个list数据
HashSet<Channel> h1 = new HashSet<>(list);
HashSet<Channel> h2 = new HashSet<>(list2);
h1.removeAll(h2);
list.clear();
list.addAll(h1);String数组转换成List<Integer>
List<Integer> list= Arrays.asList((Integer[]) ConvertUtils.convert(stringArray, Integer.class));
// 将String数组转成Integer数组
Integer[] interArray = (Integer[])ConvertUtils.convert(stringArray, Integer.class);
// String数组转int数组
int[] array = Arrays.asList(strings).stream().mapToInt(Integer::parseInt).toArray();
int[] array = Arrays.stream(strings).mapToInt(Integer::parseInt).toArray();list对象转对象某属性的list
List<String> ids = list.stream()
.map(User::getId)
.collect(Collectors.toList());list对象转成Map
public static Map<Object, Object> getListToObjectMap(List<Student> list) {
Map<Object, Object> map = list.stream().collect(Collectors.toMap(Student::getStuId, student -> student));
map.forEach((key, value) -> {
System.out.println("key:" + key + ",value:" + value);
});
return map;
}map转list
Map<String, String> map = new HashMap<>();
// Convert all Map keys to a List
List<String> result = new ArrayList(map.keySet());
// Convert all Map values to a List
List<String> result2 = new ArrayList(map.values());
// Java 8, Convert all Map keys to a List
List<String> result3 = map.keySet().stream()
.collect(Collectors.toList());
// Java 8, Convert all Map values to a List
List<String> result4 = map.values().stream()
.collect(Collectors.toList());
// Java 8, seem a bit long, but you can enjoy the Stream features like filter and etc.
List<String> result5 = map.values().stream()
.filter(x -> !"apple".equalsIgnoreCase(x))
.collect(Collectors.toList());JSON中string转List<String>
List<String> pList = JSON.parseArray(svcCont4PlaceHolderReq.getMarksList(),String.class);list集合从前面追加数据
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("1111");
list.add("2222");
System.out.println(list); // [1111, 2222]
list.add(0, "qqqqq");
System.out.println(list); // [qqqqq, 1111, 2222]
}list<Integer>与list<String>互转
List<String> stringList = intList.stream().map(String::valueOf).collect(Collectors.toList());
List<Integer> codesInteger = codes.stream().map(Integer::parseInt).collect(Collectors.toList());将list集合，元素随机打乱
2021-07-14更新
- static void shuffle(List<?> list) 使用默认随机源对列表进行置换，所有置换发生的可能性都是大致相等的。
- static void shuffle(List<?> list, Random rand) 使用指定的随机源对指定列表进行置换，所有置换发生的可能性都是大致相等的，假定随机源是公平的。
Collections.shuffle(list); Random rand=new Random(47); Collections.shuffle(list,rand);
根据下标替换元素
jsonArray.set(i, jsonObject);stream api对象过滤空
Set<Long> collect = list.stream().map(DO::getMainId).filter(Objects::nonNull).collect(Collectors.toSet());
Set<Long> collect = list.stream().filter(Objects::nonNull).collect(Collectors.toSet());
Objects::nonNull, 或filter(StringUtils::isNotBlank)判断字符串(import org.apache.commons.lang.StringUtils;)list使用 stream api去重
常用的去重list转set, stream也有对应的api, 注意对象的话需要重写equals and hashcode0
List<String> newList = list.stream().distinct().collect(Collectors.toList());
2022-06-30更新
List根据某属性删除对象
jdk 1.8 的集合类 removeIf() 方法用于删除所有满足特定条件的数组元素。语法; arraylist.removeIf(Predicate<E> filter)
List<User> newList = userList.stream().collect(Collectors.collectingAndThen(
Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getCode))), ArrayList::new));userList.removeIf(user -> user.age > 50);List获取某属性重复的对象
根据名字分组统计, 获取到名字重复数大于1的名字列表(groupingBy的值不能为空)
List<String> userNameList = userList.stream().filter(f -> StringUtils.isNotBlank(f.getName()))
.collect(Collectors.groupingBy(User::getName, Collectors.counting())).entrySet().stream()
.filter(e -> e.getValue() > 1).map(Map.Entry::getKey)
.collect(Collectors.toList());过滤一下
List<User> list = userList.stream().filter(f -> userNameList.contains(f.getName())).collect(Collectors.toList());
List根据某属性去重
List<User> newList = userList.stream().collect(Collectors.collectingAndThen( Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getCode))), ArrayList::new));
2022-12-13补充
list根据某属性分组
Map<String, List<Student>> map = students.stream().collect(Collectors.groupingBy(Student::getName));
更多java常用知识点整理：java常用知识点整理_瑶山的博客-CSDN博客_java知识点整理
2023-2补充
List分割数据, 例每次请求500条数据
import com.google.common.collect.Lists;
// 代码模拟
List<List<String>> partition = Lists.partition(idList, 500);
for (List<String> list : partition) {
query.setUserIds(list);
response = queryList(query);
}2023-4补充
List转map重复key报错java.lang.IllegalStateException: Duplicate key 0
Map<String, Long> totalBindMap = list.stream()
.collect(Collectors.toMap(StatisticsDO::getCode, StatisticsDO::getMoney, (entity1, entity2) -> entity2));(entity1, entity2) -> entity2中，如果entity1与entity2的key值相同，选择entity2作为那个key所对应的value值。这里的箭头函数，当出现了重复key的数据时，会回调这个方法，可以在这个方法里处理重复Key数据问题
list求交集
List<String> list1 = new ArrayList<>();
list1.add("03");
list1.add("02");
list1.add("01");
List<String> list2 = new ArrayList<>();
list2.add("02");
list2.add("03");
// list1 只保留在 lists2 中的元素
list1.retainAll(list2);
System.out.println(list1);
->> ["03, 02]
// 并集
listA.removeAll(listB);
listA.addAll(listB);本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
