实体类

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=1, name='Emma', score='A', classNo=701}
Student{id=2, name='Larissa', score='S', classNo=701}
Student{id=3, name='Sophia', score='B', classNo=701}
Student{id=4, name='Ashley', score='B', classNo=702}
Student{id=5, name='May', score='C', classNo=702}
Student{id=6, name='Hailey', score='D', classNo=702}
Student{id=7, name='Kelly', score='S', classNo=703}
Student{id=8, name='Amy', score='A', classNo=703}
Student{id=9, name='Wesley', score='C', classNo=703}
----------------普通List转Set---------------
701
702
703

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---------------
1::Student{id=1, name='Emma', score='A', classNo=701}
2::Student{id=2, name='Larissa', score='S', classNo=701}
3::Student{id=3, name='Sophia', score='B', classNo=701}
4::Student{id=4, name='Ashley', score='B', classNo=702}
5::Student{id=5, name='May', score='C', classNo=702}
6::Student{id=6, name='Hailey', score='D', classNo=702}
7::Student{id=7, name='Kelly', score='S', classNo=703}
8::Student{id=8, name='Amy', score='A', classNo=703}
9::Student{id=9, name='Wesley', score='C', classNo=703}

复杂一点的转换：(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=1, name='Emma', score='A', classNo=701}
Student{id=2, name='Larissa', score='S', classNo=701}
Student{id=3, name='Sophia', score='B', classNo=701}
Student{id=4, name='Ashley', score='B', classNo=702}
Student{id=5, name='May', score='C', classNo=702}
Student{id=6, name='Hailey', score='D', classNo=702}
Student{id=7, name='Kelly', score='S', classNo=703}
Student{id=8, name='Amy', score='A', classNo=703}
Student{id=9, name='Wesley', score='C', classNo=703}
----------------List<Student>转Map<String, Student>重复key只保留前者---------------
701::Student{id=1, name='Emma', score='A', classNo=701}
702::Student{id=4, name='Ashley', score='B', classNo=702}
703::Student{id=7, name='Kelly', score='S', classNo=703}
----------------List<Student>转Map<String, List<Student>>---------------
701::[Student{id=1, name='Emma', score='A', classNo=701}, Student{id=2, name='Larissa', score='S', classNo=701}, Student{id=3, name='Sophia', score='B', classNo=701}]
702::[Student{id=4, name='Ashley', score='B', classNo=702}, Student{id=5, name='May', score='C', classNo=702}, Student{id=6, name='Hailey', score='D', classNo=702}]
703::[Student{id=7, name='Kelly', score='S', classNo=703}, Student{id=8, name='Amy', score='A', classNo=703}, Student{id=9, name='Wesley', score='C', classNo=703}]

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=1, name='Emma', score='A', classNo=701}
Student{id=8, name='Amy', score='A', classNo=703}
Student{id=3, name='Sophia', score='B', classNo=701}
Student{id=4, name='Ashley', score='B', classNo=702}
Student{id=5, name='May', score='C', classNo=702}
Student{id=9, name='Wesley', score='C', classNo=703}
Student{id=2, name='Larissa', score='S', classNo=701}
Student{id=7, name='Kelly', score='S', classNo=703}
Student{id=6, name='Hailey', score='D', classNo=702}
----------------Map<String, List<Student>>转List<List<Student>>---------------
[Student{id=1, name='Emma', score='A', classNo=701}, Student{id=8, name='Amy', score='A', classNo=703}]
[Student{id=3, name='Sophia', score='B', classNo=701}, Student{id=4, name='Ashley', score='B', classNo=702}]
[Student{id=5, name='May', score='C', classNo=702}, Student{id=9, name='Wesley', score='C', classNo=703}]
[Student{id=2, name='Larissa', score='S', classNo=701}, Student{id=7, name='Kelly', score='S', classNo=703}]
[Student{id=6, name='Hailey', score='D', classNo=702}]

