jdk1.5与jdk1.8的新特性

jdk1.5新特性

1.静态导入

可以导入静态方法，可以直接使用
静态导入信息会优先加载

package cn.tedu.jdk.jdk5;
//静态导入
import static java.lang.Math.*;

public class StaticImportDemo {
    public static void main(String[] args) {
        //
        System.out.println(random());
        System.out.println(abs(12));
    }
}

2.可变参数

参数类型…
可以接受任意多个参数
底层是有数组来实现的，参数值都是存放在对应的数组元素中
可变参数值只能出现在参数列表的最右边，最多只能出行一次

package cn.tedu.jdk.jdk5;

public class VariableDemo {
    public static void main(String[] args) {
        System.out.println(sum(1));
        System.out.println(sum(1,2));
        System.out.println(sum(1,2,34,4));
    }
    //定义方法求和
    //参数类型...---可变参数
    //可以接受任意多个参数
    //可变参数底层是一个大大的数组，把参数值赋值给对应的数组元素
    //可变参数只能出现在参数列表的最右边（最多只能出现一次）
    public static int sum(int... i){
        //return i;
        int sum=0;
        for (int j=0;j<i.length;j++){
            sum+=i[j];
        }
        return sum;
    }
    /*public static int sum(int i,int j){
        return i+j;
    }
    public static int sum(int i,int j,int z){
        return i+j+z;
    }
    public static int sum(int[] arr){
        int m=0;
        for (int a:arr){
            m+=a;
        }
        return m;
    }*/
}

3.枚举

把值一一列举
列举是枚举常量且在首行，并且在一行
构造方法一定要私有化
定义属性和方法
定义抽象方法
switch表达式类型支持枚举类型

package cn.tedu.reflect;

public class EnumDemo {
    public static void main(String[] args) {
        Season spring=Season.spring;
        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 i=1;
    //方法
    public void m(){}
    //构造方法--只能私有化
    private Season(){}
    //抽象方法
    public abstract void n();
}
//定义类---代表季节的类,类产生的对象就是具体的季节
//只有四个季节，类只能产生四个对象
/*class Season{
    //构造方法私有化，保证外部不能调用构造方法来创建对象
    private Season(){}
    //创建四个对象---四个季节
    public final static Season spring=new Season();
    public final static Season summer=new Season();
    public final static Season autumn=new Season();
    public final static Season winter=new Season();
}*/

jdk1.8新特性

接口里可以定义实体方法（默认方法、静态方法）
Lambda表达式用于重写函数式接口的抽象方法
函数式接口里只含有一个抽象方法

public class LambdaDemo1 {
    public static void main(String[] args) {
        //创建实现类对象
        //CalcImpl c=new CalcImpl();
        //调用接口里的实体类方法---默认方法
        /*System.out.println(c.sum(1,2));*/
       /* //由接口名称直接调用实体类方法---静态方法
        Calc.cj(2,3);*/

        /*//创建实现类对象
        //调用接口重写方法
        c.max(1,2);*/

        /*//匿名内部类
        //c是匿名内部类的对象
        Calc c=new Calc() {
            @Override
            public int max(int x, int y) {
                return x>y?x:y;
            }
        };
        //调用匿名内部类（接口的实现类）的重写方法
        c.max(1,2);*/
        //Lambda表达式（针对函数式接口）
        //(参数列表)->{抽象方法的重写的方法体};
        //Calc c=(int x,int y)->{return  x>y?x:y;};
        //由前面的抽象方法参数类型推导出此时的参数类型，不用写参数类型
        //如果重写方法的方法体只有一句话就可以把return以及{}省略
        Calc c=(x,y)->x>y?x:y;
        c.max(1,2);
    }
}

//接口---计算器
//接口里只有一个抽象方法---函数式接口(函数式编程)
@FunctionalInterface
interface  Calc{

    //求最大值
    int max(int x,int y);

    //实体方法---默认方法
    public default  int sum(int x,int y){return x+y;}
    //
    public static int cj(int x,int y){return x*y;}
}

//实现类
class CalcImpl implements Calc{

    @Override
    public int max(int x, int y) {
        return x>y?x:y;
    }
}

public class LambdaDemo2 {
    public static void main(String[] args) {
       /* //Lambda表达式
        SortArray s=(arr )-> Arrays.sort(arr);*/
        //当参数只有一个时可以省略()
        //SortArray s=arr -> Arrays.sort(arr);
        //::传递静态方法    前后只使用一个参数就可以省略
        //SortArray s=Arrays::sort;
        //比较器是函数式接口
        //new ArrayList<String>().sort(new Comparator<String>()
        //FileFilter()---函数式接口
        //new File("").listFiles(new FileFilter()
        //FilenameFilter() ---函数式接口
        //new File("").list(new FilenameFilter()
    }
}

interface SortArray{
    //排序---抽象方法
    void sort(int[] arr);
}

Stream—流式结构

操作集合元素
提供大量的函数式接口

public class StreamDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list=new ArrayList<>();
        //添加元素
        list.add("C");
        list.add("Python");
        list.add("Java");
        list.add("PHP");
        list.add("C++");
        list.add("C#");
        list.add("GO");

        //筛选出以C开头的元素
        /*for (String s:list){
            //
            if (s.startsWith("c")){
                System.out.println(s);
            }
        }*/

        //
        Stream<String> s=list.stream();
        /*s.filter(new Predicate<String>() {
            //指定过滤规则
            @Override
            public boolean test(String s) {
                return s.startsWith("C");
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        //用lambda表达式
        //筛选出以C开头的元素并且排序--升序
        s.filter(str1->str1.startsWith("C")).sorted((s1,s2)->s1.compareTo(s2)).forEach(str2-> System.out.println(str2));
    }
}

time包

时间和日期可以分开操作

public static void main(String[] args) {
    //只有时间
    //LocalTime l=LocalTime.now();
    //只有日期
    LocalDate l=LocalDate.now();
    System.out.println(l);
}