java8 List<对象> 转 Set、Map（高级）

实体类

import lombok.Getter;

import lombok.Setter;

@Getter

@Setter

public class Student {

    private int id;

    private String name;

    private String score;

    private int classNo;

    public Student(int id, String name, String score, int classNo) {

        this.id = id;

        this.name = name;

        this.score = score;

        this.classNo = classNo;

    }

}

Main

import com.demo.entity.Student;

import java.util.*;

import java.util.stream.Collectors;

public class Main {

    private static List<String> simpleList = new ArrayList<>();

    private static List<Student> normalList = new ArrayList<>();

    static {

        simpleList.add("apple");

        simpleList.add("apple");

        simpleList.add("banana");

        simpleList.add("orange");

        normalList.add(new Student(1, "Emma", "A", 701));

        normalList.add(new Student(2, "Larissa", "S", 701));

        normalList.add(new Student(3, "Sophia", "B", 701));

        normalList.add(new Student(4, "Ashley", "B", 702));

        normalList.add(new Student(5, "May", "C", 702));

        normalList.add(new Student(6, "Hailey", "D", 702));

        normalList.add(new Student(7, "Kelly", "S", 703));

        normalList.add(new Student(8, "Amy", "A", 703));

        normalList.add(new Student(9, "Wesley", "C", 703));

    }

    public static void main(String[] args){

        // TODO

    }

}

List<String> 转 Set<String>

System.out.println("----------------简单List---------------");

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

System.out.println("----------------简单List转Set---------------");

Set<String> simpleSet = new HashSet<>(simpleList);

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

输出：

----------------简单List---------------

apple

apple

banana

orange

----------------简单List转Set---------------

banana

orange

apple

List<Student> 转 Set<Integer>

System.out.println("----------------普通List---------------");

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

System.out.println("----------------普通List转Set---------------");

Set<Integer> normalSet = normalList.stream().map(Student::getClassNo).collect(Collectors.toSet());

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

输出：

----------------普通List---------------

Student{id=, name='Emma', score='A', classNo=}

Student{id=, name='Larissa', score='S', classNo=}

Student{id=, name='Sophia', score='B', classNo=}

Student{id=, name='Ashley', score='B', classNo=}

Student{id=, name='May', score='C', classNo=}

Student{id=, name='Hailey', score='D', classNo=}

Student{id=, name='Kelly', score='S', classNo=}

Student{id=, name='Amy', score='A', classNo=}

Student{id=, name='Wesley', score='C', classNo=}

----------------普通List转Set---------------

List<Student> 转 List<String>

System.out.println("----------------普通List转List---------------");

List<String> list = normalList.stream().map(Student::getName).collect(Collectors.toList());

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

输出：

----------------普通List转List---------------

Emma

Larissa

Sophia

Ashley

May

Hailey

Kelly

Amy

Wesley

List<Student> 转 Map<Integer,Student>

System.out.println("----------------普通List转Map---------------");

Map<Integer,Student> normalMap = normalList.stream().collect(Collectors.toMap(Student::getId,(b)->b));

normalMap.forEach((id, student) -> {

    System.out.println(id + "::" + student);

});

输出：

----------------普通List转Map---------------

::Student{id=, name='Emma', score='A', classNo=}

::Student{id=, name='Larissa', score='S', classNo=}

::Student{id=, name='Sophia', score='B', classNo=}

::Student{id=, name='Ashley', score='B', classNo=}

::Student{id=, name='May', score='C', classNo=}

::Student{id=, name='Hailey', score='D', classNo=}

::Student{id=, name='Kelly', score='S', classNo=}

::Student{id=, name='Amy', score='A', classNo=}

::Student{id=, name='Wesley', score='C', classNo=}

复杂一点的转换：(List转Map处理重复key)

List<Student> students = new ArrayList<>(normalList);

System.out.println("----------------原数据---------------");

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

System.out.println("----------------List<Student>转Map<String, Student>重复key只保留前者---------------");

// 重复key处理 (s1, s2) -> s1)

Map<Integer, Student> classStudentMap = students.stream().collect(Collectors.toMap(Student::getClassNo, s -> s, (s1, s2) -> s1));

classStudentMap.forEach((classNo, student) -> System.out.println(classNo + "::" + student));