分组

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=1, name='Emma', score='A', classNo=701}, Student{id=8, name='Amy', score='A', classNo=703}]
B::[Student{id=3, name='Sophia', score='B', classNo=701}, Student{id=4, name='Ashley', score='B', classNo=702}]
C::[Student{id=5, name='May', score='C', classNo=702}, Student{id=9, name='Wesley', score='C', classNo=703}]
S::[Student{id=2, name='Larissa', score='S', classNo=701}, Student{id=7, name='Kelly', score='S', classNo=703}]
D::[Student{id=6, name='Hailey', score='D', classNo=702}]
----------------按照多个属性分组---------------
702_C::[Student{id=5, name='May', score='C', classNo=702}]
703_A::[Student{id=8, name='Amy', score='A', classNo=703}]
702_B::[Student{id=4, name='Ashley', score='B', classNo=702}]
701_S::[Student{id=2, name='Larissa', score='S', classNo=701}]
703_C::[Student{id=9, name='Wesley', score='C', classNo=703}]
703_S::[Student{id=7, name='Kelly', score='S', classNo=703}]
702_D::[Student{id=6, name='Hailey', score='D', classNo=702}]
701_B::[Student{id=3, name='Sophia', score='B', classNo=701}]
701_A::[Student{id=1, name='Emma', score='A', classNo=701}]

排序

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=2, name='Larissa', score='S', classNo=701}, Student{id=7, name='Kelly', score='S', classNo=703}]
A::[Student{id=1, name='Emma', score='A', classNo=701}, Student{id=8, name='Amy', score='A', classNo=703}]
C::[Student{id=5, name='May', score='C', classNo=702}, Student{id=9, name='Wesley', score='C', classNo=703}]
D::[Student{id=6, name='Hailey', score='D', classNo=702}]
B::[Student{id=3, name='Sophia', score='B', classNo=701}, Student{id=4, name='Ashley', score='B', classNo=702}]
----------------
A::[Student{id=1, name='Emma', score='A', classNo=701}, Student{id=8, name='Amy', score='A', classNo=703}]
B::[Student{id=3, name='Sophia', score='B', classNo=701}, Student{id=4, name='Ashley', score='B', classNo=702}]
C::[Student{id=5, name='May', score='C', classNo=702}, Student{id=9, name='Wesley', score='C', classNo=703}]
D::[Student{id=6, name='Hailey', score='D', classNo=702}]
S::[Student{id=2, name='Larissa', score='S', classNo=701}, Student{id=7, name='Kelly', score='S', classNo=703}]
----------------
S::[Student{id=2, name='Larissa', score='S', classNo=701}, Student{id=7, name='Kelly', score='S', classNo=703}]
A::[Student{id=1, name='Emma', score='A', classNo=701}, Student{id=8, name='Amy', score='A', classNo=703}]
C::[Student{id=5, name='May', score='C', classNo=702}, Student{id=9, name='Wesley', score='C', classNo=703}]
D::[Student{id=6, name='Hailey', score='D', classNo=702}]
B::[Student{id=3, name='Sophia', score='B', classNo=701}, Student{id=4, name='Ashley', score='B', classNo=702}]

如果你要倒序的话

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=2, name='Larissa', score='S', classNo=701}, Student{id=7, name='Kelly', score='S', classNo=703}]
D::[Student{id=6, name='Hailey', score='D', classNo=702}]
C::[Student{id=5, name='May', score='C', classNo=702}, Student{id=9, name='Wesley', score='C', classNo=703}]
B::[Student{id=3, name='Sophia', score='B', classNo=701}, Student{id=4, name='Ashley', score='B', classNo=702}]
A::[Student{id=1, name='Emma', score='A', classNo=701}, Student{id=8, name='Amy', score='A', classNo=703}]
----------------
B::[Student{id=3, name='Sophia', score='B', classNo=701}, Student{id=4, name='Ashley', score='B', classNo=702}]
A::[Student{id=1, name='Emma', score='A', classNo=701}, Student{id=8, name='Amy', score='A', classNo=703}]
C::[Student{id=5, name='May', score='C', classNo=702}, Student{id=9, name='Wesley', score='C', classNo=703}]
D::[Student{id=6, name='Hailey', score='D', classNo=702}]
S::[Student{id=2, name='Larissa', score='S', classNo=701}, Student{id=7, name='Kelly', score='S', classNo=703}]

