java list 去重 相同的相加_Java 8 Stream相关集合转换

一、Stream list To Map

listToMap

public class listToMap {

public static void main(String[] args) {

List keyList = new ArrayList();

keyList.add(1);

keyList.add(2);

keyList.add(3);

List valueList = new ArrayList();

valueList.add("one");

valueList.add("two");

valueList.add("three");

Map reMap = (Map) keyList.stream().collect(Collectors.toMap(key -> key, index -> valueList.get(keyList.indexOf(index))));

System.out.println(reMap);

}

}

for循环转换：

listToMap

二、Stream list to Map，key重复

Duplicate key one

三、Stream list to Map，key重复，value三种处理

解决一：用新值覆盖旧值

新value覆盖旧value

解决二：重复时将之前的value 和现在的value拼接或相加起来

value拼接或相加起来

解决三：将重复key的数据变成一个集合

将重复key的数据变成一个集合

四、map排序、list去重、统计重复元素个数，获取map的key集合和value集合

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.function.Function;

import java.util.stream.Collectors;

public class stream {

public static void main(String[] args) {

//定义一个size为100的集合，包含A-Z

List list = new LinkedList<>();

for (int i = 0; i < 100; i++) {

list.add(String.valueOf((char) ('A' + Math.random() * ('Z' - 'A' + 1))));

}

System.out.println(list);

//统计集合重复元素出现次数，并且去重返回HashMap

Map map = list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

System.out.println(map);

//由于HashMap无序，所以再排序放入LinkedHashMap里(key升序)

Map sortMap = new LinkedHashMap<>();

map.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEachOrdered(e -> sortMap.put(e.getKey(), e.getValue()));

System.out.println(sortMap);

//获取排序后map的key集合

List keys = new LinkedList<>();

sortMap.entrySet().stream().forEachOrdered(e -> keys.add(e.getKey()));

System.out.println(keys);

//获取排序后map的value集合

List values = new LinkedList<>();

sortMap.entrySet().stream().forEachOrdered(e -> values.add(e.getValue()));

System.out.println(values);

}

}

五、Streams中filter()的用法

在 Java 8 以前，过滤一个 List如下：

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Collectors;

public class streamFilter {

public static void main(String[] args) {

List lines = Arrays.asList("one", "two", "three");

List result = getFilterOutput(lines, "three");

for (String temp : result) {

System.out.println(temp);

}

}

private static List getFilterOutput(List lines, String filter) {

List result = new ArrayList<>();

for (String line : lines) {

if (!filter.equals(line)) {

result.add(line);

}

}

return result;

}

}

Java8使用collect()将一个List转化为steam(流)，然后使用stream.filter()来过滤它：

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Collectors;

public class streamFilter {

public static void main(String[] args) {

List lines = Arrays.asList("one", "two", "three");

List res = lines.stream() //转化为一个流

.filter(a -> !"three".equals(a)) //排除 'three'

.collect(Collectors.toList()); //把输出流收集回List中

res.forEach(System.out::println);

}

}

六、Streams中filter()、findAny()和orElse()的用法

@Data

@NoArgsConstructor

@AllArgsConstructor

public class User {

private String name;

private int age;

}

在Java 8以前，通过name获取一个Person通常像这样：

public static void main(String[] args) {

List userList = Arrays.asList(

new User("Tom", 30),

new User("Jerry", 20),

new User("Rose", 40)

);

User res = getUserByName(userList, "Tom");

System.out.println(res);

}

private static User getUserByName(List userList, String name) {

User res = null;

for (User temp : userList) {

if (name.equals(temp.getName())) {

res = temp;

}

}

return res;

}

输出结果：User{name='Tom', age=40}

Java 8使用stream.filter()来过滤List，使用.findAny().orElse(null)来返回指定的对象：

public static void main(String[] args) {

List userList = Arrays.asList(

new User("Tom", 30),

new User("Jerry", 20),

new User("Rose", 40)

);

User res = userList.stream() // 转化为流

.filter(x -> "Tom".equals(x.getName())) // 只过滤出"Tom"

.findAny() // 如果找到了就返回

.orElse(null); // 如果找不到就返回null

System.out.println(res);

}

再看下面这段代码：

public static void main(String[] args) {

List userList = Arrays.asList(

new User("Tom", 30),

new User("Jerry", 20),

new User("Rose", 40)

);

User res = userList.stream()

.filter((p) -> "Tom".equals(p.getName()) && 30 == p.getAge())

.findAny()

.orElse(null);

System.out.println("res：" + res);

//或者这样写

User ult = userList.stream()

.filter(p -> "Tom".equals(p.getName()) && 30 == p.getAge()).findAny()

.orElse(null);

System.out.println("ult：" + ult);

}

Streams中filter()和map()的用法：

public static void main(String[] args) {

List userList = Arrays.asList(

new User("Tom", 30),

new User("Jerry", 20),

new User("Rose", 40)

);

String name = userList.stream()

.filter(x -> "Rose".equals(x.getName()))

.map(User::getName) //把流转化为String，这里其实就是

//把一个新的事物转为另外一种事物了。类型得到了转换

.findAny()

.orElse("");

System.out.println("name : " + name);

List collect = userList.stream()

.map(User::getName)

.collect(Collectors.toList());

collect.forEach(System.out::println);

}

map()解释：如果有一个函数可以将一种类型的值转换成另外一种类型，map操作就可以使用该函数，将一个流中的值转换成一个新的流。 map是Stream上最常用的操作之一。