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() 是用来检查其包 ...
随机推荐
- 利用 ajax自定义Form表单的提交方式
需求场景:有时候单纯的form表单无法向后端传递额外的参数 比如需要action传递js异步生成的参数 ,form表单默认的action就无法满足需求,这时就需要我们自定义form表单的提交方式. h ...
- Ajax之Jquery封装使用举例2(Json和JsonArray处理)
本例主要使用ajax进行异步数据请求,并针对返回数据为json和jsonarray类型的数据处理. 本例中只有前端的代码,后端代码不是本文重点,故省略. 后端接口返回数据为: Json: {" ...
- freemarker -include
在ftl中使用<#include >时 ,页面被强制显示 需要在struts.xml增加跳转type ,或则可以加同一<result-types></result-typ ...
- Java反射和注解
反射:http://blog.csdn.net/liujiahan629629/article/details/18013523 注解:http://www.cnblogs.com/peida/arc ...
- model,map,MapAndVivew用于页面跳转时候使用的即跳转后才添加属性 这样再回调中无法使用 因为回调的前提是页面不调转;解决的方法是用responsewrite(普通的字符响应)
model,map,MapAndVivew用于页面跳转时候使用的即跳转后才添加属性 这样再回调中无法使用 因为回调的前提是页面不调转:解决的方法是用responsewrite
- poj-1236(强连通分量)
题意:给你n个点,每个点可能有指向其他点的单向边,代表这个点可以把软件传给他指向的点,然后解决两个问题, 1.问你最少需要给几个点,才能使所有点都能拿到软件: 2.问你还需要增加几条单向边,才能使任意 ...
- ffmpeg 转码命令与ffplay
ffmpeg.exe用于视频的转码. ▫ 最简单的命令 ffmpeg -i input.avi -b:v 640k output.ts 该命令将当前文件夹下的input.avi文件转换为output. ...
- mybatis,mysql批量delete多个记录
1.dao 接口中 Integer delete(List<UserDeviceRela> relas); 2.xml <delete id="delete" p ...
- 水课 or not
很不幸,这学期的毛概老师是个老古董,讲的内容也甚是枯燥和迂腐,个人角度是不太喜欢.然而这也仅仅是站在个人感性的角度,唏嘘一下也就够了.听不下去了,写点东西. 有时候会想,是不是随着自己长大,渐渐地对专 ...
- Hibernate 注解映射
工作中遇到hibernate映射的一些问题,这里总结一下 (特别是测试时,许多数据并不能有效关联.所以@NotFound 很重要) 一,假设有2张表user,company 我们知道,一个用户属于一个 ...