System.out.println("----------------List<Student>转Map<String, List<Student>>---------------");

// 重复key处理成一个集合

Map<Integer, List<Student>> listMap = students.stream().collect(Collectors.toMap(Student::getClassNo, s -> {

    List<Student> l = new ArrayList<>();

    l.add(s);

    return l;

}, (List<Student> s1, List<Student> s2) -> {

    s1.addAll(s2);

    return s1;

}));

listMap.forEach((learn, student) -> System.out.println(learn + "::" + student));

输出：

----------------原数据---------------

Student{id=, name='Emma', score='A', classNo=}

Student{id=, name='Larissa', score='S', classNo=}

Student{id=, name='Sophia', score='B', classNo=}

Student{id=, name='Ashley', score='B', classNo=}

Student{id=, name='May', score='C', classNo=}

Student{id=, name='Hailey', score='D', classNo=}

Student{id=, name='Kelly', score='S', classNo=}

Student{id=, name='Amy', score='A', classNo=}

Student{id=, name='Wesley', score='C', classNo=}

----------------List<Student>转Map<String, Student>重复key只保留前者---------------

::Student{id=, name='Emma', score='A', classNo=}

::Student{id=, name='Ashley', score='B', classNo=}

::Student{id=, name='Kelly', score='S', classNo=}

----------------List<Student>转Map<String, List<Student>>---------------

::[Student{id=, name='Emma', score='A', classNo=}, Student{id=, name='Larissa', score='S', classNo=}, Student{id=, name='Sophia', score='B', classNo=}]

::[Student{id=, name='Ashley', score='B', classNo=}, Student{id=, name='May', score='C', classNo=}, Student{id=, name='Hailey', score='D', classNo=}]

::[Student{id=, name='Kelly', score='S', classNo=}, Student{id=, name='Amy', score='A', classNo=}, Student{id=, name='Wesley', score='C', classNo=}]

Map<String, List<Student>>转List<Student> 和 Map<String, List<Student>>转List<List<Student>>

List<Student> students = new ArrayList<>(normalList);

// 先分组，准备好数据

Map<String, List<Student>> grouping = students.stream().collect(Collectors.groupingBy(Student::getScore));

System.out.println("----------------Map<String, List<Student>>转List<Student>---------------");

// 把map的values全部拆出来

List<Student> collect = grouping.entrySet().stream()

        .flatMap(map -> map.getValue().stream())

        .collect(Collectors.toList());

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

System.out.println("----------------Map<String, List<Student>>转List<List<Student>>---------------");

// 只要map的value，但是不改变格式

grouping.values().forEach(System.out::println);

输出：

----------------Map<String, List<Student>>转List<Student>---------------

Student{id=, name='Emma', score='A', classNo=}

Student{id=, name='Amy', score='A', classNo=}

Student{id=, name='Sophia', score='B', classNo=}

Student{id=, name='Ashley', score='B', classNo=}

Student{id=, name='May', score='C', classNo=}

Student{id=, name='Wesley', score='C', classNo=}

Student{id=, name='Larissa', score='S', classNo=}

Student{id=, name='Kelly', score='S', classNo=}

Student{id=, name='Hailey', score='D', classNo=}

----------------Map<String, List<Student>>转List<List<Student>>---------------

[Student{id=, name='Emma', score='A', classNo=}, Student{id=, name='Amy', score='A', classNo=}]

[Student{id=, name='Sophia', score='B', classNo=}, Student{id=, name='Ashley', score='B', classNo=}]

[Student{id=, name='May', score='C', classNo=}, Student{id=, name='Wesley', score='C', classNo=}]

[Student{id=, name='Larissa', score='S', classNo=}, Student{id=, name='Kelly', score='S', classNo=}]

[Student{id=, name='Hailey', score='D', classNo=}]

分组

List<Student> students = new ArrayList<>(normalList);

System.out.println("----------------分组---------------");

// 根据key分组

Map<String, List<Student>> grouping = students.stream().collect(Collectors.groupingBy(Student::getScore));

grouping.forEach((score, student) -> System.out.println(score + "::" + student));

System.out.println("----------------按照多个属性分组---------------");

// 根据多个key的组合分组

grouping = students.stream().collect(Collectors.groupingBy( e -> e.getClassNo() + "_" + e.getScore()));

