♀要ST♪
♀要ST♪

JDK1.8新特性

内容的介绍

  1. 了解Java发展史
  2. Lambda表达式
  3. 接口的增强
  4. 函数式接口
  5. 方法引用
  6. Stream API
  7. Optional
  8. 新时间日期API
  9. 其他新特性

一、Java发展历史

1. Java的发展历史

Sun公司在1991年成立了一个称为绿色计划( Green Project )的项目，由James Gosling(高斯林)博
土领导，绿色计划
的目的是开发一种能够在各种消费性电子产品(机顶盒、冰箱、收音机等)上运行的程序架构。这个项目的
产品就是
Java语言的前身: Oak(橡树)。Oak当时在消费品市场上并不算成功，但随着1995年互联网潮流的兴起，Oak迅速找到了最适合自己发展的市场定位。

  • JDK Beta - 1995
  • JDK 1.0 - 1996年1月 (真正第一个稳定的版本JDK 1.0.2，被称作 Java 1 )
  • JDK 1.1 - 1997年2月
  • J2SE 1.2 - 1998年12月
  • J2ME（Java 2 Micro Edition，Java 2平台的微型版），应用于移动、无线及有限资源的环境。
  • J2SE（Java 2 Standard Edition，Java 2平台的标准版），应用于桌面环境。
  • J2EE（Java 2 Enterprise Edition，Java 2平台的企业版），应用于基于Java的应用服务器。
  • J2SE 1.3 - 2000年5月
  • J2SE 1.4 - 2002年2月
  • J2SE 5.0 - 2004年9月
  • Java SE 6 - 2006年12月
  • Java SE 7 - 2011年7月
  • Java SE 8（LTS） - 2014年3月
  • Java SE 9 - 2017年9月
  • Java SE 10（18.3） - 2018年3月
  • Java SE 11（18.9 LTS） - 2018年9月
  • Java SE 12（19.3） - 2019年3月
  • Java SE 13（19.9) - 2019年9月
  • Java SE 14（20.3) - 2020年3月
  • Java SE 15（20.9) - 2020年9月
    我们可以看到Java SE的主要版本大约每两年发布一次，直到Java SE 6到Java SE 7开始花了五年时间，之后又花了三年时间到达Java SE 8。

2.OpenJDK和OracleJDK

2.1 Open JDK来源
Java 由 Sun 公司发明，Open JDK是Sun在2006年末把Java开源而形成的项目。也就是说Open JDK

是Java SE平台版的开源和免费实现，它由 SUN 和 Java 社区提供支持，2009年 Oracle 收购了 Sun 公司，自此 Java 的维护方之一的
SUN 也变成了 Oracle。

2.2 Open JDK 和 Oracle JDK的关系
大多数 JDK 都是在 Open JDK 的基础上进一步编写实现的，比如 IBM J9, Oracle JDK 和 Azul Zulu,

Azul Zing。
Oracle JDK完全由 Oracle 公司开发，Oracle JDK是基于Open JDK源代码的商业版本。此外，它包含闭源组件。
Oracle JDK根据二进制代码许可协议获得许可，在没有商业许可的情况下，在2019年1月之后发布的
Oracle Java SE 8的公开更新将无法用于商业或生产用途。但是 Open JDK是完全开源的，可以自由使用。
JDK1.8新特性_第1张图片

2.3 Open JDK 官网介绍

Open JDK 官网： http://openjdk.java.net/ 。 JDK Enhancement Proposals(JDK增强建议)。通俗的讲JEP就是JDK的新特性
小结：
Oracle JDK是基于Open JDK源代码的商业版本。我们要学习Java新技术可以去Open JDK 官网学习。

二、Lambda表达式

1. 需求分析

  • 创建一个新的线程，指定线程要执行的任务
    public static void main(String[] args) {
        // 开启一个新的线程
        new Thread(new Runnable() {
            @Override
            public void run() {                
                System.out.println("新线程中执行的代码 : " + Thread.currentThread().getName());
            }
        }).start();

        System.out.println("主线程中的代码：" + Thread.currentThread().getName());
    }

代码分析：

  1. Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
  2. 为了指定run方法体，不得不需要Runnable的实现类
  3. 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
  4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错
  5. 而实际上，我们只在乎方法体中的代码

2.Lambda表达式初体验

  • Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码
 new Thread(() -> {
      System.out.println("新线程中Lambada : " + Thread.currentThread().getName());
  }).start();
  • Lambda表达式的优点：简化了匿名内部类的使用，语法更加简单。
  • 匿名内部类语法冗余，体验了Lambda表达式后，发现Lambda表达式是简化匿名内部类的一种方式。

3. Lambda的语法规则

  • Lambda省去了面向对象的条条框框，Lambda的标准格式由3个部分组成：
(参数类型 参数名称) -> { 
	代码体; 
}

格式说明：

  • (参数类型 参数名称):参数列表
  • {代码体;} :方法体
  • -> : 箭头，分割参数列表和方法体
3.1 Lambda练习1
  1. 练习无参无返回值的Lambda
    定义一个接口
public interface UserService {
    void show();
}
  1. 然后创建主方法使用
public class Demo01Lambada2 {

    public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
                System.out.println("show 方法执行了");
            }
        });
        System.out.println("----------------------");

        goShow(() -> {
            System.out.println("Lambada show 方法执行了");
        });
    }
    
    public static void goShow(UserService userService) {

        userService.show();
    }
}

输出：
JDK1.8新特性_第2张图片

3.2 Lambda练习2
  • 完成一个有参且有返回值得Lambda表达式案例
  1. 创建一个Person对象
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {

    private String name;

    private  Integer age;

    private Integer height;

}

然后我们在List集合中保存多个Person对象，然后对这些对象做根据age排序操作

public class Demo03Lambada {

    public static void main(String[] args) {

        List<Person> list = new ArrayList<>();
        list.add(new Person("周杰伦", 33, 175));
        list.add(new Person("刘德华", 43, 185));
        list.add(new Person("刘德华2", 43, 1285));
        list.add(new Person("周星驰", 43, 177));
        list.add(new Person("郭富城", 23, 170));
        
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                int a = o1.getAge() - o2.getAge();
                return a == 0 ? o1.getHeight() - o2.getHeight():o1.getAge() - o2.getAge();
            }
        });
        for (Person person : list) {
            System.out.println(person);
        }
    }
}

我们发现在sort方法的第二个参数是一个Comparator接口的匿名内部类，且执行的方法有参数和返回
值，那么我们可以改写为Lambda表达式

public class Demo03Lambada {

    public static void main(String[] args) {

        List<Person> list = new ArrayList<>();
        list.add(new Person("周杰伦", 33, 175));
        list.add(new Person("刘德华", 43, 185));
        list.add(new Person("刘德华2", 43, 1285));
        list.add(new Person("周星驰", 43, 177));
        list.add(new Person("郭富城", 23, 170));

        Collections.sort(list,(Person o1, Person o2 ) -> {
            return o1.getAge() - o2.getAge();
        });

        for (Person person : list) {
            System.out.println(person);
        }
    }
}
3.2 @FunctionalInterface注解
// 这是一个标志注解，被该注解修饰的接口只能声明一个抽象方法
@FunctionalInterface
public interface UserService {
    void show();
}
3.3 Lambda表达式的原理
  • 匿名内部类的本质是在编译时生成一个Class 文件。XXXXX$1.class
public class Demo01Lambada {

    public static void main(String[] args) {
        // 开启一个新的线程
        new Thread(new Runnable() {
            @Override
            public void run() {

                System.out.println("新线程中执行的代码 : " + Thread.currentThread().getName());
            }
        }).start();

        System.out.println("主线程中的代码：" + Thread.currentThread().getName());

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

        new Thread(() -> {
            System.out.println("新线程中Lambada : " + Thread.currentThread().getName());
        }).start();*/
    }
}

JDK1.8新特性_第3张图片

还可以通过反编译工具来查看生成的代码 XJad 工具来查看

    static class Demo01Lambda$1 implements Runnable {
        public void run() {
            System.out.println((new StringBuilder()).append("新线程中执行的代码 : ").append(Thread.currentThread().getName()).toString());
        }

        Demo01Lambda$1() {
        }
    }
  • 那么Lambda表达式的原理是什么呢？我们也通过反编译工具来查看

JDK1.8新特性_第4张图片

写的有Lambda表达式的class文件，我们通过XJad查看报错。这时我们可以通过JDK自带的一个工具：
javap 对字节码进行反汇编操作。

javap -c -p 文件名.class 
-c:表示对代码进行反汇编 
-p:显示所有的类和成员

反汇编的结果：

public class com.jose.jdk.lambada.Demo02Lambada {
  public com.jose.jdk.lambada.Demo02Lambada();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class com/jose/jdk/lambada/Demo02Lambada$1
       3: dup
       4: invokespecial #3                  // Method com/jose/jdk/lambada/Demo02Lambada$1."":()V
       7: invokestatic  #4                  // Method goShow:(Lcom/jose/jdk/lambada/service/UserService;)V
      10: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      13: ldc           #6                  // String ----------------------
      15: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      18: invokedynamic #8,  0              // InvokeDynamic #0:show:()Lcom/jose/jdk/lambada/service/UserService;
      23: invokestatic  #4                  // Method goShow:(Lcom/jose/jdk/lambada/service/UserService;)V
      26: return

  public static void goShow(com.jose.jdk.lambada.service.UserService);
    Code:
       0: aload_0
       1: invokeinterface #9,  1            // InterfaceMethod com/jose/jdk/lambada/service/UserService.show:()V
       6: return

  private static void lambda$main$0();
    Code:
       0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #10                 // String Lambada show 方法执行了
       5: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

在这个反编译的源码中我们看到了一个静态方法 lambda$main$0()，这个方法里面做了什么事情呢？我
们通过debug的方式来查看下：

JDK1.8新特性_第5张图片
上面的效果可以理解为如下：

