Java List集合去重、过滤、分组、获取数据、求最值、合并、排序、跳数据和遍历
前言
请各大网友尊重本人原创知识分享，谨记本人博客：南国以南i、
准备工作：现有一个User类、Student 类和Ticket类，加入相关依赖
@Data
public class User {
/**
* id
*/
private Integer id;
/**
* 姓名
*/
private String name;
/**
* 工号
*/
private String jobNumber;
/**
* 年龄
*/
private Integer age;
/**
* true:男 false：女
*/
private Boolean gender;
/**
* 身高
*/
private Double height;
/**
* 出生日期
*/
private LocalDate birthday;
/**
* 成员数量
*/
private BigDecimal familyMemberQuantity;
public User(String name, String jobNumber, Integer age, Boolean gender, Double height, LocalDate birthday){
this.name = name;
this.jobNumber = jobNumber;
this.gender = gender;
this.age = age;
this.height = height;
this.birthday = birthday;
}
public User(String name,Integer age,BigDecimal familyMemberQuantity){
this.name = name;
this.age = age;
this.familyMemberQuantity = familyMemberQuantity;
}
/**
* 输出打印信息
* @param list
*/
public static void printUsers(List<User> list){
System.out.println("[姓名]\t\t[工号]\t\t[性别]\t\t[年龄]\t\t[身高]\t\t[生日]");
System.out.println("-----------------------------------------------------------------------");
list.forEach(u-> System.out.println(printValue(u)));
System.out.println(" ");
}
/***
* 输出list结果集
* @param user
* @return
*/
public static String printValue(User user){
String str=String.format("%s\t\t\t%s\t\t%s\t\t%s\t\t\t%s\t\t%s",
user.name,user.jobNumber,user.gender.toString(),user.age.toString(),
user.height.toString(),user.birthday.toString());
return str;
}
}
@Data
public class Ticket {
private String groupId;
private String mallid;
private String ticketId;
private String ticketName;
private String batchId;
private String convertible;
private String gradeLimit;
private String batchAvailableNum;
private String saleNum;
private String exIntegral;
private String exMoney;
private String isSoldOut;
private String isSpike;
private Date exEndTime;
private Date createDate;
/**
* 输出打印信息
* @param list
*/
public static void printTickets(List<Ticket> list){
System.out.println("[电子券名称]\t\t[isSoldOut]\t\t[convertible]\t\t[isSpike]\t\t[saleNum]\t\t[exIntegral]\t\t[exMoney]\t\t[exEndTime]\t\t[createDate]");
System.out.println("-----------------------------------------------------------------------");
list.forEach(u-> System.out.println(printValue(u)));
System.out.println(" ");
}
/***
* 输出list结果集
* @param ticket
* @return
*/
public static String printValue(Ticket ticket){
String str=String.format("%s\t\t\t\t%s\t\t\t\t%s\t\t\t\t\t%s\t\t\t\t%s\t\t\t%s\t\t\t%s\t\t\t%s\t\t\t%s",
ticket.ticketName,ticket.isSoldOut,ticket.convertible.toString(),ticket.isSpike.toString(),ticket.saleNum.toString(),
ticket.exIntegral.toString(),ticket.exMoney.toString(),ticket.exEndTime.toString(),ticket.createDate.toString());
return str;
}
}
@Data
public class Student {
private String id;
private int nums;
private int sums;
}
<!--Json工具类-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.68</version>
</dependency>
1. List集合去重：使用distinct()函数
使用stream().map()提取List对象的某一列值及去重
public class ListDistinct {
public static void main(String[] args) {
//构建测试数据
List<User> list = new ArrayList<User>();
list.add(new User("张三","000001",26,true,1.76, LocalDate.of(1996,1,18)));
list.add(new User("小莉","000002",21,false,1.61, LocalDate.of(2001,1,18)));
list.add(new User("李四","000003",22,true,1.83, LocalDate.of(2000,1,18)));
list.add(new User("程曦","000004",20,false,1.64, LocalDate.of(2002,1,18)));
list.add(new User("喜喜","000005",20,false,1.67, LocalDate.of(2002,1,18)));
//输出list列表
User.printUsers(list);
//1.提取某一列
List<String> nameList = list.stream().map(User::getName).collect(Collectors.toList());
System.out.println(JSON.toJSONString(nameList));
System.out.println("#############################################################");
//2.从列表中提取age并去重
List<Integer> ageList = list.stream().map(User::getAge).distinct().collect(Collectors.toList());
System.out.println(JSON.toJSONString(ageList));
System.out.println();
}
}
2.List集合过滤：使用filter方法可以过滤某些条件
public class ListFilter {
public static void main(String[] args) {
//构建测试数据
List<User> list = new ArrayList<>();
list.add(new User("张三","000001",26,true,1.76, LocalDate.of(1996,1,18)));
list.add(new User("小莉","000002",21,false,1.61, LocalDate.of(2001,1,18)));
list.add(new User("李四","000003",22,true,1.83, LocalDate.of(2000,1,18)));
list.add(new User("程曦","000004",20,false,1.64, LocalDate.of(2002,1,18)));
list.add(new User("喜喜","000005",20,false,1.67, LocalDate.of(2002,1,18)));
//输出list列表
User.printUsers(list);
//示例3：使用filter()过滤list
//查找身高在1.8米及以上的男生
List<User> teacherList = list.stream().filter(user -> user.getGender()
&& user.getHeight() >= 1.8).collect(Collectors.toList());
//输出查找结果
User.printUsers(teacherList);
//查找年龄在20以上的女生
List<User> tList = list.stream().filter(user -> !user.getGender()
&& user.getAge() >= 20).collect(Collectors.toList());
//输出查找结果
User.printUsers(tList);
}
}
3.List集合获取第一条数据
使用 findAny() 和 findFirst() 获取第一条数据
public class ListFindAnyFindFirst {
public static void main(String[] args) {
//构建测试数据
List<User> list = new ArrayList<User>();
list.add(new User("张丹",11,new BigDecimal(11)));
list.add(new User("刘大",13,new BigDecimal(13)));
list.add(new User("飒飒",16,new BigDecimal(16)));
list.add(new User("斯蒂芬",11,new BigDecimal(11)));
//1. findAny():将返回集合中符合条件的任意一个元素。
//findAny()Java Stream的方法为该流的某些元素返回一个Optional，如果该流为空，则返回一个空的Optional。在这里，Optional是一个容器对象，可以包含也可以不包含非null值
Optional<User> userOptional = list.stream().findAny();
System.out.println(userOptional.get());
//1. findFirst():获取第一条数据
//如果一个集合数据是有序的，而且你要查找符合条件的第一条数据。这时用findFirst是比较合适的
Optional<User> userOptional1 = list.stream().findFirst();
System.out.println(userOptional1.get());
/***
* 问题解答：findFirst和findAny如何选择？
* （1）如果你不关心返回的是哪一个数据，只要符合条件的就行，那就用findAny。
* 而且在并行流上，findAny限制更少。
* （2）如果你关心集合的顺序，要返回符合条件的第一个元素，那就用findFirst。
*/
}
}
4.List集合分组:通过Collectors.groupingBy可以分组指定字段
public class ListGrouping {
public static void main(String[] args) {
//构建测试数据
List<User> list = new ArrayList<>();
list.add(new User("张三","000001",26,true,1.76, LocalDate.of(1996,1,18)));
list.add(new User("小莉","000002",21,false,1.61, LocalDate.of(2001,1,18)));
list.add(new User("李四","000003",22,true,1.83, LocalDate.of(2000,1,18)));
list.add(new User("程曦","000004",20,false,1.64, LocalDate.of(2002,1,18)));
list.add(new User("喜喜","000005",20,false,1.67, LocalDate.of(2002,1,18)));
//输出list列表
User.printUsers(list);
//示例2：list分组（通过groupingBy可以分组指定字段）
System.out.println("###############################单字段分组##############################");
//2.1单字段分组：按照gender分组
Map<Boolean,List<User>> groupList = list.stream().collect(Collectors.groupingBy(User::getGender));
//遍历结果集
for(Map.Entry<Boolean,List<User>> entryUser :groupList.entrySet()){
Boolean key = entryUser.getKey();
List<User> entryUserList = entryUser.getValue();
System.out.println("key："+key +",value:"+entryUserList.toString());
}
System.out.println("#############################################################");
//知道key值，可如下输出分组的结果
groupList.get(true).forEach(e->{
System.out.println("男："+e.toString());
});
System.out.println("#############################################################");
groupList.get(false).forEach(e->{
System.out.println("女："+e.toString());
});
System.out.println("#############################################################");
//2.2多字段分组(多个字段，用下划线拼接)：按照年龄、gender分组
Map<Object,List<User>> groupList2 = list.stream().collect(Collectors.groupingBy(o ->{
StringBuffer bf = new StringBuffer();
bf.append(o.getAge()).append("_");
bf.append(o.getGender());
return bf.toString();
}));
System.out.println(JSON.toJSONString(groupList2, SerializerFeature.PrettyFormat));
}
}
5.List集合最值：使用jdk8的Stream来获取list集合的最小值、最大值、总和、平均数
public class ListMaxMin {
public static void main(String[] args) {
//构建测试数据
List<User> list = new ArrayList<User>();
list.add(new User("张丹",11,new BigDecimal(11)));
list.add(new User("刘大",13,new BigDecimal(13)));
list.add(new User("飒飒",16,new BigDecimal(16)));
list.add(new User("斯蒂芬",11,new BigDecimal(11)));
//获取用户年龄的最大、最小、总和、平均值
int max = list.stream().mapToInt(u->u.getAge()).max().getAsInt();
int min = list.stream().mapToInt(u->u.getAge()).min().getAsInt();
//求和
//求和：分基本类型和大数据类型，基本类型先mapToInt方法,然后调用sun方法；大数类型使用reduce调用BigDecimal::add方法
//基本类型求和
int sum = list.stream().mapToInt(u->u.getAge()).sum();
//BigDecimal求和
BigDecimal totalQuantity = list.stream().map(u->u.getFamilyMemberQuantity()).reduce(BigDecimal.ZERO,BigDecimal::add);
double avg = list.stream().mapToInt(u->u.getAge()).average().getAsDouble();
System.out.println("年龄最大值："+max+"\n年龄最小值："+min);
System.out.println("年龄总和："+sum+"\n年龄平均值："+avg);
System.out.println("成员数量总和："+totalQuantity);
}
}
6.List集合合并：合并两个list,并将userId相同的其它属性合并
public class ListMerge {
public static void main(String[] args) {
mergeList();
}
/**
* @Description: 合并两个list<map>,并将userId相同的其它属性合并
* @Title: mergeList
* @param: @return
* @return: List<Map<String,Object>>
* @throws
*/
public static List<Map<String,Object>> mergeList(){
//构建list1集合数据
List<Map<String,Object>> list1 = new ArrayList<>();
Map<String,Object> data=new HashMap<>();
data.put("userId","100001");
data.put("userName","唐僧");
list1.add(data);
data=new HashMap<>();
data.put("userId","100002");
data.put("userName","八戒");
list1.add(data);
data=new HashMap<>();
data.put("userId","100003");
data.put("userName","悟空");
list1.add(data);
data=new HashMap<>();
data.put("userId","100004");
data.put("userName","沙僧");
list1.add(data);
//构建list2集合数据
List<Map<String,Object>> list2 = new ArrayList<>();
data=new HashMap<>();
data.put("userId","100001");
data.put("gender","男");
data.put("age",20);
list2.add(data);
data=new HashMap<>();
data.put("userId","100002");
data.put("gender","雄");
data.put("age",1000);
list2.add(data);
data=new HashMap<>();
data.put("userId","100003");
data.put("gender","雄");
data.put("age",600);
list2.add(data);
data=new HashMap<>();
data.put("userId","100004");
data.put("gender","男");
data.put("age",800);
list2.add(data);
//steam():把一个源数据，可以是集合，数组，I/O channel， 产生器generator 等，转化成流。
//forEach():迭代流中的每个数据
//map():用于映射每个元素到对应的结果
//filter():用于通过设置的条件过滤出元素
//Collectors(): 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
//属性合并：根据userId把list2合并到list1的结果集中
List<Map<String, Object>> list = list1.stream().map(m -> {
list2.stream().filter(m2-> Objects.equals(m.get("userId"),m2.get("userId"))).forEach(m2-> {
m.put("gender",m2.get("gender"));
m.put("age",m2.get("age"));
});
return m;
}).collect(Collectors.toList());
//遍历输出合并后的结果集
for(Map<String, Object> map:list){
System.out.println(map.toString());
}
return list;
}
}
7.List集合合并：合并两个list,并将ticketId相同的其它属性合并
public class ListMerge1 {
public static void main(String[] args) {
mergeList();
}
/**
* @Description: 合并两个list<Ticket>,并将ticketId相同的其它属性合并
* @Title: mergeList
* @param: @return
* @return: List<Ticket>
* @throws
*/
public static List<Ticket> mergeList(){
List<Ticket> list1 = new ArrayList<>();
Ticket data=new Ticket();
data.setTicketId("100001");
data.setTicketName("唐僧");
list1.add(data);
data=new Ticket();
data.setTicketId("100002");
data.setTicketName("八戒");
list1.add(data);
data=new Ticket();
data.setTicketId("100003");
data.setTicketName("悟空");
list1.add(data);
data=new Ticket();
data.setTicketId("100004");
data.setTicketName("沙僧");
list1.add(data);
List<Ticket> list2 = new ArrayList<>();
data=new Ticket();
data.setTicketId("100001");
data.setSaleNum("20");
data.setBatchAvailableNum("10");
list2.add(data);
data=new Ticket();
data.setTicketId("100001");
data.setSaleNum("20");
data.setBatchAvailableNum("10");
list2.add(data);
data=new Ticket();
data.setTicketId("100002");
data.setSaleNum("1000");
data.setBatchAvailableNum("600");
list2.add(data);
data=new Ticket();
data.setTicketId("100003");
data.setSaleNum("600");
data.setBatchAvailableNum("100");
list2.add(data);
data=new Ticket();
data.setTicketId("100004");
data.setSaleNum("800");
data.setBatchAvailableNum("300");
list2.add(data);
//使用stream流把list1和list2根据属性ticketId合并一个list集合
List<Ticket> list = list1.stream().map(m -> {
list2.stream().filter(m2-> Objects.equals(m.getTicketId(),m2.getTicketId())).forEach(m2-> {
m.setSaleNum(m2.getSaleNum());
m.setBatchAvailableNum(m2.getBatchAvailableNum());
});
return m;
}).collect(Collectors.toList());
for(Ticket ticket:list){
System.out.println(ticket.getTicketId()+","+ticket.getTicketName()+","+ticket.getSaleNum()+","+ticket.getBatchAvailableNum());
}
return list;
}
}
8.List集合合并：合并两个list.list1合并到list2(list1的个数 < list2的个数)
public class ListMerge2 {
public static void main(String[] args) {
mergeList();
}
/**
* @Description: 合并两个list<map>,并将userId相同的其它属性合并
* @Title: mergeList
* @param: @return
* @return: List<Map<String,Object>>
* @throws
*/
public static List<Ticket> mergeList(){
List<Ticket> list1 = new ArrayList<>();
Ticket data=new Ticket();
data.setTicketId("100001");
data.setTicketName("唐僧");
list1.add(data);
data=new Ticket();
data.setTicketId("100002");
data.setTicketName("八戒");
list1.add(data);
List<Ticket> list2 = new ArrayList<>();
data=new Ticket();
data.setTicketId("100001");
data.setBatchId("1");
list2.add(data);
data=new Ticket();
data.setTicketId("100001");
data.setBatchId("2");
list2.add(data);
data=new Ticket();
data.setTicketId("100002");
data.setBatchId("1");
list2.add(data);
data=new Ticket();
data.setTicketId("100002");
data.setBatchId("2");
list2.add(data);
data=new Ticket();
data.setTicketId("100002");
data.setBatchId("3");
list2.add(data);
//使用stream流把list1合并到list2集合中，根据ticketId属性
List<Ticket> list = list2.stream().map(m -> {
list1.stream().filter(m2-> Objects.equals(m.getTicketId(),m2.getTicketId())).forEach(m2-> {
m.setTicketId(m2.getTicketId());
m.setTicketName(m2.getTicketName());
});
return m;
}).collect(Collectors.toList());
for(Ticket ticket:list){
System.out.println(ticket.getTicketId()+","+ticket.getTicketName()+","+ticket.getBatchId());
}
return list;
}
}
9.List集合合并：合并两个list.list1合并到list2(list1的个数 > list2的个数)
public class ListMerge3 {
public static void main(String[] args) {
mergeList();
}
/**
* @Description: 合并两个list<map>,并将userId相同的其它属性合并
* @Title: mergeList
* @param: @return
* @return: List<Map<String,Object>>
* @throws
*/
public static List<Ticket> mergeList(){
List<Ticket> list1 = new ArrayList<>();
Ticket data=new Ticket();
data.setTicketId("100001");
data.setTicketName("唐僧");
list1.add(data);
data=new Ticket();
data.setTicketId("100002");
data.setTicketName("八戒");
list1.add(data);
List<Ticket> list2 = new ArrayList<>();
data=new Ticket();
data.setTicketId("100001");
data.setBatchId("1");
list2.add(data);
data=new Ticket();
data.setTicketId("100001");
data.setBatchId("2");
list2.add(data);
// data=new Ticket();
// data.setTicketId("100002");
// data.setBatchId("1");
// list2.add(data);
//
// data=new Ticket();
// data.setTicketId("100002");
// data.setBatchId("2");
// list2.add(data);
//
// data=new Ticket();
// data.setTicketId("100002");
// data.setBatchId("3");
// list2.add(data);
//使用stream流把list1合并到list2集合中，根据ticketId属性
List<Ticket> list = list2.stream().map(m -> {
list1.stream().filter(m2-> Objects.equals(m.getTicketId(),m2.getTicketId())).forEach(m2-> {
m.setTicketId(m2.getTicketId());
m.setTicketName(m2.getTicketName());
});
return m;
}).collect(Collectors.toList());
for(Ticket ticket:list){
System.out.println(ticket.getTicketId()+","+ticket.getTicketName()+","+ticket.getBatchId());
}
return list;
}
}
10.一个list 集合合并去重求和
public class ListMerge4 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
Student s1 = new Student();
s1.setId("s1");
s1.setNums(1);
s1.setSums(1);
list.add(s1);
s1 = new Student();
s1.setId("s1");
s1.setNums(2);
s1.setSums(3);
list.add(s1);
s1 = new Student();
s1.setId("s2");
s1.setNums(3);
s1.setSums(5);
list.add(s1);
//合并去重求和
List<Student> result = merge(list);
result.stream().forEach(e->{
System.out.println("id:"+e.getId()+",nums:"+e.getNums()+",sums:"+e.getSums());
});
}
/**
* 将id进行合并nums, sums 相加道回合并后的集合使用Java8的流进行处理
* @return
*/
public static List<Student> merge(List<Student> list){
List<Student> result = list.stream()
.collect(Collectors.toMap(Student::getId, a->a,(o1,o2)->{
o1.setNums(o1.getNums()+o2.getNums());
o1.setSums(o1.getSums()+o2.getSums());
return o1;
})).values().stream().collect(Collectors.toList());
return result;
}
}
11.List集合排序：单字段排序1
public class ListSort {
public static void main(String[] args) {
List<Ticket> list = new ArrayList<Ticket>();
Ticket data = new Ticket();
data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
data.setMallid("8a8481f57cca9442017ce026ddd40049");
data.setTicketId("1b82899c065d4474b85cfb809a99396a");
data.setTicketName("金卡");
data.setBatchId("7ed298bd08104cfe9ece16621c5e51ce");
data.setConvertible("0");
data.setGradeLimit("金卡");
data.setBatchAvailableNum("100");
data.setSaleNum("10");
list.add(data);
data = new Ticket();
data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
data.setMallid("8a8481f57cca9442017ce026ddd40049");
data.setTicketId("5ecd6634026c45edaca8b4ebfdf3964c");
data.setTicketName("电子券001");
data.setBatchId("2d29984f938b446b9174a24233b64b39");
data.setConvertible("1");
data.setGradeLimit("都可");
data.setBatchAvailableNum("100");
data.setSaleNum("30");
list.add(data);
data = new Ticket();
data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
data.setMallid("8a8481f57cca9442017ce026ddd40049");
data.setTicketId("5ecd6634026c45edaca8b4ebfdf3964c");
data.setTicketName("电子券001");
data.setBatchId("2d29984f938b446b9174a24233b64b39");
data.setConvertible("0");
data.setGradeLimit("都可");
data.setBatchAvailableNum("100");
data.setSaleNum("3");
list.add(data);
data = new Ticket();
data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
data.setMallid("8a8481f57cca9442017ce026ddd40049");
data.setTicketId("5ecd6634026c45edaca8b4ebfdf3964c");
data.setTicketName("电子券001");
data.setBatchId("2d29984f938b446b9174a24233b64b39");
data.setConvertible("0");
data.setGradeLimit("都可");
data.setBatchAvailableNum("100");
data.setSaleNum("6");
list.add(data);
data = new Ticket();
data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
data.setMallid("8a8481f57cca9442017ce026ddd40049");
data.setTicketId("5ecd6634026c45edaca8b4ebfdf3964c");
data.setTicketName("电子券001");
data.setBatchId("2d29984f938b446b9174a24233b64b39");
data.setConvertible("0");
data.setGradeLimit("都可");
data.setBatchAvailableNum("100");
data.setSaleNum("11");
list.add(data);
data = new Ticket();
data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
data.setMallid("8a8481f57cca9442017ce026ddd40049");
data.setTicketId("96c166ce59894cf0a4f8fc14a5c94fb2");
data.setTicketName("普卡");
data.setBatchId("1c332332b0d64d729a3521ea253fe621");
data.setConvertible("1");
data.setGradeLimit("普卡");
data.setBatchAvailableNum("90");
data.setSaleNum("33");
list.add(data);
data = new Ticket();
data.setGroupId("8a8480487c96d58f017c9b7bab7d0020");
data.setMallid("8a8481f57cca9442017ce026ddd40049");
data.setTicketId("b3826676e6e14168b58a1342b049723c");
data.setTicketName("银卡");
data.setBatchId("6d32889f9ab7450fb48fedad5efcaf85");
data.setConvertible("0");
data.setGradeLimit("银卡");
data.setBatchAvailableNum("30");
data.setSaleNum("33");
list.add(data);
//根据ticketId字段进行分组
Map<String, List<Ticket>> map = list.stream().collect(Collectors.groupingBy(Ticket::getTicketId));
List<Ticket> newList = new ArrayList<Ticket>();
//取每组的第一条数据
map.forEach((s, tickets) -> {
newList.add(tickets.get(0));
});
for(Ticket ticket:newList){
System.out.println(ticket.getTicketName()+","+ticket.getConvertible()+","+ticket.getSaleNum()+","+ticket.getBatchAvailableNum());
}
System.out.println("--------------------------------------list------------------------------------");
// 根据SaleNum降序
newList.sort(Comparator.comparing(Ticket::getSaleNum).reversed());
//BatchAvailableNum降序
newList.sort(Comparator.comparing(Ticket::getBatchAvailableNum).reversed());
for(Ticket ticket:newList){
System.out.println("ticketName："+ticket.getTicketName()+",convertible："+ticket.getConvertible()+",saleNum："+ticket.getSaleNum()+",batchAvailableNum："+ticket.getBatchAvailableNum());
}
}
}
12.List集合排序：单字段排序2
public class ListSortMultiple {
public static void main(String[] args) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
List<Ticket> list = new ArrayList<Ticket>();
Ticket data = new Ticket();
data.setTicketName("测试券1");
data.setConvertible("0");
data.setCreateDate(sdf.parse("2022-01-05 22:56:03"));
data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
data.setExIntegral("1");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("11");
list.add(data);
data = new Ticket();
data.setTicketName("测试券2");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2022-01-05 22:54:11"));
data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
data.setExIntegral("1");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("31");
list.add(data);
data = new Ticket();
data.setTicketName("测试券3");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2022-01-05 22:52:06"));
data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
data.setExIntegral("1");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("41");
list.add(data);
data = new Ticket();
data.setTicketName("测试券4");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2022-01-07 17:03:42"));
data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
data.setExIntegral("10");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("12");
list.add(data);
data = new Ticket();
data.setTicketName("测试券5");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2022-01-05 14:10:09"));
data.setExEndTime(sdf.parse("2022-01-15 23:59:59"));
data.setExIntegral("0");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("11");
list.add(data);
data = new Ticket();
data.setTicketName("测试券6");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2022-01-05 09:48:43"));
data.setExEndTime(sdf.parse("2022-01-12 23:59:59"));
data.setExIntegral("0");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("8");
list.add(data);
data = new Ticket();
data.setTicketName("测试券7");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2022-01-05 22:58:27"));
data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
data.setExIntegral("1200");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("16");
list.add(data);
data = new Ticket();
data.setTicketName("测试券8");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2022-01-10 17:56:44"));
data.setExEndTime(sdf.parse("2022-01-31 23:59:59"));
data.setExIntegral("1000");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("21");
list.add(data);
data = new Ticket();
data.setTicketName("测试券9");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2022-01-05 21:54:37"));
data.setExEndTime(sdf.parse("2022-01-12 23:59:59"));
data.setExIntegral("9");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("2");
list.add(data);
data = new Ticket();
data.setTicketName("测试1券");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2022-01-11 11:27:11"));
data.setExEndTime(sdf.parse("2022-01-12 23:59:59"));
data.setExIntegral("1000");
data.setExMoney("0.01");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("1");
list.add(data);
data = new Ticket();
data.setTicketName("测试2券");
data.setConvertible("1");
data.setCreateDate(sdf.parse("2021-12-23 14:35:57"));
data.setExEndTime(sdf.parse("2022-01-13 23:59:59"));
data.setExIntegral("50");
data.setExMoney("0");
data.setIsSoldOut("1");
data.setIsSpike("0");
data.setSaleNum("2");
list.add(data);
for(Ticket ticket:list){
System.out.println(ticket.getTicketName()+","+ticket.getConvertible()+","+ticket.getSaleNum()+","+ticket.getBatchAvailableNum());
}
System.out.println("--------------------------------------list------------------------------------");
//jdk8 组合降序排序
//isSoldOut desc,convertible desc,isSpike desc,saleNum desc,exIntegral desc,exMoney desc,exEndTime asc,createDate desc
//Comparator.reverseOrder():降序 Comparator.naturalOrder()：升序
//方式一：多个字段排序（多余两个）
//先以属性SaleNum降序,再进行属性BatchAvailableNum升序 多个字段 后面追加即可
// List<Ticket> sortList = list.stream()
// .sorted(Comparator.comparing(Ticket::getSaleNum,Comparator.reverseOrder())
// .thenComparing(e->{
// return Integer.valueOf(e.getBatchAvailableNum());
// },Comparator.naturalOrder())
// .thenComparing(e->{
// return Integer.valueOf(e.getConvertible());
// },Comparator.reverseOrder())
// )
// .collect(Collectors.toList());
//方式二：多个字段排序（多余两个）
Collections.sort(list, Comparator.comparing(Ticket::getIsSoldOut,Comparator.reverseOrder())
.thenComparing(Ticket::getConvertible,Comparator.reverseOrder())
.thenComparing(Ticket::getIsSpike,Comparator.reverseOrder())
.thenComparing(t->Integer.parseInt(t.getSaleNum()),Comparator.reverseOrder())
.thenComparing(t->Double.valueOf(t.getExIntegral()),Comparator.reverseOrder())
.thenComparing(t->Double.valueOf(t.getExMoney()),Comparator.reverseOrder())
.thenComparing(Ticket::getExEndTime,Comparator.naturalOrder())
.thenComparing(Ticket::getCreateDate,Comparator.reverseOrder())
);
//输出
Ticket.printTickets(list);
}
}
13.List集合：skip(long n) 方法用于跳过前n条数据
public class ListSpike {
public static void main(String[] args) {
skip(7);
}
public static void skip(long n){
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.stream().skip(n).forEach(integer -> System.out.println("integer = " + integer));
}
}
14.List集合遍历
public class ListTraverse {
public static void main(String[] args) {
//构建测试数据
List<User> list = new ArrayList<>();
list.add(new User("张三","000001",26,true,1.76, LocalDate.of(1996,1,18)));
list.add(new User("小莉","000002",21,false,1.61, LocalDate.of(2001,1,18)));
list.add(new User("李四","000003",22,true,1.83, LocalDate.of(2000,1,18)));
list.add(new User("程曦","000004",20,false,1.64, LocalDate.of(2002,1,18)));
//输出list列表
User.printUsers(list);
//示例1：list遍历
System.out.println("###############################方式一##############################");
// 方式一：for循环遍历
for(int i=0;i<list.size();i++){
User user = list.get(i);
System.out.println("姓名："+list.get(i).getName());
}
System.out.println("###############################方式二##############################");
// 方式二：for
for(User user:list){
System.out.println("姓名："+user.getName());
}
System.out.println("###############################方式三#############################");
// 方式三：iterator
Iterator<User> it = list.iterator();
while(it.hasNext()){
System.out.println("姓名："+it.next().getName());
}
System.out.println("###############################方式四##############################");
// 方式四：foreach（jdk1.8之后）
list.forEach(u->{
System.out.println("姓名："+u.getName());
});
}
}
总结
我是南国以南i记录点滴每天成长一点点，学习是永无止境的！转载请附原文链接！！！
Java List集合去重、过滤、分组、获取数据、求最值、合并、排序、跳数据和遍历的更多相关文章
- JAVA读取XML文件并解析获取元素、属性值、子元素信息
JAVA读取XML文件并解析获取元素.属性值.子元素信息 关键字 XML读取 InputStream DocumentBuilderFactory Element Node 前言 最 ...
- Java 单个集合去重与两个集合去重
一.单个集合去重 描述: 去掉一个集合里重复的元素:将list集合转成hashSet集合,hashSet有自动去重的功能,再利用去重后的hashSet集合初始化一个新的list集合,此时这个list就 ...
- ListView在编辑状态下不能获取修改后的值，无法更新数据
ListView在编辑状态下不能获取修改后的值,获取到的总是以前的值解决方法:在page_load事件里写: if(!IsPostBack) { ListViewBind(); } 原因:这涉及到as ...
- java中集合去重2
1.对集合中的自动定义的对象去重: 自定义Person类,同时复写hashCode和equals方法 package collection; public class Person { private ...
- java中集合去重1
//TreeMap 处理 处理后 得到的值 按拼音排序 TreeMap map = new TreeMap(new MaterialComparator()); map.put("东莞&qu ...
- JAVA从URL参数链接中获取指定参数的值
import java.util.HashMap; import java.util.Map; /** * @author yvioo */ public class UrlUtils { /** * ...
- js获取url 中的值，并跳转相应页面
实现方法:一:获取URL带QUESTRING参数的JAVASCRIPT客户端解决方案,相当于asp的request.querystring,PHP的$_GET1.函数: <Script lang ...
- 【mybatis】mybatis 中select 查询 select * 查询出来的数据，字段值带不出来 数据不全
原来的代码如下: <select id="findByGoodsUid" resultType="com.pisen.cloud.luna.ms.goods.bas ...
- 十七、Java基础---------集合框架之Map
前两篇文章中介绍了Collection框架,今天来介绍一下Map集合,并用综合事例来演示. Map<K,V> Map<K,V>:Map存储的是键值对形式的元素,它的每一个元素, ...
- java容器---集合总结
思考为什么要引入容器这个概念? Java有多种方式保存对象(应该是对象的引用),例如使用数组时保存一组对象中的最有效的方式,如果你想保存一组基本类型的数据,也推荐使用这种方式,但大家知道数组是具有固定 ...
随机推荐
- 固态硬盘使用f2fs作为根分区安装linux
目录 前言 碰到的问题 对策 我的实际操作步骤 0.警告 1. 准备 2. 分区 3. 使用网络安装debian10 4. 备份根分区 5. 修改固态硬盘linux根分区为f2fs 6.恢复备份 7. ...
- Geospatial Data 在 Nebula Graph 中的实践
本文首发于 Nebula Graph Community 公众号 本文主要介绍了地理空间数据(Geospatial Data)以及它在 Nebula Graph 中的具体实践. Geospatial ...
- C++socket服务器与客户端简单通信流程
服务器和客户端简单通信的流程,做一个简单的复习: 1.服务器创建的流程 代码如下,各个重要函数已经写注释: #include <iostream> // 推荐加上宏定义 #define W ...
- Java中枚举配合switch语句用法-2022新项目
一.业务场景 项目开发中经常会遇到多条件判断的情况,如果判断条件少的话使用if/elseif/else还比较好处理,如果判断条件多的话,则在使用这种语句就不太合适. 如果是自定义的一些内容,比如不同的 ...
- IIS 修改配置 进行性能优化
1.修改线程池队列长度和启动模式 2.修改线程池最大工作进程数 --设置为0 目的是根据服务器核数 匹配最佳线程数 3.站点高级设置开启预加载
- Spring JDBCTemplate Query方法查询
queryspringtypessqldaoemail 近日系统有一个打印采购单的功能,发现连续打印多张后,主机宕机,看了下service和dao层的实现,很繁杂,估计原因主要出在组页面资料的时候,循 ...
- verilog勘误系列之-->算术运算符运算失败
描述 在verilog代码设计时使用算术运算符与乘法搭配使用出现计算错误 原因 由于数据位宽设置不当导致 错误案例 wire signed [13:0] w01; wire signed [23:0] ...
- CMakeLists.txt 编写要点 && 一个关于install（）的深坑
PS:要转载请注明出处,本人版权所有. PS: 这个只是基于<我自己>的理解, 如果和你的原则及想法相冲突,请谅解,勿喷. 前置说明 本文作为本人csdn blog的主站的备份.(Bl ...
- 【732. 我的日程安排表 III】差分数组
class MyCalendarThree { private TreeMap<Integer, Integer> cnt; public MyCalendarThree() { cnt ...
- 大年学习linux（第三节---用户管理）
三.用户管理 用户和用户组操作命令 ld Finger Pwck 检查/etc/passwd配置文件内的信息与实际主文件夹是否存在,还可比较/etc/passwd和/etc/shadow的信息是否一致 ...