Java基础（二十）jdk1.5和jdk1.8新特性

最新推荐文章于 2024-06-11 21:32:56 发布

原创最新推荐文章于 2024-06-11 21:32:56 发布 · 383 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #lambda #stream

Java 专栏收录该内容

33 篇文章

订阅专栏

本文介绍了Java从1.5到1.8的重要更新，包括1.5的静态导入、可变参数和枚举，以及1.8的接口默认方法、Lambda表达式和Stream API的引入，帮助开发者理解这些版本的特性增强。

1.jdk1.5新特性

1.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(1.2));
        System.out.println(floor(2.23));
    }
}

1.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, 3));
    }

    //定义方法求和
    //参数类型...---可变参数
    //可以接收任意多个参数
    //可变参数的底层是一个大大的数组，把参数值赋值给对应的数组元素
    //可变参数只能出现在参数列表的最右边（最多只能出现一次）
    public static int sum(int... i) {
        int sum = 0;
        for (int j = 0; j < i.length; j++) {
            sum += i[j];
        }
        return sum;
    }
    /*public static int sum(int i){
        return i;
    }
    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;
    }*/

    }

1.3 枚举
列举出枚举常量，保证出现在首行并且同一行
构造方法私有化
可以定义属性和方法
可以定义抽象方法
switch表达式类型支持枚举类型

package cn.tedu.jdk.jdk5;

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();
}*/

2.jdk1.8新特性

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

package cn.tedu.jdk8;

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

        /*//由接口名称直接调用
        Calc.cj(2,3);*/

       /* //创建实现类的对象
        CalcImpl c=new CalcImpl();
        //调用接口重写方法
        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;
    }
}

2.2 Stream—流式结构
操作元素集合
提供大量的函数式接口

package cn.tedu.stream;

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("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表达式
        s.filter(str1->str1.startsWith("C"))
                .sorted((s1,s2)->s2.compareTo(s1))
                .forEach(str2-> System.out.println(str2));

    }
}

2.3 time包—时间和日期可以分开操作

package cn.tedu.time;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;

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