 public static void main(String[] args) {
        goShow(() -> {
            System.out.println("Lambada show 方法执行了");
        });
    }
    public static void goShow(UserService userService) {

        userService.show();
    }

为了更加直观的理解这个内容，我们可以在运行的时候添加 -
Djdk.internal.lambda.dumpProxyClasses, 加上这个参数会将内部class码输出到一个文件中

java -Djdk.internal.lambda.dumpProxyClasses 要运行的包名.类名

命令执行

jose@192 classes % java -Djdk.internal.lambda.dumpProxyClasses com.jose.jdk.lambada.Demo02Lambada
show 方法执行了
----------------------
Lambada show 方法执行了

JDK1.8新特性_第6张图片
反编译后的内容：
JDK1.8新特性_第7张图片

可以看到这个匿名的内部类实现了UserService接口，并重写了show()方法。在show方法中调用了
Demo03Lambda.lambda$main$0(),也就是调用了Lambda中的内容。

 public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
               Demo02Lambda.lambda$main$0();
            }
        });

    }

    public static void goShow(UserService userService) {
        userService.show();
    }

小结：
匿名内部类在编译的时候会产生一个class文件。
Lambda表达式在程序运行的时候会形成一个类。

  1. 在类中新增了一个方法，这个方法的方法体就是Lambda表达式中的代码
  2. 还会形成一个匿名内部类，实现接口，重写抽象方法
  3. 在接口中重写方法会调用新生成的方法

4.Lambda表达式的省略写法

在lambda表达式的标准写法基础上，可以使用省略写法的规则为：

  1. 小括号内的参数类型可以省略
  2. 如果小括号内有且仅有一个参数，则小括号可以省略
  3. 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。
public class Demo04Lambada {

    public static void main(String[] args) {
        goStudent((String name, Integer age) -> {
            return name + age + "666...";
        });

        //   省略写法
        goStudent((name, age) -> name + age + "666...");

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

        goOrder((String name) -> {
            return 6666;
        });

        //   省略写法
        goOrder(name -> 666);

    }

    public static void goStudent(StudentService studentService) {
        studentService.show("张三", 22);
    }

    public static void goOrder(OrderService orderService) {
        orderService.show("李四");
    }
}

5.Lambda表达式的使用前提

Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注
意

  1. 方法的参数或局部变量类型必须为接口才能使用Lambda
  2. 接口中有且仅有一个抽象方法(@FunctionalInterface)
6.Lambda和匿名内部类的对比

Lambda和匿名内部类的对比

  1. 所需类型不一样

    匿名内部类的类型可以是 类，抽象类，接口Lambda表达式需要的类型必须是接口

  2. 抽象方法的数量不一样

    匿名内部类所需的接口中的抽象方法的数量是随意的Lambda表达式所需的接口中只能有一个抽象方法

  3. 实现原理不一样

    匿名内部类是在编译后形成一个classLambda表达式是在程序运行的时候动态生成class

三、接口中新增的方法

1. JDK8中接口的新增

在JDK8中针对接口有做增强，在JDK8之前

interface 接口名{
	 静态常量; 
	 抽象方法;
 }

JDK8之后对接口做了增加，接口中可以有默认方法和静态方法

interface 接口名{ 
静态常量; 
	抽象方法; 
	默认方法;
	静态方法; 
}

2.默认方法

2.1 为什么要增加默认方法

在JDK8以前接口中只能有抽象方法和静态常量，会存在以下的问题：
如果接口中新增抽象方法，那么实现类都必须要抽象这个抽象方法，非常不利于接口的扩展的

public class Demo01Interface {
    public static void main(String[] args) {
        A a = new B();
        A c = new C();
    }
}

interface A {
    void test1();

    // 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展
    void test2();
}

class B implements A {

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

class C implements A {

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}
2.2 接口默认方法的格式

接口中默认方法的语法格式是

interface 接口名{ 
	修饰符 default 返回值类型 方法名{ 
		方法体;
 }
 }

public class Demo01Interface {
    public static void main(String[] args) {
        A a = new B();
        a.test3();
        A c = new C();
        c.test3();
    }
}

interface A {
    void test1();

    // 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展
    void test2();

    // 接口中定义的默认方法
    public default String test3() {
        System.out.println("接口中的默认方法执行了...");
        return "hello";
    }
}

class B implements A {

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

class C implements A {

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }

    @Override
    public String test3() {
        System.out.println("B 实现类中重写了默认方法...");
        return "ok ...";
    }
}
2.3 接口中默认方法的使用

接口中的默认方法有两种使用方式

  1. 实现类直接调用接口的默认方法
  2. 实现类重写接口的默认方法

3. 静态方法

JDK8中为接口新增了静态方法，作用也是为了接口的扩展

3.1 语法规则
interface 接口名{ 
	修饰符 static 返回值类型 方法名{
 		方法体; 
 } 
 }

public class Demo01Interface {
    public static void main(String[] args) {
        A a = new B();
        a.test3();
        A c = new C();
        c.test3();
        A.test4();
    }
}

interface A {
    void test1();

    // 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展
    void test2();

    // 接口中定义的默认方法
    public default String test3() {
        System.out.println("接口中的默认方法执行了...");
        return "hello";
    }

    // 接口中的静态方法
    public static String test4() {
        System.out.println("接口中的静态方法....");
        return "Hello";
    }
}

class B implements A {

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

class C implements A {

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }

    @Override
    public String test3() {
        System.out.println("B 实现类中重写了默认方法...");
        return "ok ...";
    }
}
3.2 静态方法的使用

接口中的静态方法在实现类中是不能被重写的，调用的话只能通过接口类型来实现: 接口名.静态方法名
();

JDK1.8新特性_第8张图片

4. 两者的区别介绍

  1. 默认方法通过实例调用，静态方法通过接口名调用
  2. 默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法
  3. 静态方法不能被继承，实现类不能重写接口的静态方法，只能使用接口名调用

四、函数式接口

1. 函数式接口的由来

我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，
抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方
法，在JDK中提供了大量常用的函数式接口

public class Demo01Fun {

    public static void main(String[] args) {
        fun1((arr) -> {
            int sum = 0;
            for (int i : arr) {
                sum += i;
            }
            return sum;
        });
    }

    public static void fun1(Operator operator) {
        int[] arr = {1, 2, 3, 4};
        int sum = operator.getSum(arr);
        System.out.println("sum = " + sum);
    }
}

// 函数式接口
@FunctionalInterface
interface Operator {
    int getSum(int[] arr);
}

2. 函数式接口介绍

在JDK中帮我们提供的有函数式接口，主要是在 java.util.function 包中。

2.1 Supplier

无参有返回值的接口，对于的Lambda表达式需要提供一个返回数据的类型。

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

使用：

public class SupplierTest {

    public static void main(String[] args) {
        fun1(() -> {
            int arr[] = {22, 33, 55, 66, 44, 99, 10};
            // 计算出数组中的最大值
            Arrays.sort(arr);
            return arr[arr.length - 1];
        });
    }

    private static void fun1(Supplier<Integer> supplier) {
        // get() 是一个无参的有返回值的 抽象方法
        Integer max = supplier.get();
        System.out.println("max = " + max);
    }
}
2.2 Consumer

有参无返回值得接口,前面介绍的Supplier接口是用

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

使用：将输入的数据统一转换为小写输出

public class ConsumerTest {

    public static void main(String[] args) {
        test(msg -> {
            System.out.println(msg + "-> 转换为小写：" + msg.toLowerCase());
        });
    }

    public static void test(Consumer<String> consumer) {
        consumer.accept("Hello World");
    }
}

默认方法:andThen
如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时候，
首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法
andThen方法

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> {
            accept(t);
            after.accept(t);
        };
    }

具体的操作

public class ConsumerAndThenTest {

    public static void main(String[] args) {
        test2(msg1 -> {
            System.out.println(msg1 + "-> 转换为小写：" + msg1.toLowerCase());
        }, msg2 -> {
            System.out.println(msg2 + "-> 转换为大写：" + msg2.toUpperCase());
        });
    }

    public static void test(Consumer<String> consumer) {
        consumer.accept("Hello World");
    }

    public static void test2(Consumer<String> c1, Consumer<String> c2) {
        String str = "Hello World";
//        c1.accept(str); // 转小写
//         c2.accept(str); // 转大写
         c1.andThen(c2).accept(str);
         c2.andThen(c1).accept(str);
    }
}
2.3 Function

有参有返回值的接口，Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

使用：传递进入一个字符串返回一个数字

public class FunctionTest {
    public static void main(String[] args) {
        test(msg -> {
            return Integer.parseInt(msg);
        });
    }

    public static void test(Function<String, Integer> function) {
        Integer apply = function.apply("666");
        System.out.println("apply = " + apply);
    }
}

默认方法：andThen，也是用来进行组合操作，

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

public class FunctionAndThenTest {
    public static void main(String[] args) {
        test(msg -> {
            return Integer.parseInt(msg);
        }, msg2 -> {
            return msg2 * 10;
        });
    }

    public static void test(Function<String, Integer> f1, Function<Integer, Integer> f2) { /*Integer i1 = f1.apply("666"); Integer i2 = f2.apply(i1);*/
        Integer i2 = f1.andThen(f2).apply("666");
        System.out.println("i2:" + i2);
    }
}

默认的compose方法的作用顺序和andThen方法刚好相反
而静态方法identity则是，输入什么参数就返回什么参数

2.4 Predicate

有参且返回值为Boolean的接口

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

使用：

public class PredicateTest {

    public static void main(String[] args) {
        test(msg -> {
            return msg.length() > 3;
        }, "HelloWorld");
    }

    private static void test(Predicate<String> predicate, String msg) {
        boolean b = predicate.test(msg);
        System.out.println("b:" + b);
    }
}

在Predicate中的默认方法提供了逻辑关系操作 and or negate isEquals方法

public class PredicateDefaultTest {

    public static void main(String[] args) {
        test(msg1 -> {
            return msg1.contains("H");
        }, msg2 -> {
            return msg2.contains("W");
        });
    }

    private static void test(Predicate<String> p1, Predicate<String> p2) {
        // b1 包含H b2 包含W
        // p1 包含H 同时 p2 包含W
        boolean bb1 = p1.and(p2).test("Hello");
        // p1 包含H 或者 p2 包含W
        boolean bb2 = p1.or(p2).test("Hello");
        // p1 不包含H
        boolean bb3 = p1.negate().test("Hello");
        System.out.println(bb1); // FALSE
        System.out.println(bb2); // TRUE
        System.out.println(bb3); // FALSE
    }
}

五、方法引用

1. 为什么要用方法引用

