java 8 获取list中重复数据

### 回答1：
可以使用Java 8的流(Stream)和Lambda表达式来获取List中的重复数据。下面是一些示例代码：

1. 找到所有重复的元素：

List<String> list = Arrays.asList("A", "B", "C", "A", "D", "B");
List<String> duplicates = list.stream()
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
    .entrySet().stream()
    .filter(e -> e.getValue() > 1)
    .map(Map.Entry::getKey)
    .collect(Collectors.toList());
System.out.println(duplicates); // 输出 [A, B]

这段代码首先使用`groupingBy`方法将元素分组，然后使用`filter`方法过滤出出现次数大于1的元素，并使用`map`方法将`Map.Entry`转换为其键值，最后将结果收集到一个List中。

2. 找到第一个重复的元素：

List<String> list = Arrays.asList("A", "B", "C", "A", "D", "B");
Optional<String> firstDuplicate = list.stream()
    .filter(new HashSet<>()::add, HashSet::new)
    .findFirst();
System.out.println(firstDuplicate.orElse(null)); // 输出 A

这段代码首先创建了一个空的HashSet，然后使用`filter`方法过滤出第一个无法添加到HashSet中的元素，即为第一个重复的元素。最后使用`findFirst`方法获取结果。注意，由于结果可能为null，因此使用`Optional`类包装结果。

希望这可以帮助到你！

### 回答2：
在Java 8中，我们可以使用 Stream API 来获取 List 中的重复数据。
首先，我们将 List 转换为 Stream 对象，然后使用 `Collectors.groupingBy` 方法对元素进行分组，相同的元素将会分到同一组中。
接着，我们使用 Stream 对分组结果进行过滤，筛选出有多个元素的组，即为重复的数据。
最后，我们将过滤出的组的键值提取出来，即为 List 中的重复数据。

下面是一个示例代码：

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 2, 4, 5, 4, 6);
        
        List<Integer> duplicates = list.stream()
                .collect(Collectors.groupingBy(e -> e, Collectors.counting()))
                .entrySet()
                .stream()
                .filter(entry -> entry.getValue() > 1)
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
        
        System.out.println("List 中的重复数据：" + duplicates);
    }
}

运行代码后输出结果为：List 中的重复数据：[2, 4] ，即 List 中重复的元素是 2 和 4。

### 回答3：
要获取一个Java 8中List中的重复数据，可以按照以下步骤进行操作：

1. 创建一个HashMap对象，该对象的键是List中的元素，值是元素出现的次数。
2. 使用Java 8的stream()方法将List转换为Stream。
3. 使用forEach()方法对Stream中的元素进行迭代。
4. 在迭代中，使用HashMap的merge()方法将元素作为键，并将其值初始化为1，如果已存在相同的键，则将其值加1。
5. 创建一个新的ArrayList对象，用于存储重复的元素。
6. 再次使用stream()方法将List转换为Stream。
7. 使用filter()方法对Stream中的元素进行过滤，根据HashMap中键对应的值是否大于1来判断是否为重复元素。
8. 使用collect()方法将Stream中的过滤出的元素收集到ArrayList中。
9. 最后，你可以打印或做其他操作，来验证获取的重复元素是否正确。

以下是一个示例代码：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(2);
        list.add(4);
        list.add(1);
        
        Map<Integer, Integer> countMap = new HashMap<>();
        
        list.stream().forEach(num -> countMap.merge(num, 1, Integer::sum));
        
        List<Integer> duplicates = list.stream()
                                      .filter(num -> countMap.get(num) > 1)
                                      .collect(Collectors.toList());
                                      
        System.out.println("重复的元素：" + duplicates);
    }
}

这个示例代码将会输出：重复的元素：[1, 2]。它会将List中的重复元素找到，并存储在新的ArrayList对象中。