grouping.forEach((learn, student) -> System.out.println(learn + "::" + student));

输出：

----------------分组---------------

A::[Student{id=, name='Emma', score='A', classNo=}, Student{id=, name='Amy', score='A', classNo=}]

B::[Student{id=, name='Sophia', score='B', classNo=}, Student{id=, name='Ashley', score='B', classNo=}]

C::[Student{id=, name='May', score='C', classNo=}, Student{id=, name='Wesley', score='C', classNo=}]

S::[Student{id=, name='Larissa', score='S', classNo=}, Student{id=, name='Kelly', score='S', classNo=}]

D::[Student{id=, name='Hailey', score='D', classNo=}]

----------------按照多个属性分组---------------

702_C::[Student{id=, name='May', score='C', classNo=}]

703_A::[Student{id=, name='Amy', score='A', classNo=}]

702_B::[Student{id=, name='Ashley', score='B', classNo=}]

701_S::[Student{id=, name='Larissa', score='S', classNo=}]

703_C::[Student{id=, name='Wesley', score='C', classNo=}]

703_S::[Student{id=, name='Kelly', score='S', classNo=}]

702_D::[Student{id=, name='Hailey', score='D', classNo=}]

701_B::[Student{id=, name='Sophia', score='B', classNo=}]

701_A::[Student{id=, name='Emma', score='A', classNo=}]

排序

List<Student>根据名字排序

System.out.println("----------------List排序---------------");

// 虽然这里是浅拷贝，但是只影响修改而不影响排序

List<Student> students = new ArrayList<>(normalList);

Collections.sort(students, Comparator.comparing(Student::getName));

// 比上面更简洁

// students.sort(Comparator.comparing(Student::getName));

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

输出：

----------------List排序---------------

Student{id=8, name='Amy', score='A', classNo=703}

Student{id=4, name='Ashley', score='B', classNo=702}

Student{id=1, name='Emma', score='A', classNo=701}

Student{id=6, name='Hailey', score='D', classNo=702}

Student{id=7, name='Kelly', score='S', classNo=703}

Student{id=2, name='Larissa', score='S', classNo=701}

Student{id=5, name='May', score='C', classNo=702}

Student{id=3, name='Sophia', score='B', classNo=701}

Student{id=9, name='Wesley', score='C', classNo=703}

List<String>排序

System.out.println("----------------简单List排序---------------");

List<String> list = new ArrayList<>(simpleList);

System.out.println("----------------正序---------------");

list.sort((a,b) -> a.compareTo(b));

// 更简洁的方式

// list.sort(Comparator.naturalOrder());

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

System.out.println("----------------倒序---------------");

list.sort(Comparator.reverseOrder());

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

输出：

----------------简单List排序---------------

----------------正序---------------

apple

apple

banana

orange

----------------倒序---------------

orange

banana

apple

apple

Map排序

List<Student> students = new ArrayList<>(normalList);

// 先按照成绩分组，准备好数据

Map<String, List<Student>> grouping = students.stream().collect(Collectors.groupingBy(Student::getScore));

System.out.println("----------------Map<String, List<Student>>排序---------------");

Map<String, List<Student>> result = new LinkedHashMap<>();

// Map的key有特殊处理

grouping.entrySet().stream()

        .sorted((o1,o2) -> {

            Integer k1 = getWeight(o1.getKey());

            Integer k2 = getWeight(o2.getKey());

            return k1.compareTo(k2);

        })

        .forEachOrdered(x -> result.put(x.getKey(), x.getValue()));

result.forEach((learn, student) -> System.out.println(learn + "::" + student));

System.out.println("----------------");

Map<String, List<Student>> result2 = new LinkedHashMap<>();

// 仅仅按照key排序

grouping.entrySet().stream()

        .sorted(Map.Entry.comparingByKey())

        .forEachOrdered(x -> result2.put(x.getKey(), x.getValue()));

result2.forEach((learn, student) -> System.out.println(learn + "::" + student));

System.out.println("----------------");

Map<String, List<Student>> result3 = new LinkedHashMap<>();

// 等价第一个，只是省去了getKey方法

grouping.entrySet().stream()

        .sorted(Map.Entry.comparingByKey((o1,o2) -> {

            Integer k1 = getWeight(o1);

            Integer k2 = getWeight(o2);

            return k1.compareTo(k2);

        }))

        .forEachOrdered(x -> result3.put(x.getKey(), x.getValue()));