1.1 lambda表达式冗余

在使用Lambda表达式的时候，也会出现代码冗余的情况，比如：用Lambda表达式求一个数组的和

public class FunctionRefTest01 {
    public static void main(String[] args) {
        printMax(a -> {
            // Lambda表达式中的代码和 getTotal中的代码冗余了
            int sum = 0;
            for (int i : a) {
                sum += i;
            }
            System.out.println("数组之和：" + sum);
        });
    }

    //求数组中的所有元素的和
    public void getTotal(int a[]) {
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        System.out.println("数组之和：" + sum);
    }

    private static void printMax(Consumer<int[]> consumer) {
        int[] a = {10, 20, 30, 40, 50, 60};
        consumer.accept(a);
    }
}
1.2 解决方案

因为在Lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一
份逻辑了，这时我们就可以“引用”重复代码

public class FunctionRefTest02 {
    public static void main(String[] args) {
        // :: 方法引用 也是JDK8中的新的语法
        printMax(FunctionRefTest02::getTotal);
    }

    // 求数组中的所有元素的和
    public static void getTotal(int a[]) {
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        System.out.println("数组之和：" + sum);
    }

    private static void printMax(Consumer<int[]> consumer) {
        int[] a = {10, 20, 30, 40, 50, 60};
        consumer.accept(a);
    }
}

:: 方法引用 也是JDK8中的新的语法

2. 方法引用的格式

符号表示： ::
符号说明：双冒号为方法引用运算符，而它所在的表达式被称为 方法引用
应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方
法引用。
常见的引用方式：
方法引用在JDK8中使用是相当灵活的，有以下几种形式：

  1. instanceName::methodName 对象::方法名
  2. ClassName::staticMethodName 类名::静态方法
  3. ClassName::methodName 类名::普通方法
  4. ClassName::new 类名::new 调用的构造器
  5. TypeName[]::new String[]::new 调用数组的构造器
2.1 对象名::方法名

这是最常见的一种用法。如果一个类中的已经存在了一个成员方法，则可以通过对象名引用成员方法

    public static void main(String[] args) {
        Date now = new Date();

        // Supplier-无参有返回值的接口
        Supplier<Long> supplier1 = new Supplier<Long>() {
            @Override
            public Long get() {
                return now.getTime();
            }
        };
        Supplier<Long> supplier2 = () -> now.getTime();

        System.out.println(supplier1.get());
        System.out.println(supplier2.get());

        // 然后我们通过 方法引用 的方式来处理
        Supplier<Long> supplier3 = now::getTime;
        System.out.println(supplier3.get());
    }

方法引用的注意事项：

  1. 被引用的方法，参数要和接口中的抽象方法的参数一样
  2. 当接口抽象方法有返回值时，被引用的方法也必须有返回值
2.2 类名::静态方法名

也是比较常用的方式：

    public static void main(String[] args) {
        Supplier<Long> supplier1 = () -> {
            return System.currentTimeMillis();
        };
        System.out.println(supplier1.get());
        // 通过 方法引用 来实现
        Supplier<Long> supplier2 = System::currentTimeMillis;
        System.out.println(supplier2.get());
    }
2.3 类名::引用实例方法

Java面向对象中，类名只能调用静态方法，类名引用实例方法是用前提的，实际上是拿第一个参数作
为方法的调用者

    public static void main(String[] args) {

        //  Function 有参有返回值
        Function<String, Integer> function = (s) -> s.length();
        System.out.println(function.apply("hello"));

        // 通过方法引用来实现
        Function<String, Integer> function1 = String::length;
        System.out.println(function1.apply("hahahaha"));

        BiFunction<String, Integer, String> function2 = String::substring;
        String msg = function2.apply("HelloWorld", 3);
        System.out.println(msg);
    }
2.4 类名::构造器

由于构造器的名称和类名完全一致，所以构造器引用使用 ::new 的格式使用，

    public static void main(String[] args) {
        Supplier<Person> sup = () -> {
            return new Person();
        };
        System.out.println(sup.get());
        // 然后通过 方法引用来实现
        Supplier<Person> sup1 = Person::new;
        System.out.println(sup1.get());
        BiFunction<String, Integer, Person> function = Person::new;
        System.out.println(function.apply("张三", 22));
    }
2.5 数组::构造器

数组是怎么构造出来的呢？

    public static void main(String[] args) {
        Function<Integer, String[]> fun1 = (len) -> {
            return new String[len];
        };
        String[] a1 = fun1.apply(3);
        System.out.println("数组的长度是：" + a1.length);
        
        // 方法引用 的方式来调用数组的构造器
        Function<Integer, String[]> fun2 = String[]::new;
        String[] a2 = fun2.apply(5);
        System.out.println("数组的长度是：" + a2.length);
    }

小结：方法引用是对Lambda表达式符合特定情况下的一种缩写方式，它使得我们的Lambda表达式更加
的精简，也可以理解为lambda表达式的缩写形式，不过要注意的是方法引用只能引用已经存在的方法。

六、Stream API

1.集合处理数据的弊端

当我们在需要对集合中的元素进行操作的时候，除了必需的添加，删除，获取外，最典型的操作就是
集合遍历，

    public static void main(String[] args) {
        // 定义一个List集合
        List<String> list = Arrays.asList("张三", "张三丰", "成龙", "周星驰");

        // 1.获取所有 姓张的信息
        List<String> list1 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
                list1.add(s);
            }
        }

        // 2.获取名称长度为3的用户
        List<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if (s.length() == 3) {
                list2.add(s);
            }
        }

        // 3. 输出所有的用户信息
        for (String s : list2) {
            System.out.println(s);
        }
    }

上面的代码针对与我们不同的需求总是一次次的循环循环循环.这时我们希望有更加高效的处理方式，这
时我们就可以通过JDK8中提供的Stream API来解决这个问题了。

Stream更加优雅的解决方案：

    public static void main(String[] args) { // 定义一个List集合
        List<String> list = Arrays.asList("张三", "张三丰", "成龙", "周星驰");
        // 1.获取所有 姓张的信息
        // 2.获取名称长度为3的用户
        // 3. 输出所有的用户信息
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> {
            System.out.println(s);
        });
        System.out.println("----------");

        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
	}

2. Steam流式思想概述

注意：Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！
Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数
据进行加工处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商
品。
JDK1.8新特性_第9张图片

3. Stream流的获取方式

3.1 根据Collection获取

首先，java.util.Collection 接口中加入了default方法 stream，也就是说Collection接口下的所有的实
现都可以通过steam方法来获取Stream流

    public static void main(String[] args) { // 定义一个List集合
        List<String> list = new ArrayList<>();
        list.stream();
        Set<String> set = new HashSet<>();
        set.stream();
        Vector vector = new Vector();
        vector.stream();
    }

但是Map接口别没有实现Collection接口，那这时怎么办呢？这时我们可以根据Map获取对应的key
value的集合

    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        Stream<String> stream = map.keySet().stream(); // key
        Stream<Object> stream1 = map.values().stream(); // value
        Stream<Map.Entry<String, Object>> stream2 = map.entrySet().stream(); // entry
    }
3.2 通过Stream的of方法

在实际开发中我们不可避免的还是会操作到数组中的数据，由于数组对象不可能添加默认方法，所
以Stream接口中提供了静态方法of

    public static void main(String[] args) {

        Stream<String> a1 = Stream.of("a1", "a2", "a3");
        String[] arr1 = {"aa", "bb", "cc"};
        Stream<String> arr11 = Stream.of(arr1);
        Integer[] arr2 = {1, 2, 3, 4};
        Stream<Integer> arr21 = Stream.of(arr2);
        arr21.forEach(System.out::println);
        // 注意：基本数据类型的数组是不行的
        int[] arr3 = {1, 2, 3, 4};
        Stream.of(arr3).forEach(System.out::println);
    }

4.Stream常用方法介绍

Stream常用方法
Stream流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

方法名 方法作用 返回值类型 方法种类
count 统计个数 long 终结
forEach 逐一处理 void 终结
filter 过滤 Stream 函数拼接
limit 取用前几个 Stream 函数拼接
skip 跳过前几个 Stream 函数拼接
map 映射 Stream 函数拼接
concat 组合 Stream 函数拼接

终结方法：返回值类型不再是 Stream 类型的方法，不再支持链式调用。本小节中，终结方法包括count 和forEach 方法。
非终结方法：返回值类型仍然是 Stream 类型的方法，支持链式调用。（除了终结方法外，其余方法均为非终结方法。）
Stream注意事项(重要)

  1. Stream只能操作一次
  2. Stream方法返回的是新的流
  3. Stream不调用终结方法，中间的操作不会执行
4.1 forEach

forEach用来遍历流中的数据的

void forEach(Consumer<? super T> action);

该方法接受一个Consumer接口，会将每一个流元素交给函数处理

    public static void main(String[] args) {
        Stream.of("a1", "a2", "a3").forEach(System.out::println);
    }
4.2 count

Stream流中的count方法用来统计其中的元素个数的

long count();

该方法返回一个long值，代表元素的个数。

    public static void main(String[] args) {
        long count = Stream.of("a1", "a2", "a3").count();
        System.out.println(count);
    }
4.3 filter

filter方法的作用是用来过滤数据的。返回符合条件的数据

JDK1.8新特性_第10张图片
可以通过filter方法将一个流转换成另一个子集流

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个Predicate函数式接口参数作为筛选条件

    public static void main(String[] args) {
        Stream.of("a1", "a2", "a3", "bb", "cc", "aa", "dd")
                .filter((s) -> s.contains("a"))
                .forEach(System.out::println);
    }

输出

a1
a2
a3
aa
4.4 limit

limit方法可以对流进行截取处理，支取前n个数据，
JDK1.8新特性_第11张图片

Stream<T> limit(long maxSize);

参数是一个long类型的数值，如果集合当前长度大于参数就进行截取，否则不操作：

    public static void main(String[] args) {
        Stream.of("a1", "a2", "a3", "bb", "cc", "aa", "dd")
                .limit(2)
                .forEach(System.out::println);
    }

输出

a1
a2
4.5 skip

JDK1.8新特性_第12张图片
如果希望跳过前面几个元素，可以使用skip方法获取一个截取之后的新流：

