零基础学习java------21---------动态代理，java8新特性（lambda, stream,DateApi）
1. 动态代理
在一个方法前后加内容，最简单直观的方法就是直接在代码上加内容（如数据库中的事务），但这样写不够灵活，并且代码可维护性差，所以就需要引入动态代理
1.1 静态代理实现
在讲动态代理之前，需要先讲下静态代理，静态代理就是通过proxy持有realObject的引用，并进行一层封装，从而达到增强的效果
需求：在target中的test方法中加上一些内容（打印结果前后加上日志内容）
a 简单直观的方法
接口
public interface InterfaceA { public void test(); }
Target类（在上面直接加内容）
public class Target implements InterfaceA{ @Override public void test() { System.out.println("日志开始"); //方法前加内容 System.out.println("这世界会好吗"); System.out.println("日志结束"); //方法后加内容 } }
这样写不够好，破坏了target这个类，万一其他地方需要调用这个方法有的地方需要这内容，有的地方不需要，但又不想要这个日志内容，这样就显得多余了，所以，该怎么解决这个问题呢？
解决方法：定义一个单独的类来实现这样的需求，这样一个类我们称为代理
代理类（Proxy）
public class Proxy implements InterfaceA{ Target t = new Target(); //目标对象 @Override public void test() { System.out.println("日志开始"); //增强 t.test(); System.out.println("日至结束"); } }
测试类
public class ProxyTest { public static void main(String[] args) { Proxy p = new Proxy(); p.test(); } }
当目标类中的某个方法需要加一些特定的内容（如事务），就可以在代理类中创建目标类的对象并在相应方法加上想要的内容（如事务），在代理类自身的方法内调用相应的方法即可，这样以来就实现了在Target类某个方法灵活加内容的需求，但是其也有一个问题，就是当Target类中有成百上千的方法，并且每个方法都需要加上内容，这时候代理类写起来会很麻烦，这个时候就需要动态代理
1.2 动态代理的实现
接口
1.3 java8新特性
新特性概览:
1. 接口中的默认方法与静态方法（即接口中不是只能有抽象方法了）
2. Lambda 表达式
3. 集合中的Stream
4. DateApi
5. 其他
String: join
String str = String.join(",", "a", "b", "c");
1.3.1. lambda表达式
1. 使用lambda表达式的前提：
具有函数式接口（只包含一个抽象方法的接口(SAM)，其他实现了的方法可以有多个）
2. 格式：
lambda 表达式实际上就是代码块的传递的实现。其语法结构如下：
(parameters) -> expression 或者(parameters) -> {statements;}
注意事项：
a. 括号里的参数可以省略其类型，编译器会根据上下文来推导参数的类型，也可以显式的指定参数类型，如果没有参数，括号内可以为空
b. 方法体，如果有多行功能语句用大括号括起来，如果只有一行功能语句则可以省略大括号
c. 可替代匿名内部类
方法的引用（不太懂）：
方法引用，方法引用是lambda 表达式的一种简写形式。如果lambda 表达式只是调用一个特定的已经存在的方法，则可以使用方法引用。
使用“::”操作符将方法名和对象或类的名字分隔开来。以下是四种使用情况：
对象::实例方法
类::静态方法
类::实例方法
类::new
Arrays.sort(str, (o1,o2)->o1.compareToIgnoreCase(o2));
Arrays.sort(strings, String::compareToIgnoreCase);
案例1：以线程为例
正常开启一个线程的代码如下：
public class LambdaDemo { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { System.out.println("哈哈"); } }).start();; } }
分析：Thread里面一定是runnable对象，所以此可以省略掉，此外，runnable里面只有run方法，所以也可以省略，简化后的代码就变成如下：
public class LambdaDemo { public static void main(String[] args) { new Thread(() { // 此处的小括号不能省略，有可能要传参数 System.out.println("哈哈"); }).start();; } }
如果实现的抽象方法只有一行，那么大括号也可以省略，用lambda得到的代码如下
public class LambdaDemo { public static void main(String[] args) { new Thread(()-> System.out.println("哈哈")).start();; } }
lambda表达式只关注接口中方法的参数，以及方法是怎么实现的
案例2：list的降序排序
未使用lambda表达式
public class LambdaDemo { public static void main(String[] args) { List<Integer> list = Arrays.asList(1,3,6,12,14,27); Collections.sort(list, new Comparator<Integer>() { //实现降序排序 @Override public int compare(Integer o1, Integer o2) { // TODO Auto-generated method stub return o2-o1; } }); } }
lambda表达式
public class LambdaDemo { public static void main(String[] args) { List<Integer> list = Arrays.asList(1,3,6,12,14,27); Collections.sort(list, (o1,o2)-> o2-o1); }
// 遍历此list
list.forEach((t)->System.out.print(t))
// 将上面遍历进一步改为方法引用
list.forEach(System.out::print) }
此处o1，o2的类型可以省略，如上，编译器会根据上下文自动推断出其类型，此处为Integer类型
案例3：map的遍历（常规方法有三种，见以前笔记）
lambda形式
public class LambdaDemo1 { public static void main(String[] args) { HashMap<Integer, String> map = new HashMap<>(); map.put(1, "a"); map.put(2, "b"); map.put(3, "c"); map.put(4, "d"); map.forEach((k,v)->System.out.println(k+":"+v)); } }
1.3.2 stream
Stream是Java 8 提供的高效操作集合类（Collection）数据的API
1. 如何获取Stream
（1）使用集合创建
public static Stream<Integer> getStream() { List<Integer> list = Arrays.asList(1,2,3,5,32,24); return list.stream(); }
（2）使用数组创建
String[] arr = new String[] {"James","Wade","Kobe","Jardon"}; return Arrays.stream(arr);
（3）使用value创建
return Stream.of("哈哈","呵呵","嘿嘿");
（4）使用iterate创建
return Stream.iterate("h", n->n+5).limit(10);
（5）使用generate
return Stream.generate(Math::random).limit(20);
2. Stream中常用操作
（1）forEach：循环输出
（2）filter：帅选
（3）limit：限制取多少个
（4）sorted：
（5）join：将Stream转成字符串
public class StreamDemo1 { public static void main(String[] args) { Stream<String> s4 = Stream.of("I","Love","u"); String s8 = s4.collect(Collectors.joining(" ")); System.out.println(s8);//I Love u Stream<String> s5 = Stream.of("I","Love","u"); String s9 = s5.collect(Collectors.joining(",","{","}")); System.out.println(s9);//{I,Love,u} } }
（6）distinct：去重
Stream.of("aa","bb","aa").distinct().forEach(System.out::print);//aabb
（7）map：对每一个元素进行操作
（8）reduce：归并
（9）collection：收集（将流转成集合）
1.3.3DateApi
jdk8中这个特性使得日期和时间可以分离开（以前的date是连在一起的），其通过三个类实现，如下
public class DateApiDemo { public static void main(String[] args) { LocalDateTime now = LocalDateTime.now();//当前时间(日期和时间) System.out.println(now); //2019-09-02T16:59:29.862366800 LocalDate now1 = LocalDate.now();//日期 System.out.println(now1);//2019-09-02 LocalTime now2 = LocalTime.now();//时间 System.out.println(now2);//17:03:32.698811500 } }
把LocalDateTime转成想要的格式（使用DateTimeFormatter）
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); System.out.println(now.format(dtf)); // 2019-09-02 17:12:36
把字符串转成LocalDateTime
LocalDateTime ldt1 = LocalDateTime.parse("2019-09-02 17:12:36",dtf); System.out.println(ldt1);//2019-09-02T17:12:36
此外，此新特性可以得到单独的年，月（中文和英文），日（某个月的第几天，以及某年的第几天）
System.out.println(now.getYear());//2019 获取年份 System.out.println(now.getMonth());//SEPTEMBER 获取英文的月份 System.out.println(now.getMonthValue());//9 获取中文的月数 System.out.println(now.getDayOfMonth());//2 获取该时间中天数属于该时间的月中的第几天 System.out.println(now.getDayOfYear());//245 获取该时间中天数属于该时间的年中的第几天
将确定的时间以单独的年、月、日、小时等来修改来，其形式见下例：
// 修改年份 System.out.println(now); // 2019-09-02T19:30:51.234745600 LocalDateTime d2 = now.withYear(2020); System.out.println(d2); // 2020-09-02T19:30:51.234745600 //修改月份 LocalDateTime d3 = now.withMonth(11); System.out.println(d3); // 2019-11-02T19:30:51.234745600