result3.forEach((learn, student) -> System.out.println(learn + "::" + student));

权重方法：

/**

 * 不同成绩有不同的排序权重

 * @param score

 * @return

 */

public static Integer getWeight(String score){

    switch (score){

        case "S": return 1;

        case "A": return 2;

        case "B": return 3;

        case "C": return 2;

        case "D": return 2;

        default:return 0;

    }

}

输出：

----------------Map<String, List<Student>>排序---------------

S::[Student{id=, name='Larissa', score='S', classNo=}, Student{id=, name='Kelly', score='S', classNo=}]

A::[Student{id=, name='Emma', score='A', classNo=}, Student{id=, name='Amy', score='A', classNo=}]

C::[Student{id=, name='May', score='C', classNo=}, Student{id=, name='Wesley', score='C', classNo=}]

D::[Student{id=, name='Hailey', score='D', classNo=}]

B::[Student{id=, name='Sophia', score='B', classNo=}, Student{id=, name='Ashley', score='B', classNo=}]

----------------

A::[Student{id=, name='Emma', score='A', classNo=}, Student{id=, name='Amy', score='A', classNo=}]

B::[Student{id=, name='Sophia', score='B', classNo=}, Student{id=, name='Ashley', score='B', classNo=}]

C::[Student{id=, name='May', score='C', classNo=}, Student{id=, name='Wesley', score='C', classNo=}]

D::[Student{id=, name='Hailey', score='D', classNo=}]

S::[Student{id=, name='Larissa', score='S', classNo=}, Student{id=, name='Kelly', score='S', classNo=}]

----------------

S::[Student{id=, name='Larissa', score='S', classNo=}, Student{id=, name='Kelly', score='S', classNo=}]

A::[Student{id=, name='Emma', score='A', classNo=}, Student{id=, name='Amy', score='A', classNo=}]

C::[Student{id=, name='May', score='C', classNo=}, Student{id=, name='Wesley', score='C', classNo=}]

D::[Student{id=, name='Hailey', score='D', classNo=}]

B::[Student{id=, name='Sophia', score='B', classNo=}, Student{id=, name='Ashley', score='B', classNo=}]

如果你要倒序的话

System.out.println("----------------倒序----------------");

Map<String, List<Student>> result4 = new LinkedHashMap<>();

// 仅仅按照key排序

grouping.entrySet().stream()

        .sorted(Map.Entry.<String, List<Student>>comparingByKey().reversed())

        .forEachOrdered(x -> result4.put(x.getKey(), x.getValue()));

result4.forEach((learn, student) -> System.out.println(learn + "::" + student));

System.out.println("----------------");

Map<String, List<Student>> result5 = new LinkedHashMap<>();

// 等价第一个，只是省去了getKey方法

grouping.entrySet().stream()

        .sorted(Map.Entry.<String, List<Student>>comparingByKey((o1,o2) -> {

            Integer k1 = getWeight(o1);

            Integer k2 = getWeight(o2);

            return k1.compareTo(k2);

        }).reversed())

        .forEachOrdered(x -> result5.put(x.getKey(), x.getValue()));

result5.forEach((learn, student) -> System.out.println(learn + "::" + student));

输出：

----------------倒序----------------

S::[Student{id=, name='Larissa', score='S', classNo=}, Student{id=, name='Kelly', score='S', classNo=}]

D::[Student{id=, name='Hailey', score='D', classNo=}]

C::[Student{id=, name='May', score='C', classNo=}, Student{id=, name='Wesley', score='C', classNo=}]

B::[Student{id=, name='Sophia', score='B', classNo=}, Student{id=, name='Ashley', score='B', classNo=}]

A::[Student{id=, name='Emma', score='A', classNo=}, Student{id=, name='Amy', score='A', classNo=}]

----------------

B::[Student{id=, name='Sophia', score='B', classNo=}, Student{id=, name='Ashley', score='B', classNo=}]

A::[Student{id=, name='Emma', score='A', classNo=}, Student{id=, name='Amy', score='A', classNo=}]

C::[Student{id=, name='May', score='C', classNo=}, Student{id=, name='Wesley', score='C', classNo=}]

D::[Student{id=, name='Hailey', score='D', classNo=}]