统计

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() {@Overridepublic 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（高级）、排序、分组、统计相关推荐

1. java8新特性：对map集合排序

   一.简单介绍Map 在讲解Map排序之前,我们先来稍微了解下map,map是键值对的集合接口,它的实现类主要包括:HashMap, TreeMap, Hashtable以及LinkedHashMap等 ...

2. java8新特性：对map集合排序，根据key或者value操作排序（升序、降序）

   java8新特性:对map集合排序,根据key或者value操作排序(升序.降序) 直接上代码: package com.drew.test; import java.util.List; impor ...

3. java8特性：list转Map并排序

   初始代码 public Map<String,List<RgwstBean>> getMap(List<RgwstBean> lists){Map<Strin ...

4. java8分组_JAVA8 分组统计

   JAVA8使用stream()根据ID对List进行分组统计 Apple类: /** * @version: V1.0 * @author: fendo * @className: Apple * @ ...

5. java map 值排序_使用Java8 Stream API对Map类型按照键或值进行排序

   在这篇文章中,您将学习如何使用Java对Map按照键或值进行排序.前几日有位朋友面试遇到了这个问题,看似很简单的问题,但是如果不仔细研究一下也是很容易让人懵圈的面试题.所以我决定写这样一篇文章.在Ja ...

6. Java8 对Map进行排序

   前言: 随着Java 8 的 Stream 之后推出后可以很优雅实现Map的排序. 示例: final Map<String, Integer> wordCounts = new Hash ...

7. JS中集合对象(Array、Map、Set)及类数组对象的使用与对比

   JS中集合对象(Array.Map.Set)及类数组对象的使用与对比 在使用js编程的时候,常常会用到集合对象,集合对象其实是一种泛型,在js中没有明确的规定其内元素的类型,但在强类型语言譬如Java ...

8. 将JSON对象中的某个字段进行分组和排序(java实现)

   现在有这样一个数据 { "systemid": "123", "productid": "123", "dat ...

9. java hashmap 无序_Map的有序和无序实现类，与Map的排序

   1.HashMap.Hashtable不是有序的: 2.TreeMap和LinkedHashMap是有序的(TreeMap默认 Key 升序,LinkedHashMap则记录了插入顺序). 今天做统计 ...

10. C++屏蔽map自动排序

    最近写项目时,发现map自动排序了,以前没注意这个问题,可能ms考虑到map查询效率问题,插入时候就自动按key排序,查找其内部构造,发现其是模板实现方式,咱们可以改一改模板就可以避免自动排序(万不得 ...

最新文章

1. 程序员单身比例有多高？【2019开发者图鉴】告诉你
2. WCF 第五章 控制并发调用的数量
3. 给数组里面的对象添加一个新的数据
4. Linux中su命令详解
5. msdn画圆弧函数_画直线不简单！python-matplotlib告诉你为什么
6. vim 文本一些行注释，替换
7. static,构造器,执行顺序
8. ssis中数据类型_SSIS中的数据挖掘查询
9. [运维笔记] PowerShell (模块).模块清单
10. 基于蚁群算法的二维路径规划算法
11. setup factory 会话变量
12. 多模态知识图谱构建和推理技术 王萌 东南大学
13. 大气压力换算公式_大气压强计算新方法
14. 我与刘强东的故事：他的1000亿和我的5000万（转超级表格）
15. php调用海康人脸识别摄像机,海康网络摄像机SDK对接
16. 华为q1设置虚拟服务器,华为路由Q1上网设置【图文】教程 | 192路由网
17. STM32L152 的参考电压Vrefint输出
18. 推荐系统领域对比学习和数据增强论文及代码集锦
19. 女性如何理解男人的性需求？ 男性的性表达
20. 解决 unity 按住鼠标右键 WS不能前进后退（我被自己蠢哭了）

热门文章

1. 机器学习算法总结之支持向量机（五）
2. android代码zip怎么用,Rxjava Android如何使用Zip操作符
3. io hang linux 原理,Linux 避免IO hang
4. Leetcod每日一题：151.reverse-words-in-a-string（翻转字符串里的单词）
5. 吴恩达|机器学习作业6.0支持向量机(SVM)
6. 吴恩达机器学习神经网络作业（python实现）
7. 「镁客早报」第九城市与法拉第未来成立合资公司，出资6亿美元；华为获得韩国运营商5G订单，占比95%... 1
8. [Postman使用]请求与响应
9. 如何在结构体里面套结构体_Rust 学习笔记-13 Rust 结构体
10. ddddocr打包不成功解决办法