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

好程序员大数据学习路线之大数据自学路线二
lambda表达式
比较lambda表达式和匿名内部类：
lambda表达式就是简单的匿名内部类
匿名内部类能够为任意接口建立实例，无论接口有多少抽象方法；
lambda表达式只能为函数式接口建立实例（即只能有一个抽象方法）

基本语法：

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

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

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

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

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

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

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

//匿名内部类    
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.引用构造方法

//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表达式做为参数

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.类上的泛型与方法上的泛型保持一致

class Dog<F>{    
    public void eat(F f) {
    
    }
}

2.方法上独立使用泛型

public <E> void song(E e) {
    
    }

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

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

泛型应用在接口上：

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

interface Inte<E>{    
    public void show(E e);
}    
class Pig<E> implements Inte<E>{    
    @Override
    public void show(E e) {

    }
}

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

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的父类