Java对List的操作

 List<Person>转成map，并自定义key

假设有一List中有如下数据

Person{id='100', name='张三0100'}
Person{id='101', name='张三1100'}
Person{id='102', name='张三2100'}
Person{id='103', name='张三3100'}
Person{id='104', name='张三4100'}
Person{id='105', name='张三5100'}
Person{id='106', name='张三6100'}
Person{id='107', name='张三7100'}
Person{id='108', name='张三8100'}
Person{id='109', name='张三9100'}

1. foreach 依旧简单而直观

    Map<String , Person> map = new HashMap<>();
           people.forEach(item->{
               String key=item.getId()+"-"+item.getName();
               map.put(key,item);
           });

2. Stream

    Map<String, Person> stresmMap = people.stream()
                   .collect(Collectors.toMap(
                           item -> item.getId() + "-" + item.getName(),
                           item -> item
                   ));

打印结果如下： 

   stresmMap.forEach((k, person) ->{
            System.out.print(k + " : ");
            System.out.println(person);
        });
-------------------------------------------------
106-张三6100 : Person{id='106', name='张三6100'}
107-张三7100 : Person{id='107', name='张三7100'}
105-张三5100 : Person{id='105', name='张三5100'}
103-张三3100 : Person{id='103', name='张三3100'}
102-张三2100 : Person{id='102', name='张三2100'}
101-张三1100 : Person{id='101', name='张三1100'}
100-张三0100 : Person{id='100', name='张三0100'}
108-张三8100 : Person{id='108', name='张三8100'}
104-张三4100 : Person{id='104', name='张三4100'}
109-张三9100 : Person{id='109', name='张三9100'}

数据筛选

假设有如下数据，从List<Persion> 中，快速取出每个对象的name，组成一个新的list

let PersonList = [
  {id:1,name:"张三"},
  {id:2,name:"李思思"},
  {id:3,name:"网无无"}
]

 首先你会想到什么？是`foreach`吗 ？

let nameList= []
Person.forEach(item=>{
  nameList.push(item.name)
})

console.log(nameList);
-----------------------------------------
[Running] node "e:\我的文件\testCode\test-java-vue\JavaScript\basic.js"
[ '张三', '李思思', '网无无' ]

有没有更简单的方法呢？

let nameList = PersonList.map(item => item.name);
console.log(nameList);
--------------------------------------------
[Running] node "e:\我的文件\testCode\test-java-vue\JavaScript\basic.js"
[ '张三', '李思思', '网无无' ]

数据筛选Stream（）初使用

public List<SeriousManage> filterByExamDate(List<SeriousManage> seriousManageList, int examDateDelta) {
    LocalDate today = LocalDate.now();
    
    return seriousManageList.stream()
        .filter(seriousManage -> {
            LocalDate examDate = seriousManage.getExamDate().toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
            long daysBetween = ChronoUnit.DAYS.between(today, examDate);
            return daysBetween % examDateDelta == 0;
        })
        .collect(Collectors.toList());
}

tips：ChronoUnit.DAYS.between(today, examDate) 是用于计算两个日期之间相差的天数的方法。在这里，today 是表示今天日期的 LocalDate 对象，而 examDate 是表示某条数据的考试日期的 LocalDate 对象。 

在 Java 中，Stream 的 filter 操作用于从一个 Stream 中筛选出满足指定条件的元素，然后返回一个新的 Stream。在处理 List 的时候，您可以使用 stream() 方法将 List 转换为一个 Stream，然后使用 filter 方法对其中的元素进行筛选。

以下是如何在 Java 中使用 Stream 的 filter 操作来处理 List 的简单示例：

List<Person> filteredPeople = people.stream()
    .filter(person -> person.getAge() >= 25)
    .collect(Collectors.toList());

在这个示例中，.filter(person -> person.getAge() >= 25) 部分就是使用 filter 操作来筛选满足条件的 Person 对象。最终，通过 .collect(Collectors.toList()) 将筛选后的结果收集回一个新的 List。

将两个List合并为一个

1. addAll 方法

List<T> list1 = new ArrayList<>();
List<T> list2 = new ArrayList<>();

// 合并两个列表
list1.addAll(list2);

上述代码会将 list2 中的所有元素添加到 list1 中，从而实现两个列表的合并。

2. Stream 的 concat 操作

如果您更喜欢使用 Stream API，可以使用 Stream.concat 操作来合并两个流：

List<T> mergedList = Stream.concat(list1.stream(), list2.stream())
                           .collect(Collectors.toList());

效率比较 

让我们来比较一下使用 addAll 方法和使用 Stream 的 concat 操作的效率。

1. addAll 方法：addAll 方法是一个原地操作，它会修改一个列表，并将另一个列表的元素添加到该列表中。这种方法可以很快地将一个列表的元素添加到另一个列表，因为它只涉及一个列表的操作。

   long startTime = System.nanoTime();
   
   list1.addAll(list2);
   
   long endTime = System.nanoTime();
   long duration = endTime - startTime;
   
   System.out.println("addAll time: " + duration + " nanoseconds");
   

2. Stream 的 concat 操作：
   Stream 的 concat 操作会返回一个新的流，其中包含两个原始流的元素。这涉及创建一个新的流对象以容纳所有元素，并遍历两个原始流的元素来填充新的流。

   long startTime = System.nanoTime();
   
   List<T> mergedList = Stream.concat(list1.stream(), list2.stream())
                              .collect(Collectors.toList());
   
   long endTime = System.nanoTime();
   long duration = endTime - startTime;
   
   System.out.println("Stream.concat time: " + duration + " nanoseconds");
   

   在合并大型列表时，addAll 方法通常会更快，因为它直接修改一个列表而无需创建新的流对象。

返回一个空列表

在有些必要的时候，我们需要返回一个空列表，可以怎么做呢？

List<String> emptyList = new ArrayList<>();
        // 现在 emptyList 是一个空列表

  List<String> emptyList = Collections.emptyList();
        // 现在 emptyList 是一个空列表
 
  List<String> emptyList = Arrays.asList();
        // 现在 emptyList 是一个空列表

  return Collections.emptyList();

List转String，元素中间用，分割

将一个 List<String> 转换为一个逗号分隔的字符串可以使用 String.join() 方法。这个方法可以将列表中的元素连接起来，使用指定的分隔符。

import java.util.ArrayList;
import java.util.List;

public class ListToStringExample {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        stringList.add("apple");
        stringList.add("banana");
        stringList.add("orange");

        String result = String.join(",", stringList);
        System.out.println(result);
    }
}

打印--------------------------------
apple,banana,orange

 如果我们面对的不是String，而是`Long` 亦或其他类型的对象，又该当如何？

当然是先把它变成String了

List<Long> childTenantIds = this.tenantApi.getALLTenantIdsForChild(tenantId).getData();
String childTenantIdsString = String.join(",", childTenantIds.stream().map(String::valueOf).collect(Collectors.toList()));

以上只是我个人日常使用到的一些方法，欢迎各位道友补充。