Stream<T> skip(long n);


    public static void main(String[] args) {
        Stream.of("a1", "a2", "a3", "bb", "cc", "aa", "dd")
                .skip(2)
                .forEach(System.out::println);
    }

输出

a3
bb
cc
aa
dd
4.6 map

如果我们需要将流中的元素映射到另一个流中，可以使用map方法：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

JDK1.8新特性_第13张图片
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的数据

   public static void main(String[] args) {
        Stream.of("1", "2", "3", "4", "5", "6", "7")
                //.map(msg->Integer.parseInt(msg)) 
                .map(Integer::parseInt)
                .forEach(System.out::println);
    }
4.7 sorted

如果需要将数据排序，可以使用sorted方法：

Stream<T> sorted();

在使用的时候可以根据自然规则排序，也可以通过比较强来指定对应的排序规则

    public static void main(String[] args) {
        Stream.of("1", "2", "3", "7", "5", "6", "4")
                //.map(msg->Integer.parseInt(msg))
                .map(Integer::parseInt)
//                .sorted()
                .sorted((o1,o2) -> o2 -o1)
                .forEach(System.out::println);
    }
4.8 distinct

如果要去掉重复数据，可以使用distinct方法：

Stream<T> distinct();

JDK1.8新特性_第14张图片

    public static void main(String[] args) {
        Stream.of("1", "2", "7", "7", "5", "6", "4")
                //.map(msg->Integer.parseInt(msg))
                .map(Integer::parseInt)
//                .sorted()
                .sorted((o1, o2) -> o2 - o1)
                .distinct()
                .forEach(System.out::println);

        Stream.of(new Person("张三", 18),
                        new Person("李四", 22),
                        new Person("张三", 18))
                .distinct()
                .forEach(System.out::println);
    }

输出

7
6
5
4
2
1
Person(name=张三, age=18)
Person(name=李四, age=22)

Stream流中的distinct方法对于基本数据类型是可以直接出重的，但是对于自定义类型，我们是需要重写hashCode和equals方法来移除重复元素。

4.9 match

如果需要判断数据是否匹配指定的条件，可以使用match相关的方法

boolean anyMatch(Predicate<? super T> predicate); // 元素是否有任意一个满足条件
 boolean allMatch(Predicate<? super T> predicate); // 元素是否都满足条件 
 boolean noneMatch(Predicate<? super T> predicate); // 元素是否都不满足条件

    public static void main(String[] args) {

        boolean b = Stream.of("1", "3", "3", "4", "5", "1", "7")
                .map(Integer::parseInt)
                //.allMatch(s -> s > 0)
                // .anyMatch(s -> s >4)
                .noneMatch(s -> s > 9);
        System.out.println(b); // true
    }
4.10 find

如果我们需要找到某些数据，可以使用find方法来实现

Optional<T> findFirst(); 
Optional<T> findAny();

JDK1.8新特性_第15张图片

        Optional<String> first = Stream.of("1", "3", "3", "4", "5", "1", "7").findFirst();
        System.out.println(first.get());
        Optional<String> any = Stream.of("1", "3", "3", "4", "5", "1", "7").findAny();
        System.out.println(any.get());
4.11 max和min

JDK1.8新特性_第16张图片
如果我们想要获取最大值和最小值，那么可以使用max和min方法

Optional<T> min(Comparator<? super T> comparator); 
Optional<T> max(Comparator<? super T> comparator);

    public static void main(String[] args) {
        Optional<Integer> max = Stream.of("1", "3", "3", "4", "5", "1", "7")
                .map(Integer::parseInt)
                .max((o1, o2) -> o1 - o2);
        System.out.println(max.get());
        Optional<Integer> min = Stream.of("1", "3", "3", "4", "5", "1", "7")
                .map(Integer::parseInt)
                .min((o1, o2) -> o1 - o2);
        System.out.println(min.get());
    }
4.12 reduce方法

JDK1.8新特性_第17张图片
如果需要将所有数据归纳得到一个数据，可以使用reduce方法

T reduce(T identity, BinaryOperator<T> accumulator);

    public static void main(String[] args) {
        Integer sum = Stream.of(4, 5, 3, 9)
                // identity默认值
                // 第一次的时候会将默认值赋值给x
                // 之后每次会将 上一次的操作结果赋值给x y就是每次从数据中获取的元素
                .reduce(0, (x, y) -> {
                    System.out.println("x=" + x + ",y=" + y);
                    return x + y;
                });
        System.out.println(sum);
        // 获取 最大值
        Integer max = Stream.of(4, 5, 3, 9)
                .reduce(0, (x, y) -> {
                    return x > y ? x : y;
                });
        System.out.println(max);
    }

输出

x=0,y=4
x=4,y=5
x=9,y=3
x=12,y=9
21
9
4.13 map和reduce的组合

在实际开发中我们经常会将map和reduce一块来使用

    public static void main(String[] args) {
        // 1.求出所有年龄的总和
        Integer sumAge = Stream.of(
                        new Person("张三", 18),
                        new Person("李四", 22),
                        new Person("张三", 13),
                        new Person("王五", 15),
                        new Person("张三", 19))
                // 实现数据类型的转换
                .map(Person::getAge)
                .reduce(0, Integer::sum);
        System.out.println(sumAge);
        // 2.求出所有年龄中的最大值
        Integer maxAge = Stream.of(new Person("张三", 18),
                        new Person("李四", 22),
                        new Person("张三", 13),
                        new Person("王五", 15),
                        new Person("张三", 19))
                // 实现数据类型的转换，符合reduce对数据的要
                .map(Person::getAge)
                .reduce(0, Math::max);
        // reduce实现数据的处理
        System.out.println(maxAge);
        // 3.统计 字符 a 出现的次数
        Integer count = Stream.of("a", "b", "c", "d", "a", "c", "a")
                .map(ch -> "a".equals(ch) ? 1 : 0)
                .reduce(0, Integer::sum);
        System.out.println(count);
    }
4.14 mapToInt

如果需要将Stream中的Integer类型转换成int类型，可以使用mapToInt方法来实现
JDK1.8新特性_第18张图片

    public static void main(String[] args) {
        // Integer占用的内存比int多很多，在Stream流操作中会自动装修和拆箱操作
        Integer arr[] = {1, 2, 3, 5, 6, 8};
        Stream.of(arr).filter(i -> i > 0)
                .forEach(System.out::println);
        System.out.println("---------");
        // 为了提高程序代码的效率，我们可以先将流中Integer数据转换为int数据，然后再操作
        IntStream intStream = Stream.of(arr).mapToInt(Integer::intValue);
        intStream.filter(i -> i > 3)
                .forEach(System.out::println);
    }
4.15 concat

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat

  public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
        Objects.requireNonNull(a);
        Objects.requireNonNull(b);

        @SuppressWarnings("unchecked")
        Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
                (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
        Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
        return stream.onClose(Streams.composedClose(a, b));
    }

    public static void main(String[] args) {

        Stream<String> stream1 = Stream.of("a", "b", "c");
        Stream<String> stream2 = Stream.of("x", "y", "z");
        // 通过concat方法将两个流合并为一个新的流
        Stream.concat(stream1, stream2)
                .forEach(System.out::println);

    }
4.16 综合案例

定义两个集合，然后在集合中存储多个用户名称。然后完成如下的操作：

  1. 第一个队伍只保留姓名长度为3的成员
  2. 第一个队伍筛选之后只要前3个人
  3. 第二个队伍只要姓张的成员
  4. 第二个队伍筛选之后不要前两个人
  5. 将两个队伍合并为一个队伍
  6. 根据姓名创建Person对象
  7. 打印整个队伍的Person信息
    public static void main(String[] args) {

        List<String> list1 = Arrays.asList("迪丽热巴", "宋远桥", "苏星河", "老子", "庄子", "孙子", "洪七公公");
        List<String> list2 = Arrays.asList("古力娜扎", "张无忌", "张三丰", "赵丽颖", "张二狗", "张天爱", "张三");

//        1. 第一个队伍只保留姓名长度为3的成员
        list1.stream().filter(s -> s.length() > 3)
                .forEach(System.out::println);

        System.out.println("-------------2");
//        2. 第一个队伍筛选之后只要前3个人
        list1.stream().limit(3).forEach(System.out::println);
//        3. 第二个队伍只要姓张的成员
        System.out.println("-------------3");
        list2.stream().filter(s -> s.startsWith("张"))
                .forEach(System.out::println);
//        4. 第二个队伍筛选之后不要前两个人
        System.out.println("-------------4");

        list2.stream().filter(s -> s.startsWith("张")).skip(2)
                .forEach(System.out::println);
//        5. 将两个队伍合并为一个队伍
//        6. 根据姓名创建Person对象
//        7. 打印整个队伍的Person信息
        Stream.concat(list1.stream(),list2.stream())
         .map(Person::new).forEach(System.out::println);
        
    }

5.Stream结果收集

5.1 结果收集到集合中
    public void test01() {
        // 收集到List
        List<String> list = Stream.of("aa", "bb", "cc", "aa")
                .collect(Collectors.toList());
        System.out.println(list);

        // 收集到 Set集合中
        Set<String> set = Stream.of("aa", "bb", "cc", "aa")
                .collect(Collectors.toSet());
        System.out.println(set);
        // 如果需要获取的类型为具体的实现，比如：ArrayList HashSet
        ArrayList<String> arrayList = Stream.of("aa", "bb", "cc", "aa")
//        .collect(Collectors.toCollection(() -> new ArrayList<>()));
                .collect(Collectors.toCollection(ArrayList::new));
        System.out.println(arrayList);
        
        HashSet<String> hashSet = Stream.of("aa", "bb", "cc", "aa")
                .collect(Collectors.toCollection(HashSet::new));
        System.out.println(hashSet);
    }
5.2 结果收集到数组中

Stream中提供了toArray方法来将结果放到一个数组中，返回值类型是Object[],如果我们要指定返回的类型，那么可以使用另一个重载的toArray(IntFunction f)方法

    @Test
    public void test02() {
        Object[] objects = Stream.of("aa", "bb", "cc", "aa").toArray();
        // 返回的数组中的元素是 Object类型
        System.out.println(Arrays.toString(objects));
        // 如果我们需要指定返回的数组中的元素类型
        String[] strings = Stream.of("aa", "bb", "cc", "aa")
                .toArray(String[]::new);
        System.out.println(Arrays.toString(strings));
    }
