JAVA8的新特性

网上介绍java8新特性的概念已经很多了，我就不过多说了；

直接教你怎么使用：

一.配置环境：

1.在工作空间的build.gradle中配置

buildscript {

    repositories {

        .....

        // Java8 环境的搭建,所使用的配置

mavenCentral()

    }

    dependencies {

classpath 'com.android.tools.build:gradle:2.2.0'

        // Java8 环境的搭建,所使用的配置

classpath 'me.tatarka:gradle-retrolambda:3.3.1'

}

}

allprojects {

    repositories {

        .....

        // Java8 环境的搭建,所使用的配置

mavenCentral()

    }

}

2.在app/build.gradle中配置

// Java8 环境的搭建,所使用的配置

apply plugin: 'me.tatarka.retrolambda'

android {

    ....

// Java8 环境的搭建,所使用的配置

compileOptions {

sourceCompatibility JavaVersion.VERSION_1_8

targetCompatibility JavaVersion.VERSION_1_8

}

}

概念:java1.8及以上版本才有的新特性.是一种新的语法

使用Lambda表达式,对传统的代码进行修改,分为调用系统的,调用自己的,无参,有参,多参等:

A.这段传统写法的代码,真正有用的是run方法,而new Runnable()这件事,就显得好无意义.

newThread(

//匿名内部类,主要用到的就是run方法

newRunnable() {

@Override

public voidrun() {

    Log.d("PY","使用系统原生的代码");

}

}) {

}.start();

//A.将上面的代码替换成Lambda表达式(Runnable()变成灰色)

//A.实际就是把没有什么作用的格式用 "()->" 替换,只保留有作用的核心代码.

newThread(() -> Log.d("PY", "使用系统原生的代码")) {

}.start();

1.自定义一个类,定义一个方法,接收一个接口,执行里面的方法

class MyButton {

public void setMyListener(MyListener myListener) {

    //接口对象调用接口唯一的一个抽象方法,如果没有调用参数就是灰色的

    myListener.onStateChanged();

}

}

1.定义一个接口,内部有且只能有一个抽象方法

interface MyListener {

//自定义一个接口,无参

void onStateChanged();

}

MyButton myButton = newMyButton();

myButton.setMyListener(newMyListener() {

@Override

public voidonStateChanged() {

    Log.d("PY","使用自己定义的代码");

}

});

//B.使用Lambda表达式,() ->代表了上面的new MyListener() {void onStateChanged()...的代码

myButton.setMyListener(() -> Log.d("PY", "使用自己定义的代码"));

2.自定义一个类,定义一个方法,接收一个接口,执行里面的方法

class MyButton {

String s;

public MyButton(String s) {

    this.s = s;

}

public void setMyListener(MyListener myListener) {

    myListener.onStateChanged(s);

}

}

2.定义一个接口,内部有且只能有一个抽象方法

interfaceMyListener {

//自定义一个接口,有参

void onStateChanged(String s);

}

//B.使用Lambda表达式,第一种最常见,下面两种虽然更简化,但阅读性不好,一般我们不用,了解即可

myButton.setMyListener((String s)->Log.d("PY", s+"使用自己定义的代码"));

myButton.setMyListener((s)->Log.d("PY", s+"使用自己定义的代码"));

//这种写法,只能是接口方法的参数是一个,如果有多个的话,就不可以了

myButton.setMyListener(s ->Log.d("PY", s+"使用自己定义的代码"));

3.自定义一个类,定义一个方法,接收一个接口,执行里面的方法

class MyButton {

String s;

int i;

public MyButton(String s, int i) {

this.s = s;

this.i = i;

}

public void setMyListener(MyListener myListener) {

    //接口对象调用接口唯一的一个抽象方法

    myListener.onStateChanged(s,i);

}

}

3.定义一个接口,内部有且只能有一个抽象方法

interfaceMyListener {

//自定义一个接口,有多个参数

void onStateChanged(s,i);

}

用我们自定义的格式换成Lambda表达式,接口方法有多个参数

MyButton myButton =new MyButton("岩", 9);

myButton.setMyListener(newMyListener() {

@Override

public voidonStateChanged(String s,int i) {

    System.out.println(s + "有"+i+"个老婆");

}

});