S::[Student{id=, name='Larissa', score='S', classNo=}, Student{id=, name='Kelly', score='S', classNo=}]

统计

String s = "15, 11, 01, 03, 07, 12, 15, 12, 15, 02, 07, 14, 01, 03, 04, 05, 09, 04, 06, 12, 04, 07, 13, 10, 04, 14, 13, 11, 10, 16, 16, 04, 15, 03, 16, 08, 10, 05, 08, 11, 16, 04, 13, 07, 14, 06, 14, 10, 15, 02, 09, 16, 08, 11, 10, 01, 16, 12, 06, 01, 12, 01, 16, 12, 10, 04";

List<Integer> list = new ArrayList<>();

for(String i : s.split(", ")){

    list.add(Integer.valueOf(i));

}

// 平均值

System.out.println(list.stream().mapToDouble(value -> value).average());

// 总值

System.out.println(list.stream().mapToDouble(value -> value).sum());

// 数据数量

System.out.println(list.stream().mapToDouble(value -> value).count());

// 最大

System.out.println(list.stream().mapToDouble(value -> value).max());

// 最小

System.out.println(list.stream().mapToDouble(value -> value).min());

// 去重后计算总值

System.out.println(list.stream().mapToDouble(value -> value).distinct().sum());

也有其他数据类型的方法

结果：

OptionalDouble[9.121212121212121]

602.0

66

OptionalDouble[16.0]

OptionalDouble[1.0]

136.0

=========================================分割线=================================================

Lambda表达式

格式：(params) -> {expression}

比如我们实现一个Runnable接口

Runnable run = new Runnable() {

    @Override

    public void run() {

        // TODO

    }

};

使用Lambda表达式

Runnable run = () -> {

    // TODO

};

而可以使用Lambda的接口也是有限制的，即只能有一个方法。

函数式接口

规范：

1. 接口中只能有一个抽象方法

2. （可选）在接口上添加 @FunctionalInterface 注解，这样可以检测它是否是一个函数式接口。

比如：

@FunctionalInterface

public interface Fun{

    void fun();

}

// 也可以使用泛型

@FunctionalInterface

public interface Fun<T>{

    void fun(T t);

}

使用的时候

Fun fun = () -> {};

为什么Lambda引用外部变量需要final修饰？

1. 每个方法执行的时候都会在栈上创建一个栈帧，局部变量存放在栈帧中的局部变量表中，栈上的内容是线程私有的。

2. Lambda表达式是个匿名函数，准确来说是个匿名内部类接口的实现方法。而执行此代码的线程会在执行的时候单独创建一个栈帧，局部变量依然是私有的。

3. 由此可见，表达式里的current变量只是外部current变量的一个副本。而为了保证程序的正确性则强制要求这个被引用的局部变量被定义成final。

也就是说，人家也可以不加入这个检查，允许你改变外部局部变量的值，但是，程序运行的结果并不会如你所愿，所以，人家索性就打消你这个念头。

其它Java8新特性

1. computeIfAbsent

Map<String, String> map = new HashMap<>();

String key = "A";

String v = map.get(key);

if (v == null){

    System.out.println("处理key不存在的情况");

}

Java8可以这样处理

Map<String, String> map = new HashMap<>();

String key = "A";

String computeIfAbsent = map.computeIfAbsent(key, s -> {

    return "如果key不存在，则返回这个";

});

System.out.println(computeIfAbsent);

2. filter

过滤出特定数据，并取出特定字段

import lombok.Getter;

import java.util.ArrayList;

import java.util.List;

import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) throws Exception {

        List<People> list = new ArrayList<>();

        list.add(new People(1, "男"));

        list.add(new People(2, "女"));

        list.add(new People(3, "女"));

        List<Integer> collect = list.stream().filter(i -> "女".equals(i.getSex())).map(People::getId).collect(Collectors.toList());

        System.out.println(collect);

    }

}

@Getter

class People{

    private int id;

    private String sex;

    public People(int id, String sex) {

        this.id = id;

        this.sex = sex;

    }

}

输出

随时补充

java8 List<对象> 转 Set、Map（高级）的更多相关文章

