jdk新特性-jdk1.5新特性-jdk1.8新特性

jdk新特性

1.jdk1.5新特性

静态导入

可以导入静态方法，可以直接使用

静态导入信息会优先加载

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

public class Static ImportDemo{

public static void main(String[]args){

System.out.println(random());

System.out.println(abs(1.2));

System.out.println(floor(2.23));
}
}

可变参数

参数类型…

可以接收任意多个参数

底层是由数组来实现的，参数值都是存放在对应的数组元素中

可变参数只能出现参数列表的最右边，最多只能出现一次

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));

System.out.println(sum(2,3,4,5,67));
}
//定义方法求和

//参数类型...---可变参数

//可以接收任意多个参数

//可变参数底层是一个大大的数组，把参数值赋值给对应的数组元素

//可变参数只能出现在参数列表的最右边（最多只能出现一次）

public static int sum(int...i){

int sum=0;

for(intj=0;j<i.length;j++){

sum+=i[j];
}
return sum;
}
/*public static int sum(inti,intj){
return i+j;
}
public static int sum(inti,intj,intz){
return i+j+z;
}
public static int sum(int[]arr){
int m=0;
for(int a:arr){
m+=a;
}
return m;
}*/
}

枚举

把值一一列举

列举是枚举常量，在首行并且在一行

构造方法一定要私有化

定义属性和方法

定义抽象方法

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等效publicfinalstaticSeasonspring=newSeason();
//枚举常量---要在一行,首行
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新特性

接口里可以定义实体方法（默认方法、静态方法）

Lambda表达式用于去重写函数式接口的抽象方法

函数式接口里只含有一个抽象方法

package cn.tedu.jdk8;

public class LambdaDemo1{

public static void main(String[]args){

//创建实现类对象

/*CalcImplc=new CalcImpl();

//调用接口里的实体方法---默认方法

System.out.println(c.sum(1,2));*/

/*//由接口名称直接调用实体方法---静态方法

Calc.cj(2,3);*/
/*//创建实现类对象

CalcImplc=new CalcImpl();

//调用接口重写方法

c.max(1,2);*/

//匿名内部类

//c是匿名内部类的对象

/*Calcc=new Calc(){

@Override

public int max(intx,inty){

return x>y?x:y;

}

};

//调用匿名内部类（接口的实现类）的重写方法

c.max(1,2);*/

//Lambda表达式（针对函数式接口）

//(参数列表)->{抽象方法的重写的方法体}

//Calcc=(intx,inty)->{return x>y?x:y;};

//有前面的抽象方法参数类型推导出此时的参数类型，不用写参数类型

//如果重写方法的方法体只有一句话就可以把return以及{}省略
Calcc=(x,y)->x>y?x:y;
c.max(1,2);
}
}
//接口---计算器

//接口里只有一个抽象方法---函数式接口（函数式编程）

@FunctionalInterface

interface Calc{

//求最大值---抽象方法

int max(intx,inty);

//实体方法---默认方法

public default int sum(intx,inty){return x+y;}

//实体方法---默认方法

public static int cj(intx,inty){return x*y;}

}

//实现类---重写抽象方法

class CalcImpl implements Calc{

@Override

public int max(intx,inty){

return x>y?x:y;
}
}

package cn.tedu.jdk8;
import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.Arrays;

public class LambdaDemo2{

public static void main(String[]args){

int[] arr1={1,2,3};

//Lambda表达式

//SortArrays=(arr)->Arrays.sort(arr);

//当参数只有一个时可以省略（）

//SortArrays=arr->Arrays.sort(arr);

//::传递静态方法前后只使用一个参数就可以省略

//SortArrays=Arrays::sort;

//比较器是函数式接口

//new ArrayList<String>().sort();

//FileFiter---函数式接口

//new File("").listFiles(new FileFiter)

//Filename Filter---函数式接口

//new File("").list(new FilenameFilter)
}
}
interface SortArray{

//排序---抽象方法

void sort(int[]arr);

}

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(Strings:list){
if(s.startsWith("C")){

System.out.println(s);

}

}*/
//调用方法返回流式结构
Stream<String>s=list.stream();
/*s.filter(newPredicate<String>(){

//指定过滤规则

@Override

public boolean test(Strings){

return s.startsWith("C");

}

}).forEach(new Consumer<String>(){

@Override

public void accept(Strings){

System.out.println(s);

}

});*/

//用Lambda表达式

//筛选出以C开头的元素并且排序

s.filter(str1->str1.startsWith("C")).

sorted((s1,s2)->s2.compareTo(s1)).

forEach(str2->System.out.println(str2));
}
}

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

package cn.tedu.time;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
import java.util.Locale;
public class TimeDemo{
public static void main(String[]args){
//只有时间
//LocalTimel=LocalTime.now();
//只有日期
LocalDatel=LocalDate.now();
System.out.println(l);
}
}