好程序员大数据学习路线之大数据自学路线二

lambda 表达式

比较lambda 表达式和匿名内部类：

lambda 表达式就是简单的匿名内部类

匿名内部类可以为任意接口创建实例，不管接口有多少抽象方法；

lambda 表达式只能为函数式接口创建实例（即只能有一个抽象方法）

基本语法：

( 参数 )-> 表达式、 ( 参数 )->{ 方法体 ;}

1. 形参：形参列表允许省略形参类型，若形参列表中只有一个参数，形参列表的圆括号也可以省略代码

2. 箭头：通过英文的划线号和大于符号组成

3. 代码块：如果代码块只包含一条语句， lambda 表达式允许省略代码块的花括号

4. 返回值： lambda 代码块只有一条 return 语句，甚至可以省略 return 关键字

lambda 表达式需要返回值，而它的代码块中仅有一条省略了 return 的语句， lambda 表达式会自动返回这条语句的结果

5.lambda 表达式中变量的使用：如果是全局的变量直接用，如果是局部变量会默认在前面添加 final

```java

// 匿名内部类

InterfaceA a = new InterfaceA() {

    public void show() {

        System.out.println(" 匿名内部类的 show");

    }

};

a.show();

// 通过 lambda 表达式

InterfaceA b = ()->{

    System.out.println("lambda 表达式的 show");

};

b.show();

// 简化

InterfaceA b1 = ()->System.out.println(" 简化的 lambda 表达式的 show");

b1.show();

```

方法引用与构造器引用

1. 引用类方法

2. 引用特定对象的实例方法

3. 引用某类对象的实例方法

4. 引用构造方法

```java

//1. 没有参数的

InterA aa = ()->System.out.println(" 没有参数 ");

//2. 一个参数的

InterB bb = (ib)->System.out.println(" 一个参数 :"+ib);

//3. 两个参数的

InterC cc = (ia,ib)->System.out.println(" 两个参数 :"+"ia:"+ia+"ib:"+ib);

//4. 返回值

InterD dd = (i,j)->i+j;

int value1 = dd.showD(4, 7);

//5.lambda 表达式作为参数

```

```java

public class Demo3 {

public static void main(String[] args) {

//

//

//

//

}

}

//* 1. 引用类方法

interface Converter{

// 将字符串转换成整数

Integer convert(String value);

}

class Test1{

public static void fun1() {

}

}

//* 2. 引用特定对象的实例方法

interface IA{

public void show(String message);

}

class A{

public void play(String i) {

}

}

class Test2{

public static void fun2() {

}

}

//* 3. 引用某类对象的实例方法

interface IB{

String subString(String string,int stat,int end);

}

class Test3{

public static void fun3() {

}

}

//* 4. 引用构造方法

interface IC{

Object show(String name,int age);

}

class Person{

String name;

int age;

public Person(String name, int age) {

}

@Override

public String toString() {

}

}

class Test4{

public static void fun4() {

}

}

```

集合

可以存储不同类型的多个数据，只能存储引用数据类型，动态分配内存

Collection ：接口

添加：boolean add(Object o); 、 boolean addAll(Collection<?> c);

删除：boolean remove(Object o); 、 boolean removeAll(Collection<?> c); 、

判断：boolean contains(Object o); 、 boolean contains(Collection<?> c);

获取：Iterator<E> iterator();

集合变数组：Object toArray();

List ：接口：

有序的（存储有序），可重复的

底层数据结构是数组，线程不安全，特点：查找速度快，添加删除慢

底层数据结构是数组，线程安全，特点：查找速度快，添加删除慢

底层数据结构是链表，线程不安全，特点：查找速度慢，添加删除快

Set ：接口：

无序的，不可重复的

底层是哈希表，线程不安全

底层是二叉树，线程不安全

Map ：接口

HashMap ： DAY07 笔记 2019-07-30

TreeMap ： DAY07 笔记 2019-07-30

泛型

通过< 数据类型 > 接受一种数据类型

1. 减少容错处理，简化代码

2. 将运行错误提前到编译阶段

泛型应用在方法上：

1. 类上的泛型与方法上的泛型保持一致

```java

class Dog<F>{

public void eat(F f) {

}

}

```

2. 方法上独立使用泛型

```java

public <E> void song(E e) {

}

```

3. 静态方法上使用泛型（必须独立使用）：

```java

public static <W> void show(W w) {}

```

泛型应用在接口上：

1. 子类上的泛型与接口上的一致

```java

interface Inte<E>{

public void show(E e);

}

class Pig<E> implements Inte<E>{

@Override

public void show(E e) {

}

}

```

2. 接口上使用泛型 , 子类上不用泛型

```java

interface Inte<E>{

public void show(E e);

}

class Bird implements Inte<String>{

public void show(String e) {};

}

```

1. 如果是重写的方法 , 泛型与接口一致

2. 如果是子类自己的方法 , 可以与接口一致 , 也可以有自己的泛型

限制上限和限制下限

限制上限<? extends E> ： E 以及 E 的子类

限制上限<? super E> ： E 以及 E 的父类