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() 是用来检查其包 ...
随机推荐
- static类型的变量
c语言中变量的储存类型有以下四种 auto 如果没有定义储存类型 默认就是这个类型 比如 int a = 10; 储存类型就是 auto:编译器会跟你定义的位置,以及用途,自动帮你决定使用那 ...
- WebAPI MVC Change Identity Default Table
看过之前的文章小伙伴们应该已经明白了,当我们新建一个带有身份验证的模板时,会自带Identity Server,并且它的表名和字段名也都是默认的. 那么该如何修改它,并让EF知道呢?不废话,直接上代码 ...
- JSON 解析 （二）—— Jackson的使用
Jackson是基于Java语言的一种JSON和Java对象的数据处理工具.功能上简单易用,性能上根据目前主流转换工具比较,Jackson相对比较高效. <dependency> < ...
- JAVA优先级队列元素输出顺序测试
package code.test; import java.util.Comparator; import java.util.Iterator; import java.util.Priority ...
- 下拉列表模仿placeholder效果
模仿placeholder效果 <select id="IsTop"> <option value="" disabled selected& ...
- 使用RestTemplate测试视频上传的Post请求
以往多用RestTemplate处理接口的调用以及与Ribbon/Feign配合使用调用微服务接口,近日写了一个处理Post文件上传的解决方案,其实就是将后台所需的MultipartFile,在请求P ...
- 面向对象—的__new__()方法详解
[Python] Python 之 __new__() 方法与实例化 __new__() 是在新式类中新出现的方法,它作用在构造方法建造实例之前,可以这么理解,在 Python 中存在于类里面的构 ...
- 一个模拟——抢票部分功能的 简单版（主要实例化一下 Lock 的使用）
""" 抢票! 多个用户在同时读写同一个数据 """ from multiprocessing import Process,Lock im ...
- Matplotlib学习---用seaborn画直方图，核密度图（histogram, kdeplot）
由于直方图受组距(bin size)影响很大,设置不同的组距可能会产生完全不同的可视化结果.因此我们可以用密度平滑估计来更好地反映数据的真实特征.具体可参见这篇文章:https://blog.csdn ...
- python爬取豆瓣前25个影片内容的正则表达式练习
通过python正则表达式获取豆瓣top250的第一页的25个影片排名,影片名字,影片连接,导演,主演,上映日期,国家,剧情,评分,评价人数的内容 网页html内容: <ol class=&qu ...