Shulou(Shulou.com)06/03 Report--

Big data self-study route 2 of the learning route of good programmer big data

Lambda expression

Compare lambda expressions with anonymous inner classes:

Lambda expressions are simple anonymous inner classes

Anonymous inner classes can create instances for any interface, no matter how many abstract methods the interface has

Lambda expressions can only create instances for functional interfaces (that is, there can be only one abstract method)

Basic syntax:

(parameter)-> expression, (parameter)-> {method body;}

1. Formal parameter: the formal parameter list allows you to omit the formal parameter type. If there is only one parameter in the formal parameter list, the parentheses in the formal parameter list can also omit the code.

two。 Arrowheads: made up of dash numbers and greater than symbols in English

3. Code block: if the code block contains only one statement, the lambda expression allows the curly braces of the code block to be omitted

4. Return value: the lambda code block has only one return statement, and the return keyword can even be omitted

The lambda expression needs to return a value, and there is only one statement in its code block that omits return. The lambda expression will automatically return the result of this statement.

Use of variables in 5.lambda expressions: if global variables are used directly, final will be added by default if local variables are used.

```java

/ / Anonymous inner class

InterfaceA a = new InterfaceA () {

Public void show () {

System.out.println ("show of anonymous inner classes")

}

}

A.show ()

/ / through lambda expression

InterfaceA b = ()-> {

System.out.println ("show of lambda expressions")

}

B.show ()

/ / simplify

InterfaceA b1 = ()-> System.out.println ("show of simplified lambda expressions")

B1.show ()

`

Method reference and constructor reference

1. Reference class method

two。 An instance method that references a specific object

3. An instance method that refers to a class of objects

4. Reference construction method

```java

/ / 1. Without parameters

InterA aa = ()-> System.out.println ("No parameters")

/ / 2. Of one parameter

InterB bb = (ib)-> System.out.println ("one parameter:" + ib)

/ / 3. With two parameters

InterC cc = (ia,ib)-> System.out.println ("two parameters:" + "ia:" + ia+ "ib:" + ib)

/ / 4. Return value

InterD dd = (iMagazine j)-> iMagj

Int value1 = dd.showD (4,7)

/ / 5.lambda expression as a parameter

`

```java

Public class Demo3 {

Public static void main (String [] args) {

/ /

/ /

/ /

/ /

}

}

/ / * 1. Reference class method

Interface Converter {

/ / convert a string to an integer

Integer convert (String value)

}

Class Test1 {

Public static void fun1 () {

}

}

/ / * 2. An instance method that references a specific object

Interface IA {

Public void show (String message)

}

Class A {

Public void play (String I) {

}

}

Class Test2 {

Public static void fun2 () {

}

}

/ / * 3. An instance method that refers to a class of objects

Interface IB {

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

}

Class Test3 {

Public static void fun3 () {

}

}

/ / * 4. Reference construction method

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 () {

}

}

`

Set

Multiple data of different types can be stored, only reference data types can be stored, and memory can be allocated dynamically

Collection: interface

Add: boolean add (Object o);, boolean addAll (Collection c)

Delete: boolean remove (Object o);, boolean removeAll (Collection c);

Judge: boolean contains (Object o);, boolean contains (Collection c)

Get: Iterator iterator ()

Collection variable array: Object toArray ()

List: API:

Ordered (stored in order), repeatable

The underlying data structure is an array, and the thread is not safe. It is characterized by fast search speed and slow addition and deletion.

The underlying data structure is an array, thread-safe, and features: fast search speed, slow addition and deletion

The underlying data structure is linked list, thread is not safe, features: slow search speed, fast add and delete

Set: API:

Disordered or unrepeatable.

The underlying layer is a hash table, and the thread is not safe.

The bottom layer is a binary tree, which is not thread safe.

Map: interface

HashMap:DAY07 Notes 2019-07-30

TreeMap:DAY07 Notes 2019-07-30

Generics

By accepting a data type

1. Reduce fault-tolerant processing and simplify code

two。 Advance the run error to the compilation phase

Generics are applied to methods:

1. Generics on classes are consistent with generics on methods

```java

Class Dog {

Public void eat (F f) {

}

}

`

two。 Use generics independently of the method

```java

Public void song (E e) {

}

`

3. Use generics on static methods (must be used independently):

```java

Public static void show (W w) {}

`

Generics are applied to interfaces:

1. Generics on subclasses are consistent with those on interfaces

```java

Interface Inte {

Public void show (E e)

}

Class Pig implements Inte {

@ Override

Public void show (E e) {

}

}

`

two。 Use generics on interfaces and no generics on subclasses

```java

Interface Inte {

Public void show (E e)

}

Class Bird implements Inte {

Public void show (String e) {}

}

`

1. If it is an overridden method, the generics are consistent with the interface

two。 If it is a subclass's own method, it can be consistent with the interface, or it can have its own generics.

Upper limit and lower limit

Limit upper limit

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.