5.3 对流中的数据做聚合计算

当我们使用Stream流处理数据后，可以像数据库的聚合函数一样对某个字段进行操作，比如获得最大值，最小值，求和，平均值，统计数量。

    public void test03() {
        // 获取年龄的最大值
         Optional<Person> maxAge = Stream.of(
                        new Person("张三", 18),
                        new Person("李四", 22),
                        new Person("张三", 13),
                        new Person("王五", 15),
                        new Person("张三", 19))
                .collect(Collectors.maxBy((p1, p2) -> p1.getAge() - p2.getAge()));
        System.out.println("最大年龄：" + maxAge.get());
        // 获取年龄的最小值
        Optional<Person> minAge = Stream.of(new Person("张三", 18),
                        new Person("李四", 22),
                        new Person("张三", 13),
                        new Person("王五", 15),
                        new Person("张三", 19))
                .collect(Collectors.minBy((p1, p2) -> p1.getAge() - p2.getAge()));
        System.out.println("最新年龄:" + minAge.get());
        // 求所有人的年龄之和
        Integer sumAge = Stream.of(
                        new Person("张三", 18),
                        new Person("李四", 22),
                        new Person("张三", 13),
                        new Person("王五", 15),
                        new Person("张三", 19))
                //.collect(Collectors.summingInt(s -> s.getAge()))
                .collect(Collectors.summingInt(Person::getAge));
        System.out.println("年龄总和：" + sumAge);
        // 年龄的平均值
        Double avgAge = Stream.of(new Person("张三", 18),
                new Person("李四", 22), new Person("张三", 13), new Person("王五", 15), new Person("张三", 19)).collect(Collectors.averagingInt(Person::getAge));
        System.out.println("年龄的平均值：" + avgAge);
        // 统计数量
        Long count = Stream.of(
                        new Person("张三", 18),
                        new Person("李四", 22),
                        new Person("张三", 13),
                        new Person("王五", 15),
                        new Person("张三", 19)).
                filter(p -> p.getAge() > 18)
                .collect(Collectors.counting());
        System.out.println("满足条件的记录数:" + count);
 }
5.4 对流中数据做分组操作

当我们使用Stream流处理数据后，可以根据某个属性将数据分组

    public void test04() {
        // 根据账号对数据进行分组
        Map<String, List<Person>> map1 = Stream.of(
                new Person("张三", 18, 175),
                new Person("李四", 22, 177),
                new Person("张三", 14, 165),
                new Person("李四", 15, 166),
                new Person("张三", 19, 182))
                .collect(Collectors
                        .groupingBy(Person::getName));

        map1.forEach((k, v) ->
                System.out.println("k=" + k + "\t" + "v=" + v));

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

        // 根据年龄分组 如果大于等于18 成年否则未成年
        Map<String, List<Person>> map2 = Stream.of(
                new Person("张三", 18, 175),
                new Person("李四", 22, 177),
                new Person("张三", 14, 165),
                new Person("李四", 15, 166),
                new Person("张三", 19, 182))
                .collect(Collectors.groupingBy(p -> p.getAge() >= 18 ? "成年" : "未成 年"));

        map2.forEach((k, v) -> System.out.println("k=" + k + "\t" + "v=" + v));
    }

多级分组: 先根据name分组然后根据年龄分组

    public void test05() {
        // 先根据name分组，然后根据age(成年和未成年)分组
        Map<String, Map<Object, List<Person>>> map = Stream.of(
                        new Person("张三", 18, 175),
                        new Person("李四", 22, 177),
                         new Person("李四", 12, 137),
                        new Person("张三", 14, 165),
                        new Person("李四", 15, 166),
                        new Person("张三", 19, 182)).
                collect(Collectors.groupingBy(Person::getName,
                        Collectors.groupingBy(p -> p.getAge() >= 18 ? "成年" : "未成年")));
        map.forEach((k, v) -> {
            System.out.println(k);
            v.forEach((k1, v1) -> {
                System.out.println("\t" + k1 + "=" + v1);
            });
        });
    }

输出

李四
	未成年=[Person(name=李四, age=12, height=137), Person(name=李四, age=15, height=166)]
	成年=[Person(name=李四, age=22, height=177)]
张三
	未成年=[Person(name=张三, age=14, height=165)]
	成年=[Person(name=张三, age=18, height=175), Person(name=张三, age=19, height=182)]
5.5 对流中的数据做分区操作

Collectors.partitioningBy会根据值是否为true,把集合中的数据分割为两个列表，一个true列表，一个false列表

JDK1.8新特性_第19张图片

    /*** 分区操作 */
    @Test
    public void test06() {
        Map<Boolean, List<Person>> map = Stream.of(
                        new Person("张三", 18, 175),
                        new Person("李四", 22, 177),
                        new Person("张三", 14, 165),
                        new Person("李四", 15, 166),
                        new Person("张三", 19, 182))
                .collect(Collectors.partitioningBy(p -> p.getAge() > 18));
        map.forEach((k, v) -> System.out.println(k + "\t" + v));

输出结果：

false	[Person(name=张三, age=18, height=175), Person(name=张三, age=14, height=165), Person(name=李四, age=15, height=166)]
true	[Person(name=李四, age=22, height=177), Person(name=张三, age=19, height=182)]
5.6 对流中的数据做拼接

Collectors.joining会根据指定的连接符，将所有的元素连接成一个字符串

    public void test07() {
        String s1 = Stream.of(new Person("张三", 18, 175), new Person("李四", 22, 177), new Person("张三", 14, 165), new Person("李四", 15, 166), new Person("张三", 19, 182)).map(Person::getName).collect(Collectors.joining());
        // 张三李四张三李四张三
        System.out.println(s1);
        String s2 = Stream.of(
                        new Person("张三", 18, 175),
                        new Person("李四", 22, 177),
                        new Person("张三", 14, 165),
                        new Person("李四", 15, 166),
                        new Person("张三", 19, 182))
                .map(Person::getName)
                .collect(Collectors.joining("_"));
        // 张三_李四_张三_李四_张三
        System.out.println(s2);
        String s3 = Stream.of(
                        new Person("张三", 18, 175),
                        new Person("李四", 22, 177),
                        new Person("张三", 14, 165),
                        new Person("李四", 15, 166),
                        new Person("张三", 19, 182))
                .map(Person::getName).collect(Collectors
                        .joining("_", "###", "$$$"));
        // ###张三_李四_张三_李四_张三$$$
        System.out.println(s3);
    }
6. 并行的Stream流
6.1 串行的Stream流

我们前面使用的Stream流都是串行，也就是在一个线程上面执行。

    public void test08() {
        Stream.of(5, 6, 8, 3, 1, 6).filter(s -> {
            System.out.println(Thread.currentThread() + "" + s);
            return s > 3;
        }).count();
    }

输出:

Thread[main,5,main]5
Thread[main,5,main]6
Thread[main,5,main]8
Thread[main,5,main]3
Thread[main,5,main]1
Thread[main,5,main]6
6.2 并行流

parallelStream其实就是一个并行执行的流，它通过默认的ForkJoinPool，可以提高多线程任务的速度。
6.2.1 获取并行流
我们可以通过两种方式来获取并行流。

  1. 通过List接口中的parallelStream方法来获取
  2. 通过已有的串行流转换为并行流(parallel)

6.2.2 并行流操作

    @Test
    public void test10() {
        Stream.of(1, 4, 2, 6, 1, 5, 9).parallel()
                // 将流转换为并发流，Stream处理的时候就会通过多线程处理
                .filter(s -> {
                    System.out.println(Thread.currentThread() + " s=" + s);
                    return s > 2;
                }).count();
    }

输出

Thread[ForkJoinPool.commonPool-worker-9,5,main] s=5
Thread[ForkJoinPool.commonPool-worker-11,5,main] s=1
Thread[ForkJoinPool.commonPool-worker-5,5,main] s=4
Thread[ForkJoinPool.commonPool-worker-3,5,main] s=9
Thread[ForkJoinPool.commonPool-worker-15,5,main] s=2
Thread[main,5,main] s=1
Thread[ForkJoinPool.commonPool-worker-7,5,main] s=6
6.3 并行流和串行流对比

我们通过for循环，串行Stream流，并行Stream流来对500000000亿个数字求和。来看消耗时间

public class Test03 {
    private static long times = 500000000;
    private long start;

    @Before
    public void befor() {
        start = System.currentTimeMillis();
    }

    @After
    public void end() {
        long end = System.currentTimeMillis();
        System.out.println("消耗时间：" + (end - start));
    }

    /*** 普通for循环 消耗时间：258 */
    @Test
    public void test01() {
        System.out.println("普通for循环:");
        long res = 0;
        for (int i = 0; i < times; i++) {
            res += i;
        }
    }

    /*** 串行流处理 * 消耗时间：200 */
    @Test
    public void test02() {
        System.out.println("串行流：serialStream");
        LongStream.rangeClosed(0, times)
                .reduce(0, Long::sum);
    }

    /*** 并行流处理 消耗时间：107 */
    @Test
    public void test03() {
        LongStream.rangeClosed(0, times).parallel()
                .reduce(0, Long::sum);
    }

}

通过案例我们可以看到parallelStream的效率是最高的。
Stream并行处理的过程会分而治之，也就是将一个大的任务切分成了多个小任务，这表示每个任务都是一个线程操作。

6.4 线程安全问题

在多线程的处理下，肯定会出现数据安全问题。如下：

    @Test
    public void test01() {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add(i);
        }
        System.out.println(list.size());
        List<Integer> listNew = new ArrayList<>();
        // 使用并行流来向集合中添加数据
        list.parallelStream()
                //.forEach(s->listNew.add(s));
                .forEach(listNew::add);
        System.out.println(listNew.size());
    }

输出

1000
934

