jdk新特性

jdk新特性

jdk1.5新特性

静态导入
  静态方法导入直接书写方法进行调用
  优先于所有的静态信息先加载

//静态导入
import static java.lang.Math.*;
public class StaticImproDemo {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(Math.abs(1.2));
    }
}

可变参数
  参数类型…
  可以接收任意多个v参数
  底层基于数组实现
  最多只能出现一个在参数列表最右边

public class VariableDemo {
    public static void main(String[] args) {
        System.out.println(sum(1,2));
        System.out.println(sum(1,2,3));
        System.out.println(sum(1,2,3,4,5));
    }
    //求和方法
    //参数类型...---可变参数
    //可以接收任意多个参数
    //底层根据数组来实现的，把每个参数赋值到对应位置的数组元素
    //可变参数只能在参数列表的最右边---最多只能有一个
    public static int sum (int... a){
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i];
        }
        return sum;
    }
}

枚举
  将值（枚举常量）—列举
  枚举常量要在同一行且首行
  可以定义属性和方法
  只能定义私有化构造方法
  可以定义抽象方法（枚举常量重写抽象方法）
  从jdk1.5开始表达式类型支持枚举类型

public class EnumDemo {
    public static void main(String[] args) {
        Season spring = Season.spring;
        //switch表达式支持枚举类
        switch (spring){
            case spring:
                System.out.println("春游");
                break;
            case summer:
                System.out.println("游泳");
                break;
            case autumn:
                System.out.println("爬山");
                break;
            case winter:
                System.out.println("打雪仗");
                break;
        }
    }
}
//枚举类
//只能实现接口不能继承别的类
enum Season{
    //列举值
    //spring--public final static Season spring = new Season();
    //枚举常量
    //要在同一行并且在首行
    //如果类里有抽象方法必须让每个枚举常量重写抽象方法（匿名内部类）
    spring{
        @Override
        public void n() {

        }
    },summer{
        @Override
        public void n() {

        }
    },autumn{
        @Override
        public void n() {

        }
    },winter{
        @Override
        public void n() {

        }
    };
    //定义属性和方法
    int age;
    public void m(){}
    //定义私有构造方法
    private Season(){}
    //定义抽象方法
    public abstract void n();
}

jdk1.8新特性

  接口允许定义实体方法
  Lambda表达式默认实现函数式接口重写抽象方法
代码如下（示例1）：

public class LambdaDemo {
    public static void main(String[] args) {
        //Lambda表达式
        //(参数列表）->{重写方法方法体}
        //实现接口，重写抽象方法
//        Calc c = (int a,int b)->{return a>b?a:b;};
        //抽象方法的参数列表的类型可以有前推导，参数列表不写参数类型
//        Calc c = (a,b)->{return a>b?a:b;};
        //如果重写方法的方法体只有一行代码可以省略{}和return不写
        Calc c = (a,b)->a>b?a:b;
        //
        System.out.println(c.max(3,8));
    }
}
//计算器
//接口只定义一个抽象方法---函数式接口---函数式编程
@FunctionalInterface
interface Calc{
    //抽象方法---比大小
    int max(int m,int n);
    //求和
    //实体方法--默认方法
    public default int sum(int a,int b){
        return a + b;
    }
    //求乘积
    //实体方法--静态方法
    public static int cj(int x, int y){
        return x * y;
    }
}

代码如下（示例2）：

import java.util.Arrays;

public class LambdaDemo1 {
    public static void main(String[] args) {
        int[] arr = {5,4,6,8};
        //Lambda表达式
//        ArraySort a = (int[] arr)->{ Arrays.sort(arr);};
        //抽象方法的参数列表的类型可以由前推导，参数列表不写参数类型
        //如果重写方法的方法体只有一行代码可以省略{}和return不写
//        ArraySort a = (arr) ->Arrays.sort(arr);
        //当参数列表只有一个参数是可以省略()不写
//        ArraySort a = arr ->Arrays.sort(arr);
        //::传递静态方法
        ArraySort a = Arrays::sort;
        //调用重写内容给数组排序
        a.sortArray(arr);
        System.out.println(Arrays.toString(arr));

    }
}
//接口
interface ArraySort{
    //排序
    void sortArray(int[] arr);
}

  Steam（流式结构）
    含有大量的函数式接口需要使用Lambda表达式
代码如下（示例）：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        //
        List<String> list=new ArrayList<>();
        list.add("C");
        list.add("JAVA");
        list.add("Python");
        list.add("PHP");
        list.add("C++");
        list.add("C#");
        list.add("GO");

        //输出所有含有C的元素
        //遍历集合
       /* for(String l:list){
            //判断是否含有C
            if(l.matches(".*C.*")){
                System.out.println(l);
            }
        }*/

        //返回流式结构
        Stream<String> s = list.stream();

        //
       /* s.filter(new Predicate<String>() {
            //指定过滤规则
            @Override
            public boolean test(String s) {
                return s.matches(".*C.*");
            }
        }).forEach(new Consumer<String>() {
            //输出过滤之后的数据
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        //Lambda表达式
        //把过滤之后数据进行排序(降序)
        s.filter(s1->s1.matches(".*C.*")).
                sorted((str1,str2)->str2.compareTo(str1)).
                forEach(s2-> System.out.println(s2));
    }
}