java8新特性：对map集合排序
一.简单介绍Map 在讲解Map排序之前,我们先来稍微了解下map,map是键值对的集合接口,它的实现类主要包括:HashMap, TreeMap, Hashtable以及LinkedHashMap等 ...
Map.putAll方法——追加另一个Map对象到当前Map集合(转)
该方法用来追加另一个Map对象到当前Map集合对象,它会把另一个Map集合对象中的所有内容添加到当前Map集合对象. 语法 putAll(Map<? extends K,? extends V ...
将Object对象转换成Map 属性名和值的形式
将Java对象转换成Map的键值对形式代码: package cn.lonelcoud.util; import com.sun.deploy.util.StringUtils; import ja ...
Java对象转换成Map
需求总是千奇百怪,对象转成map,看似没必要,但就是有这个需求,所以记录下来首先是Bean package tools; import lombok.Data; /** * 车辆实体类 */ @Da ...
Java8从对象列表中取出某个属性的列表
List<属性值类型> 属性List = 对象List.stream().map(对象::get方法()).collect(Collectors.toList()); 例如: List&l ...
Map.putAll方法——追加另一个Map对象到当前Map集合
转: Map.putAll方法——追加另一个Map对象到当前Map集合(转) 该方法用来追加另一个Map对象到当前Map集合对象,它会把另一个Map集合对象中的所有内容添加到当前Map集合对象. 语法 ...
对象Bean与Map互转问题
一.摘要在实际开发过程中,经常碰到需要进行对象与map之间互转的问题,其实对于对象.Map 之间进行互转有很多种方式,下面我们一起来梳理一下: 利用 JSON 工具包,将对象转成字符串,之后再转成 ...
java8 快速实现List转map 、分组、过滤等操作
利用java8新特性,可以用简洁高效的代码来实现一些数据处理. 定义1个Apple对象: public class Apple { private Integer id; private String ...
java8中optional和.stream().map()
使用optional的好处:是一个可以包含或不可以包含非空值的容器对象,更加友好的处理程序中的空对象. Optional<T>有方法 isPresent() 和 get() 是用来检查其包 ...

随机推荐

三、安装MyCat-Web
一.下载和解压MyCat-web http://dl.mycat.io/mycat-web-1.0/ wget http://dl.mycat.io/mycat-web-1.0/Mycat-web-1 ...
Python——Flask框架——模板
一.渲染模板 render_template 函数把Jinja2模板引擎集成到程序中二.Jinja2变量过滤器过滤器名说明 safe 渲染值是不转义 capitalize 把值得首字母转换成大写 ...
Java 获取客户端ip返回127.0.0.1问题
Java开发中使用 request.getRemoteAddr 获取客户端 ip ,返回结果始终为127.0.0.1.原因是服务器使用了nginx反向代理. 解决办法:在nginx配置文件nginx. ...
WGS84，GCJ02， BD09坐标转换
public class Gps { private double wgLat; private double wgLon; public Gps(double wgLat, double wgLon ...
Nintex Forms Drop-Down "z-index"
Now we’ve got the issue, that if we are working with a “Person-Column”, the drop-down where you can ...
ubuntu终端快捷键
ctrl+alt+t 新终端 ctrl+shift+t打开新的标签页 ctrl+d关闭终端 ctrl+s 暂停屏幕输出 ctrl+q 继续屏幕输出 ctrl+l 清屏 ctrl+alt+f1 切换到第 ...
Luogu4389 付公主的背包（生成函数+多项式exp）
显然构造出生成函数,对体积v的物品,生成函数为1+xv+x2v+……=1/(1-xv).将所有生成函数乘起来得到的多项式即为答案,设为F(x),即F(x)=1/∏(1-xvi).但这个多项式的项数是Σ ...
Codeforces 714A 朋友聚会
参考自:https://www.cnblogs.com/ECJTUACM-873284962/p/6395268.html A. Meeting of Old Friends time limit p ...
P1387 最大正方形 dp
思路: i j的最大正方形等于min(他的斜上方的的最大正方形,他的上方有的连续1,他的左方有的连续1)+1 #include<bits/stdc++.h> using namespac ...
[USACO12MAR] 花盆Flowerpot
类型:二分+单调队列传送门:>Here< 题意:给出$N$个点的坐标,要求根据$x$轴选定一段区间$[L,R]$,使得其中的点的最大与最小的$y$值之差$\geq D$.求$Min\{R ...