针对这个问题，我们的解决方案有哪些呢？

  1. 加同步锁
  2. 使用线程安全的容器
  3. 通过Stream中的toArray/collect操作
    实现：
    public void test02() {
        List<Integer> listNew = new ArrayList<>();
        Object obj = new Object();
        IntStream.rangeClosed(1, 1000).parallel()
                .forEach(i -> {
                    synchronized (obj) {
                        listNew.add(i);
                    }
                });
        System.out.println(listNew.size());
    }
    /*** 将线程不安全的容器转换为线程安全的容器 */
    @Test
    public void test04() {
        List<Integer> listNew = new ArrayList<>();
        // 将线程不安全的容器包装为线程安全的容器
        List<Integer> synchronizedList = Collections.synchronizedList(listNew);
        Object obj = new Object();
        IntStream.rangeClosed(1, 1000).parallel().forEach(i -> {
            synchronizedList.add(i);
        });
        System.out.println(synchronizedList.size());
    }
    /*** 使用线程安全的容器 */
    @Test
    public void test03() {
        Vector v = new Vector();
        Object obj = new Object();
        IntStream.rangeClosed(1, 1000).parallel().forEach(i -> {
            synchronized (obj) {
                v.add(i);
            }
        });
        System.out.println(v.size());
    }
        /*** 我们还可以通过Stream中的 toArray方法或者 collect方法来操作 * 就是满足线程安全的要求 */
    @Test
    public void test05() {
        List<Integer> listNew = new ArrayList<>();
        Object obj = new Object();
        List<Integer> list = IntStream.rangeClosed(1, 1000)
                .parallel().boxed().collect(Collectors.toList());
        System.out.println(list.size());
    }

七、Optional类

这个Optional类注意是解决空指针的问题

1. 以前对null 的处理

    public void test01() {
        //String userName = "张三";
        String userName = null;
        if (userName != null) {
            System.out.println("字符串的长度：" + userName.length());
        } else {
            System.out.println("字符串为空");
        }
    }

2. Optional类

Optional是一个没有子类的工具类，Optional是一个可以为null的容器对象，它的主要作用就是为了避免Null检查，防止NullpointerException，
JDK1.8新特性_第20张图片

3. Optional的基本使用

Optional对象的创建方式

    public void test02() {
        // 第一种方式 通过of方法 of方法是不支持null的
        Optional<String> op1 = Optional.of("zhangsan");
        //Optional op2 = Optional.of(null);
        // 第二种方式通过 ofNullable方法 支持null
        Optional<String> op3 = Optional.ofNullable("lisi");
        Optional<Object> op4 = Optional.ofNullable(null);
        // 第三种方式 通过empty方法直接创建一个空的Optional对象
        Optional<Object> op5 = Optional.empty();
    }
 
  
4. Optional的常用方法
 
  
    /**
     * Optional中的常用方法介绍
     * get(): 如果Optional有值则返回，否则抛出NoSuchElementException异常
     * get()通常和isPresent方法一块使用
     * isPresent():判断是否包含值，包含值返回true，不包含值返回false
     * orElse(T t):如果调用对象包含值，就返回该值，否则返回t
     * orElseGet(Supplier s):如果调用对象包含值，就返回该值，否则返回 Lambda表达式的返 回值
     */
    @Test
    public void test03() {
        Optional<String> op1 = Optional.of("zhangsan");
        Optional<String> op2 = Optional.empty();
        // 获取Optional中的值
        if (op1.isPresent()) {
            String s1 = op1.get();
            System.out.println("用户名称:" + s1);
        }
        if (op2.isPresent()) {
            System.out.println(op2.get());
        } else {
            System.out.println("op2是一个空Optional对象");
        }
        String s3 = op1.orElse("李四");
        System.out.println(s3);
        String s4 = op2.orElse("王五");
        System.out.println(s4);
        String s5 = op2.orElseGet(() -> {
            return "Hello";
        });
        System.out.println(s5);
    }

    @Test
    public void test04() {
        Optional<String> op1 = Optional.of("zhangsan");
        Optional<String> op2 = Optional.empty();
        // 如果存在值 就做什么
        op1.ifPresent(s -> System.out.println("有值:" + s));
        op1.ifPresent(System.out::println);

    }

    /*** 自定义一个方法，将Person对象中的 name 转换为大写 并返回 */
    @Test
    public void test05() {
        Person p = new Person("zhangsan", 18);
        Optional<Person> op = Optional.of(p);
        String name = getNameForOptional(op);
        System.out.println("name=" + name);
    }

    /*** 根据Person对象 将name转换为大写并返回 * 通过Optional方式实现 * @param op * @return */
    public String getNameForOptional(Optional<Person> op) {
        if (op.isPresent()) {
            String msg = //op.map(p -> p.getName())
                    op.map(Person::getName)
                            //.map(p -> p.toUpperCase())
                            .map(String::toUpperCase).orElse("空值");
            return msg;
        }
        return null;
    }

    /*** 根据Person对象 将name转换为大写并返回 * @param person * @return */
    public String getName(Person person) {
        if (person != null) {
            String name = person.getName();
            if (name != null) {
                return name.toUpperCase();
            } else {
                return null;
            }
        } else {
            return null;
        }
    }

 
  