//B.使用Lambda表达式,注意:这里不是一行代码,而是多行,那么就要加{}

myButton.setMyListener((String s, int i) -> {

    System.out.println("岩富可敌国,所以有众多的追求者"); 

    System.out.println(s + "有"+i+"个老婆"); }

);

    使用我们自定义的格式换成Lambda表达式,接口方法有多个参数且还有返回值

MyButton myButton = new MyButton("岩", 9);

myButton.setMyListener(new MyListener() {

@Override

public boolean onStateChanged(String s, int i) {

System.out.println(s + "有"+i+"个老婆");

        return false;

    }

});

//B.使用Lambda表达式    注意:这里就有了个return

myButton.setMyListener((String s, int i)->{

        System.out.println(s + "有"+i+"个老婆");

        return false;

    }

);

/**

* F.使用Lambda静态引用方法

*/

private voidLambdaStaticMethod() {

MyButton myButton =new MyButton("岩",9);

myButton.setMyListener(newMyListener() {

@Override

public booleanonStateChanged(String s, inti) {

System.out.println(s +"有"+i+"个老婆");

return false;

}

    });

//使用Lambda表达式的静态方法引用,

myButton.setMyListener(MainActivity :: ycf);

}

/**

* Lambda方法引用:一般我们不会去写,但是第三方库会用,看懂即可.非重点

*提示:参数和返回值必须和接口的唯一抽象方法保持一致

*/

public static boolean ycf(String s, int i){

System.out.println("我是Lambda的静态方法引用");

return false;

}

Stream是高级迭代器,以流的方式使用集合,数组以及其他数据结构,可以对数据进行各种运算(转换,过滤等)

第一:一般情况你的简历:扎实的Java基础与面向对象思想,掌握Java8的新特性.

第二:rxJava又叫响应式编程 : 观察者模式 ,Lambda表达式, 使用Stream特性操作集合,进行异步加载

1.将集合转换为Stream流

2.对Stream进行数据筛选

3.输出筛选出来的数据

@TargetApi(Build.VERSION_CODES.N)
public static voidstreamFilter() {

//创建集合对象,塞入数据

List<Integer> integers = Arrays.asList(1,2,3,4,5);

//通过for循环,对集合的数据进行操作

for(intx = 0; x < integers.size(); x++) {

//需求,只要集合中的偶数,传统的做法就比较麻烦了

// System.out.println(integers.get(x));

}

//使用java1.8的新特性Stream,把数据源变成流,报错,按住alt+回车,选第二个.

java.util.stream.Stream<Integer> stream = integers.stream();

//只要集合中的偶数,内部有接口,返回值还是流

stream.filter(newPredicate<Integer>() {

@Override

public booleantest(Integer integer) {

//参数integer就是不断的代表集合中的一个数据,对数据进行筛选获取,true就代表了这个数据被选中

//对数除以2,余数是否为0;

returninteger % 2== 0;

}

})

//forEach和for循环一样,将流数据转化成对应集合类型数据进行输出,只不过输出的数据是集合中符合条件的数据

.forEach(newConsumer<Integer>() {

@Override

public voidaccept(Integer integer) {

System.out.println(integer);

}

});

//使用lambada表达式,对上面的代码进行优化,这里的最终运行,我就在测试类调用

/* integers.stream()

.filter((Integer integer) -> integer % 2 == 0)

.forEach((Integer integer) -> {

System.out.println("打印出来的数" + integer);

});*/

}

1.将集合数据转换为Stream流

2.对Stream进行数据转换

3.输出筛选出来的数据

@TargetApi(Build.VERSION_CODES.N)

public static voidstreamMap() {

//创建集合对象,塞入数据

List<Integer> integers = Arrays.asList(1,2,3,4,5);

integers.stream()

//转换数据,参数 1.原有的参数类型对象 2.要转换的参数类型对象

.map(newFunction<Integer, String>() {

@Override

publicString apply(Integer integer) {

    returninteger.toString();

}

})

.forEach(newConsumer<String>() {

@Override

public voidaccept(String s) {

    System.out.println(s);

}

});

}