八、新时间日期API
 
  
1.旧版日期时间的问题
 
  
在旧版本中JDK对于日期和时间这块的时间是非常差的。
 
  
    public void test01() throws Exception {
        // 1.设计不合理
        Date date = new Date(2021, 05, 05);
        System.out.println(date);
        
        // 2.时间格式化和解析操作是线程不安全的
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for (int i = 0; i < 50; i++) {
            new Thread(() -> {
                // System.out.println(sdf.format(date));
                try {
                    System.out.println(sdf.parse("2021-05-06"));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

 
  
     
   
  1. 设计不合理，在java.util和java.sql的包中都有日期类，java.util.Date同时包含日期和时间的，而java.sql.Date仅仅包含日期，此外用于格式化和解析的类在java.text包下。
    2.  
   
  2. 非线程安全，java.util.Date是非线程安全的，所有的日期类都是可变的，这是java日期类最大的问题之一。
    3.  
   
  3. 时区处理麻烦，日期类并不提供国际化，没有时区支持。
    4.  
  
 
  
2. 新日期时间API介绍
 
  
JDK 8中增加了一套全新的日期时间API，这套API设计合理，是线程安全的。新的日期及时间API位于
 java.time 包中，下面是一些关键类。
 
  
     
   
  • LocalDate ：表示日期，包含年月日，格式为 2019-10-16
    •  
   
  • LocalTime ：表示时间，包含时分秒，格式为 16:38:54.158549300
    •  
   
  • LocalDateTime ：表示日期时间，包含年月日，时分秒，格式为 2018-09-06T15:33:56.750
    •  
   
  • DateTimeFormatter ：日期时间格式化类。
    •  
   
  • Instant：时间戳，表示一个特定的时间瞬间。
    •  
   
  • Duration：用于计算2个时间(LocalTime，时分秒)的距离
    •  
   
  • Period：用于计算2个日期(LocalDate，年月日)的距离
    •  
   
  • ZonedDateTime ：包含时区的时间
     Java中使用的历法是ISO 8601日历系统，它是世界民用历法，也就是我们所说的公历。平年有365天，闰年是366天。此外Java 8还提供了4套其他历法，分别是：
    •  
   
  • ThaiBuddhistDate：泰国佛教历
    •  
   
  • MinguoDate：中华民国历
    •  
   
  • JapaneseDate：日本历
    •  
   
  • HijrahDate：伊斯兰历
    •  
  
 
  
2.1 日期时间的常见操作
 
  
LocalDate，LocalTime以及LocalDateTime的操作。
 
  
    /*** JDK8 日期时间操作 */
    @Test
    public void test01() {
        // 1.创建指定的日期
        LocalDate date1 = LocalDate.of(2021, 05, 06);
        System.out.println("date1 = " + date1);
        // 2.得到当前的日期
        LocalDate now = LocalDate.now();
        System.out.println("now = " + now);
        // 3.根据LocalDate对象获取对应的日期信息
        System.out.println("年：" + now.getYear());
        System.out.println("月：" + now.getMonth().getValue());
        System.out.println("日：" + now.getDayOfMonth());
        System.out.println("星期：" + now.getDayOfWeek().getValue());
    }

    /*** 时间操作 */
    @Test
    public void test02() {
        // 1.得到指定的时间
        LocalTime time = LocalTime.of(5, 26, 33, 23145);
        System.out.println(time);
        // 2.获取当前的时间
        LocalTime now = LocalTime.now();
        System.out.println(now);
        // 3.获取时间信息
        System.out.println(now.getHour());
        System.out.println(now.getMinute());
        System.out.println(now.getSecond());
        System.out.println(now.getNano());
    }

    /*** 日期时间类型 LocalDateTime */
    @Test
    public void test03() {
        // 获取指定的日期时间
        LocalDateTime dateTime = LocalDateTime.of(2020, 06, 01, 12, 12, 33
                , 213);
        System.out.println(dateTime);
        // 获取当前的日期时间
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        // 获取日期时间信息
        System.out.println(now.getYear());
        System.out.println(now.getMonth().getValue());
        System.out.println(now.getDayOfMonth());
        System.out.println(now.getDayOfWeek().getValue());
        System.out.println(now.getHour());
        System.out.println(now.getMinute());
        System.out.println(now.getSecond());
        System.out.println(now.getNano());
    }

 
  
2.2 日期时间的修改和比较
 
  
    /*** 日期时间的修改 */
    @Test
    public void test01() {
        LocalDateTime now = LocalDateTime.now();
        System.out.println("now = " + now);
        // 修改日期时间 对日期时间的修改，对已存在的LocalDate对象，创建了它模板
        // 并不会修改原来的信息
        LocalDateTime localDateTime = now.withYear(1998);
        System.out.println("now :" + now);
        System.out.println("修改后的：" + localDateTime);
        System.out.println("月份：" + now.withMonth(10));
        System.out.println("天：" + now.withDayOfMonth(6));
        System.out.println("小时：" + now.withHour(8));
        System.out.println("分钟:" + now.withMinute(15));
        // 在当前日期时间的基础上 加上或者减去指定的时间
        System.out.println("两天后:" + now.plusDays(2));
        System.out.println("10年后:" + now.plusYears(10));
        System.out.println("6个月后 = " + now.plusMonths(6));
        System.out.println("10年前 = " + now.minusYears(10));
        System.out.println("半年前 = " + now.minusMonths(6));
        System.out.println("一周前 = " + now.minusDays(7));
    }

    /*** 日期时间的比较 */
    @Test
    public void test02() {
        LocalDate now = LocalDate.now();
        LocalDate date = LocalDate.of(2020, 1, 3);
        // 在JDK8中要实现 日期的比较 isAfter isBefore isEqual 通过这几个方法来直接比较
        System.out.println(now.isAfter(date)); // true
         System.out.println(now.isBefore(date)); // false
        System.out.println(now.isEqual(date)); // false
        }

 
  
注意：在进行日期时间修改的时候，原来的LocalDate对象是不会被修改，每次操作都是返回了一个新的LocalDate对象，所以在多线程场景下是数据安全的。
 
  
2.3 格式化和解析操作
 
  
在JDK8中我们可以通过 java.time.format.DateTimeFormatter 类可以进行日期的解析和格式化操作
 
  
    public void test01() {
        LocalDateTime now = LocalDateTime.now();
        // 指定格式 使用系统默认的格式 2021-05-27T16:16:38.139
        DateTimeFormatter isoLocalDateTime = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        // 将日期时间转换为字符串
        String format = now.format(isoLocalDateTime);
        System.out.println("format = " + format);
        // 通过 ofPattern 方法来指定特定的格式
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy- MM-dd HH:mm:ss");
        String format1 = now.format(dateTimeFormatter);
        // 2021-05-27 16:16:38
        System.out.println("format1 = " + format1);
        // 将字符串解析为一个 日期时间类型
        LocalDateTime parse = LocalDateTime.parse("1997-05-06 22:45:16", dateTimeFormatter);
        // parse = 1997-05-06T22:45:16
        System.out.println("parse = " + parse);
    }

 
  
2.4 Instant类
 
  
在JDK8中给我们新增一个Instant类(时间戳/时间线)，内部保存了从1970年1月1日 00:00:00以来的秒和纳秒
 
  
    /*** Instant 时间戳 * 可以用来统计时间消耗 */
    @Test
    public void test01() throws Exception {
        Instant now = Instant.now();
        System.out.println("now = " + now);
        // 获取从1970年一月一日 00:00:00 到现在的 纳秒
        System.out.println(now.getNano());
        Thread.sleep(5);
        Instant now1 = Instant.now();
        System.out.println("耗时：" + (now1.getNano() - now.getNano()));
    }

 
  
2.5 计算日期时间差
 
  
JDK8中提供了两个工具类Duration/Period：计算日期时间差
 
  
     
   
  1. Duration：用来计算两个时间差(LocalTime)
    2.  
   
  2. Period:用来计算两个日期差(LocalDate)
    3.  
  
 
  
 /*** 计算日期时间差 */
    @Test
    public void test01() {
        // 计算时间差
        LocalTime now = LocalTime.now();
        LocalTime time = LocalTime.of(22, 48, 59);
        System.out.println("now = " + now);
        // 通过Duration来计算时间差
        Duration duration = Duration.between(now, time);
        System.out.println(duration.toDays()); // 0
        System.out.println(duration.toHours()); // 7
        System.out.println(duration.toMinutes()); // 468
        System.out.println(duration.toMillis()); // 28028736
        // 计算日期差
        LocalDate nowDate = LocalDate.now();
        LocalDate date = LocalDate.of(1997, 12, 5);
        Period period = Period.between(date, nowDate);
        System.out.println(period.getYears()); // 24
        System.out.println(period.getMonths()); // 5
        System.out.println(period.getDays()); // 44 }
    }

 
  
2.6 时间校正器
 
  
有时候我们可以需要如下调整：将日期调整到"下个月的第一天"等操作。这时我们通过时间校正器效果可能会更好。
 
  
     
   
  • TemporalAdjuster:时间校正器
    •  
   
  • TemporalAdjusters:通过该类静态方法提供了大量的常用TemporalAdjuster的实现。
    •  
  
 
  
    /*** 时间校正器 */
    @Test
    public void test01() {
        LocalDateTime now = LocalDateTime.now();
        // 将当前的日期调整到下个月的一号
        TemporalAdjuster adJuster = (temporal) -> {
            LocalDateTime dateTime = (LocalDateTime) temporal;
            LocalDateTime nextMonth = dateTime.plusMonths(1).withDayOfMonth(1);
            System.out.println("nextMonth = " + nextMonth);
            return nextMonth;
        };
        // 我们可以通过TemporalAdjusters 来实现
        // LocalDateTime nextMonth = now.with(adJuster);
        LocalDateTime nextMonth = now.with(TemporalAdjusters.firstDayOfNextMonth());
        System.out.println("nextMonth = " + nextMonth);
    }

 
  
2.7 日期时间的时区
 
  
Java8 中加入了对时区的支持，LocalDate、LocalTime、LocalDateTime是不带时区的，带时区的日期时间类分别为：ZonedDate、ZonedTime、ZonedDateTime。其中每个时区都对应着 ID，ID的格式为 “区域/城市” 。例如 ：Asia/Shanghai 等。ZoneId：该类中包含了所有的时区信息
 
  
    /*** 时区操作 */
    @Test
    public void test01() {
        // 1.获取所有的时区id
        //  ZoneId.getAvailableZoneIds().forEach(System.out::println);
        // 获取当前时间 中国使用的 东八区的时区，比标准时间早8个小时
        LocalDateTime now = LocalDateTime.now();
        System.out.println("now = " + now); // 2021-05-27T17:17:06.951
        // 获取标准时间
        ZonedDateTime bz = ZonedDateTime.now(Clock.systemUTC());
        System.out.println("bz = " + bz); // 2021-05-27T09:17:06.952Z
        // 使用计算机默认的时区，创建日期时间
        ZonedDateTime now1 = ZonedDateTime.now();
        System.out.println("now1 = " + now1); //2021-05- 27T17:17:06.952+08:00[Asia/Shanghai]
        // 使用指定的时区创建日期时间
        ZonedDateTime now2 = ZonedDateTime.now(ZoneId.of("America/Marigot"));
        System.out.println("now2 = " + now2);
    }

 
  
JDK新的日期和时间API的优势：
 
  
     
   
  1. 新版日期时间API中，日期和时间对象是不可变，操作日期不会影响原来的值，而是生成一个新的实例
    2.  
   
  2. 提供不同的两种方式，有效的区分了人和机器的操作
    3.  
   
  3. TemporalAdjuster可以更精确的操作日期，还可以自定义日期调整期
    4.  
   
  4. 线程安全
    5.  
  
 
  
九、其他新特性
 
  
1.重复注解
 
  
有一个很大的限制是：在同一个地方不能多次使用同一个注解。JDK 8引入了重复注解的概念，允许在同一个地方多次使用同一个注解。在JDK 8中使用@Repeatable注解定义重复注解。
 
  
1.1 定义一个重复注解的容器
 
  
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotations {

     MyAnnotation[] value();
}

 
  
1.2 定义一个可以重复的注解
 
  
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String value();


}

 
  
1.3 配置多个重复的注解
 
  
@MyAnnotation("test01")
@MyAnnotation("test02")
@MyAnnotation("test03")
public class AnnoTest01 {


    @MyAnnotation("fun1")
    @MyAnnotation("fun2")
    public void test01() {

    }
}

 
  
1.4 解析得到指定的注解
 
  
    /**
     * 解析注解
     *
     * @param args
     */
    public static void main(String[] args) throws NoSuchMethodException {
        // 获取类中标注的重复注解
        MyAnnotation[] annotationsByType = AnnoTest01.class.getAnnotationsByType(MyAnnotation.class);
        for (MyAnnotation myAnnotation : annotationsByType) {
            System.out.println(myAnnotation.value());

            // 获取方法上标注的重复注解
            MyAnnotation[] test01s = AnnoTest01.class.getMethod("test01").getAnnotationsByType(MyAnnotation.class);
            for (MyAnnotation test01 : test01s) {
                System.out.println(test01.value());
            }
        }

 
  
2.类型注解
 
  
JDK 8为@Target元注解新增了两种类型： TYPE_PARAMETER ， TYPE_USE 。
 
  
     
   
  • TYPE_PARAMETER ：表示该注解能写在类型参数的声明语句中。 类型参数声明如：
    •  
   
  • TYPE_USE ：表示注解可以再任何用到类型的地方使用。
     TYPE_PARAMETER
    •  
  
 
  
@Target(ElementType.TYPE_PARAMETER) 
public @interface TypeParam {
 }

 
  
使用
 
  
public class TypeDemo01<@TypeParam T> {
    public <@TypeParam K extends Object> K test01() {
        return null;
    }
}

 
  
TYPE_USE
 
  
@Target(ElementType.TYPE_USE) 
public @interface NotNull { 
}

 
  
使用
 
  
public class TypeUseDemo01 {
    public @NotNull Integer age = 10;

    public Integer sum(@NotNull Integer a, @NotNull Integer b) {
        return a + b;
    }
}

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,oracle,java-ee)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                                
  • LeetCode[Math] - #66 Plus One
                                    Cwind
javaLeetCode题解AlgorithmMath
                                    
    原题链接：#66 Plus One 
  
要求： 
给定一个用数字数组表示的非负整数，如num1 = {1, 2, 3, 9}, num2 = {9, 9}等，给这个数加上1。 
注意： 
1. 数字的较高位存在数组的头上，即num1表示数字1239 
2. 每一位（数组中的每个元素）的取值范围为0~9 
  
难度：简单 
  
分析： 
题目比较简单，只须从数组
    
                                
    • 
                                
  • JQuery中$.ajax()方法参数详解
                                    AILIKES
JavaScriptjsonpjqueryAjaxjson
                                    
    url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。 
type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和    delete也可以使用，但仅部分浏览器支持。 
timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局
    
                                
    • 
                                
  • JConsole & JVisualVM远程监视Webphere服务器JVM
                                    Kai_Ge
JVisualVMJConsoleWebphere
                                    
        JConsole是JDK里自带的一个工具，可以监测Java程序运行时所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。我们可以根据这些信息判断程序是否有内存泄漏问题。 
　　使用JConsole工具来分析WAS的JVM问题，需要进行相关的配置。 
　　首先我们看WAS服务器端的配置. 
　　1、登录was控制台https://10.4.119.18
    
                                
    • 
                                
  • 自定义annotation
                                    120153216
annotation
                                    
    Java annotation 自定义注释@interface的用法  一、什么是注释  
 
    说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源
    
                                
    • 
                                
  • CentOS 5/6.X 使用 EPEL YUM源
                                    2002wmj
centos
                                    
    CentOS 6.X 安装使用EPEL YUM源1. 查看操作系统版本[root@node1 ~]# uname -a Linux node1.test.com 2.6.32-358.el6.x86_64 #1 SMP Fri Feb 22 00:31:26 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux [root@node1 ~]#
    
                                
    • 
                                
  • 在SQLSERVER中查找缺失和无用的索引SQL
                                    357029540
SQL Server
                                    
    --缺失的索引 
SELECT  avg_total_user_cost * avg_user_impact * ( user_scans + user_seeks ) AS PossibleImprovement ,  
        last_user_seek ,  
  
    
                                
    • 
                                
  • Spring3 MVC 笔记（二） —json+rest优化
                                    7454103
Spring3 MVC
                                    
    接上次的 spring mvc 注解的一些详细信息！ 
                         其实也是一些个人的学习笔记  呵呵！ 
 

    
                                
    • 
                                
  • 替换“\”的时候报错Unexpected internal error near index 1 \ ^
                                    adminjun
java“\替换”
                                    
    发现还是有些东西没有刻子脑子里,,过段时间就没什么概念了,所以贴出来...以免再忘... 
  
在拆分字符串时遇到通过 \ 来拆分，可是用所以想通过转义 \\ 来拆分的时候会报异常 
   
 
 public class Main {   
    
     /*
    
                                
    • 
                                
  • POJ 1035 Spell checker(哈希表)
                                    aijuans
暴力求解--哈希表
                                    
    /*
题意：输入字典，然后输入单词，判断字典中是否出现过该单词，或者是否进行删除、添加、替换操作，如果是，则输出对应的字典中的单词
要求按照输入时候的排名输出

题解：建立两个哈希表。一个存储字典和输入字典中单词的排名，一个进行最后输出的判重
*/

#include <iostream>
//#define 
using namespace std;
const int HASH =
    
                                
    • 
                                
  • 通过原型实现javascript Array的去重、最大值和最小值
                                    ayaoxinchao
JavaScriptarrayprototype
                                    
    用原型函数（prototype）可以定义一些很方便的自定义函数，实现各种自定义功能。本次主要是实现了Array的去重、获取最大值和最小值。 
实现代码如下： 
  
<script type="text/javascript">
	Array.prototype.unique = function() {
		var a = {};
		var le
    
                                
    • 
                                
  • UIWebView实现https双向认证请求
                                    bewithme
UIWebViewhttpsObjective-C
                                    
      
        什么是HTTPS双向认证我已在先前的博文 ASIHTTPRequest实现https双向认证请求 
中有讲述，不理解的读者可以先复习一下。本文是用UIWebView来实现对需要客户端证书验证的服务请求，网上有些文章中有涉及到此内容，但都只言片语，没有讲完全，更没有完整的代码，让人困扰不已。但是此知
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(Redis高级应用之事务处理、持久化操作、pub_sub、虚拟内存)
                                    bijian1013
redis数据库NoSQL
                                    
    3.事务处理 
        Redis对事务的支持目前不比较简单。Redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务上下文，该连接后续的命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中
    
                                
    • 
                                
  • 各数据库分页sql备忘
                                    bingyingao
oraclesql分页
                                    
    ORACLE 
 
下面这个效率很低 
SELECT * FROM ( SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_FS_RETURN order by id desc) A ) WHERE RN <20; 
 
下面这个效率很高 
SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_
    
                                
    • 
                                
  • 【Scala七】Scala核心一：函数
                                    bit1129
scala
                                    
    1. 如果函数体只有一行代码，则可以不用写{},比如 
def print(x: Int) = println(x) 
一行上的多条语句用分号隔开，则只有第一句属于方法体，例如 
  
def printWithValue(x: Int) : String= println(x); "ABC" 
  
上面的代码报错，因为，printWithValue的方法
    
                                
    • 
                                
  • 了解GHC的factorial编译过程
                                    bookjovi
haskell
                                    
    GHC相对其他主流语言的编译器或解释器还是比较复杂的，一部分原因是haskell本身的设计就不易于实现compiler，如lazy特性，static typed，类型推导等。 
关于GHC的内部实现有篇文章说的挺好，这里，文中在RTS一节中详细说了haskell的concurrent实现，里面提到了green thread，如果熟悉Go语言的话就会发现，ghc的concurrent实现和Go有点类
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-LinkedHashMap
                                    BrokenDreams
LinkedHashMap
                                    
            前面总结了java.util.HashMap，了解了其内部由散列表实现，每个桶内是一个单向链表。那有没有双向链表的实现呢？双向链表的实现会具备什么特性呢？来看一下HashMap的一个子类——java.util.LinkedHashMap。 
      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-抽象工厂模式-Abstract Factory
                                    bylijinnan
abstract
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


package design.pattern;

/*
 * Abstract Factory Pattern
 * 抽象工厂模式的目的是：
 * 通过在抽象工厂里面定义一组产品接口，方便地切换“产品簇”
 * 这些接口是相关或者相依赖的
    
                                
    • 
                                
  • 压暗面部高光
                                    cherishLC
PS
                                    
    方法一、压暗高光&重新着色 
当皮肤很油又使用闪光灯时，很容易在面部形成高光区域。 
下面讲一下我今天处理高光区域的心得： 
皮肤可以分为纹理和色彩两个属性。其中纹理主要由亮度通道（Lab模式的L通道）决定，色彩则由a、b通道确定。 
处理思路为在保持高光区域纹理的情况下，对高光区域着色。具体步骤为：降低高光区域的整体的亮度，再进行着色。 
如果想简化步骤，可以只进行着色（参看下面的步骤1
    
                                
    • 
                                
  • Java VisualVM监控远程JVM
                                    crabdave
visualvm
                                    
    Java VisualVM监控远程JVM  
  
JDK1.6开始自带的VisualVM就是不错的监控工具. 
这个工具就在JAVA_HOME\bin\目录下的jvisualvm.exe, 双击这个文件就能看到界面 
  
通过JMX连接远程机器, 需要经过下面的配置: 
1. 修改远程机器JDK配置文件 (我这里远程机器是linux). 
   
    
                                
    • 
                                
  • Saiku去掉登录模块
                                    daizj
saiku登录olapBI
                                    
     
1、修改applicationContext-saiku-webapp.xml 
 
<security:intercept-url pattern="/rest/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />  
<security:intercept-url pattern=&qu
    
                                
    • 
                                
  • 浅析 Flex中的Focus
                                    dsjt
htmlFlexFlash
                                    
    关键字：focus、 setFocus、 IFocusManager、KeyboardEvent 
 焦点、设置焦点、获得焦点、键盘事件 
 
 
 一、无焦点的困扰——组件监听不到键盘事件 
原因：只有获得焦点的组件（确切说是InteractiveObject）才能监听到键盘事件的目标阶段；键盘事件（flash.events.KeyboardEvent）参与冒泡阶段，所以焦点组件的父项（以及它爸
    
                                
    • 
                                
  • Yii全局函数使用
                                    dcj3sjt126com
yii
                                    
    由于YII致力于完美的整合第三方库，它并没有定义任何全局函数。yii中的每一个应用都需要全类别和对象范围。例如，Yii::app()->user;Yii::app()->params['name'];等等。我们可以自行设定全局函数，使得代码看起来更加简洁易用。(原文地址) 
我们可以保存在globals.php在protected目录下。然后，在入口脚本index.php的，我们包括在
    
                                
    • 
                                
  • 设计模式之单例模式二（解决无序写入的问题）
                                    come_for_dream
单例模式volatile乱序执行双重检验锁
                                    
                    在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该
    
                                
    • 
                                
  • 程序员从初级到高级的蜕变
                                    gcq511120594
框架工作PHPandroidhtml5
                                    
    软件开发是一个奇怪的行业，市场远远供不应求。这是一个已经存在多年的问题，而且随着时间的流逝，愈演愈烈。 
我们严重缺乏能够满足需求的人才。这个行业相当年轻。大多数软件项目是失败的。几乎所有的项目都会超出预算。我们解决问题的最佳指导方针可以归结为——“用一些通用方法去解决问题，当然这些方法常常不管用，于是，唯一能做的就是不断地尝试，逐个看看是否奏效”。 
现在我们把淫浸代码时间超过3年的开发人员称为
    
                                
    • 
                                
  • Reverse Linked List
                                    hcx2013
list
                                    
    Reverse a singly linked list. 
  
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
p
    
                                
    • 
                                
  • Spring4.1新特性——数据库集成测试
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • C# Ajax上传图片同时生成微缩图(附Demo)
                                    liyonghui160com

                                    
      
  
1.Ajax无刷新上传图片,详情请阅我的这篇文章。（jquery + c# ashx） 
        2.C#位图处理  System.Drawing。 
        3.最新demo支持IE7,IE8,Fir
    
                                
    • 
                                
  • Java list三种遍历方法性能比较
                                    pda158
java
                                    
    从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码例如以下： 
package com.hisense.tiger.list;
import java.util.ArrayList;
import java.util.Iterator;
    
                                
    • 
                                
  • 300个涵盖IT各方面的免费资源（上）——商业与市场篇
                                    shoothao
seo商业与市场IT资源免费资源
                                    
     
 A.网站模板+logo+服务器主机+发票生成 
 
 
  HTML5 UP:响应式的HTML5和CSS3网站模板。 
  Bootswatch:免费的Bootstrap主题。 
  Templated:收集了845个免费的CSS和HTML5网站模板。 
  Wordpress.org|Wordpress.com:可免费创建你的新网站。 
  Strikingly:关注领域中免费无限的移动优
    
                                
    • 
                                
  • localStorage、sessionStorage
                                    uule
localStorage
                                    
    W3School 例子 
  
HTML5 提供了两种在客户端存储数据的新方法： 
localStorage - 没有时间限制的数据存储 
sessionStorage - 针对一个 session 的数据存储 
  
之前，这些都是由 cookie 完成的。但是 cookie 不适合大量数据的存储，因为它们由每个对服务器的请求来传递，这使得 cookie 速度很慢而且效率也不
    
                                
    •