• Process-oriented: specific, process-oriented, to solve a problem, you need to step by step analysis, step by step implementation

  • Advantages: Higher performance than object-oriented, because class invocation needs to be instantiated, the overhead is relatively large, more consumption of resources; For example, SCM, embedded development, Linux/Unix and so on generally adopt process-oriented development, performance is the most important factor
  • Disadvantages: No object-oriented easy maintenance, easy reuse, easy to expand

• Object-oriented: Modeled, you just pull out a class, it’s a closed box where you have the data and the solution to the problem. What functions are needed can be used directly, do not have to go step by step implementation, as for this function is how to achieve

  • Advantages: Easy to maintain, easy to reuse, easy to expand, because of the characteristics of object-oriented encapsulation, inheritance, polymorphism, can design a low coupling system, make the system more flexible, more easy to maintain
  • Disadvantages: Lower performance than process-oriented

It is the expression form of object function cohesion, which determines whether information is disclosed and the level of disclosure on the basis of abstraction, and which information is exposed in what way. The main task is to hide attributes, data, and sensitive behaviors. The access and modification of attributes must be realized through public interfaces. Encapsulation simplifies object relationships, reduces code coupling, and facilitates maintenance

The Demeter principle is the requirement of encapsulation, that is, module A uses an interface behavior of module B, and should know as little as possible about other information except this behavior in module B. Getter /setter methods are used instead of reading and modifying public properties directly because they assume permission control, logging, and so on when modifying properties, which cannot be done with direct access to properties. If you change the properties and behavior of public to private, the dependency module will report an error. Therefore, if you do not know which permission to use private should be preferred

On the basis of encapsulation and inheritance, make with to run-time objects based on the actual type has different forms, polymorphism refers to the compilation method body could not determine the final call, at run time by the JVM dynamic binding, suitable for the suitable method to rewrite, belongs to static binding due to overloading, essentially override results are completely different approach, thus polymorphism generally specifically to rewrite

Overloading refers to the same method name, but different number of parameter types, is the horizontal implementation of different behavior. To the compiler, the method name and argument list form a unique key, called the method signature, through which the JVM decides which overloaded methods to call. Regardless of the complexity of inheritance, an overload knows at compile time by rule which target method to call, and therefore is statically bound. Right

The order in which the JVM selects the appropriate method among overloaded methods: ② Basic data types are automatically converted to a larger range of representations. Automatic unpacking and packing. (4) Subclass upward transformation. ⑤ Variable parameters

JVM: The Java compiler generates computer architecture-independent bytecode instructions that can be easily interpreted and executed on any machine and dynamically translated into native machine code by the JVM, which is platform-specific and does not discriminate between operating systems

Language specifications: Basic data types are clearly defined. For example, ints are always 32 bits, whereas in C/C++ they can be 16 bits, 32 bits, or any other size specified by the compiler developer. In Java, numeric types have a fixed number of bytes, are stored and transmitted in binary format, and strings are stored in standard Unicode format

• Pass by value: Accepts a value provided by the caller
• Call by reference: means that a method accepts the address of a variable provided by the caller

Java is always called by value, a copy of all the arguments a method gets, and when you pass an object the method actually receives a copy of the object reference. Method cannot modify the arguments of the base datatype. If an int value is passed, changing the value does not affect the argument because you are changing a copy of the value

If you pass an int array, changing the contents of the array affects the argument, and changing the reference to the argument does not cause the argument to reference the new array object

Java objects are destroyed when the JVM exits, and if objects and their state need to be persisted, they need to be serialized, storing in-memory objects in a binary stream that can then be deserialized as needed. Object serialization holds the state of the object, so static variables that are class attributes are not serialized

Implementation of Serializabale tag interface, Java serialization retains object class metadata (such as classes, member variables, inherited class information) and object data, best compatibility, but does not support cross-language, performance is average. Serialization and deserialization must be consistent with the serialization ID. The private Static Final Long serialVersionUID is generally used to define the serialization ID. If not set, the compiler automatically generates this value based on the internal implementation of the class. The serialization ID should not be changed if it is a compatible upgrade to prevent errors, or it should be changed if it is an incompatible upgrade

JSON serialization converts a data object into a JSON string. The type information is discarded during the serialization process, so deserialization can only be performed accurately if the type information is provided. Compared with the previous two methods, it is more readable and convenient for debugging

Serialization usually uses network transmission objects, which often have sensitive data and are vulnerable to attack. Deserialization vulnerability has occurred in Jackson and Fastjson, so the transient keyword should be added when transferring sensitive attributes that do not need to be serialized. The purpose of transient is to limit the lifetime of a variable to memory and not write it to disk for persistence. The variable will be set to zero value of the corresponding data type

**equals: ** Checks whether objects are equal. By default, the equals method is used to compare object references. You can override the equals method to customize the comparison rule. Equals method specification: reflexivity, symmetry, transitivity, consistency, for any non-empty reference x, x.equals(null) returns false

**hashCode: **hashCode is an integer exported from an object. Each object has a default hashCode, which is derived from the object’s storage address. The string hash code is derived from the content and may have the same value. In order to use it correctly in a collection, you generally need to override both equals and hashCode, requiring that equals be the same, hashCode must be the same, hashCode is not necessarily the same as equals, so hashCode is a necessary and insufficient condition for objects to be equal

ToString: The default method for printing an object, if not overridden, to print a string representing the object’s value

Clone: The clone method is protected. A class can only clone its own objects using this method. It must be made public if it wants other classes to call this method. If an object’s class does not implement the Cloneable interface, the clone party is called to raise a CloneNotSupport exception. The default clone method is a shallow-copy. Overwriting the Clone method requires implementing the Cloneable interface and specifying the access modifier public

** Finalize: ** To determine the death of an object, it must be marked at least twice. If the object is found to have no reference chain connected with GC Roots after the reachabability analysis, it will be marked for the first time, and then it will be filtered once, and the condition is whether it is necessary for the object to execute the Finalize method. If the object has not overridden the method or if the method has been called by the virtual machine, it is considered unnecessary to execute. If necessary, the object is placed in an F-queue and executed by a low-priority Finalizer thread. The virtual machine fires this method, but it is not guaranteed to end. This is to prevent the Finalize method of an object from executing slowly or an infinite loop. As long as the object is re-associated with the object on the reference chain in the Finalize method, it will be removed from the collection on the second markup. Methods are marked as obsolete in JDK 9 and not suitable for releasing resources because they are expensive to run and cannot be called in a guaranteed order

**getClass: ** Returns the class object that contains the object information.

** Wait/notify/notifyAll: ** Blocks or wakes up the thread holding the lock

Does hashCode() get a hash, also known as a hashCode; It actually returns an int integer, and the purpose of this hash code is to determine the index position of the object in the hash table. HashCode () is defined in the JDK’s Object class, which means that any class in Java contains a hashCode() function

Hash table stores key-value pairs. It can quickly retrieve the corresponding value according to the key. That’s where the hash code comes in! (Can quickly find the desired object)

If two objects are equal, hashCode must be equal

Two objects are equal. Calling equals on both objects returns true

Two objects have the same hashCode value, but they are not necessarily equal

Therefore, if equals() is overridden, the hashCode() value must also be overridden

The default behavior of hashCode() is to generate unique values for objects on the heap. If hashCode() is not overridden, then two objects in this class will never be equal anyway (even if they point to the same data).

• == : This is used to determine whether the addresses of two objects are equal, that is, whether two objects are the same object (base datatype ** compares values, reference datatype ** compares memory addresses).

• Equals () : Also checks whether two objects are equal. But it can be used in two ways

  • Class does not override equals(), so comparing two objects of the class via equals() equals the equivalent of comparing them via **==**
  • This class overrides the equals() method. In general, we override the equals()** method to determine whether two objects are equal. If they are equal, it returns true

Note: The equals method on String is overridden, because the equals method on Object compares the memory addresses of objects, whereas the equals method on String compares the values of objects

When creating a String object, the virtual machine looks in the constant pool to see if there is an existing object with the same value as the value to be created. If there is an existing object, it assigns it to the current reference. If there is no existing object, it creates a String object in the constant pool

The JVM does not have special bytecode instructions for Boolean assignment. Boolean f = false is assigned using ICONST_0, the constant 0. Individual Boolean variables are replaced with int, and Boolean arrays are encoded as byte arrays

Java is an almost pure object-oriented programming language, but it has introduced a wrapper class for each primitive data type in order to be able to manipulate them as objects. The wrapper class for int is Integer, and since Java 5 automatic boxing/unboxing has been introduced to make them interchangeable

For object reference types: == Compares the memory address of the object. For basic data types: == compares values

If the Integer literal has a value between **-128 and 127 **, auto-boxing will not new a new Integer object, but will refer directly to an Integer object in the constant pool. Beyond the range A1 ==b1, the result is false

public static void main(String[] args) {
    Integer a = new Integer(3);
    Integer b = 3;  // Automatically box 3 into type Integer
    int c = 3;
    System.out.println(a == b); // false Two references do not refer to the same object
    System.out.println(a == c); // true a is automatically unpacked into int types and then compared with C
    System.out.println(b == c); // true

    Integer a1 = 128;
    Integer b1 = 128;
    System.out.println(a1 == b1); // false

    Integer a2 = 127;
    Integer b2 = 127;
    System.out.println(a2 == b2); // true
}
Copy the code

• Use directly+, the underlying implementation with StringBuilder. Only suitable for small quantities if used in loops+Concatenation, which is the equivalent of constantly creating new StringBuilder objects and converting them to Strings, is extremely inefficient
• Use the concat method of String, which is used in this methodArrays.copyOfCreate a new character array buf and copy the values of the current string value array into BUf, buf length = current string length + concatenation string length. After the callgetCharsMethods usingSystem.arraycopyThe value of the concatenated String is also copied to the buF array, and a new String object is returned with buf as the construction parameter new. Slightly more efficient than direct use+
• Use StringBuilder or StringBuffer, bothappendMethods all inherit from AbstractStringBuilder, which is used firstArrays.copyOfDetermine the new character array size, then callgetCharsMethods usingSystem.arraycopyAppends the new value to the array. StringBuilder was introduced in JDK5 and is efficient but not thread-safe. StringBuffer uses synchronized to ensure thread safety

• Objects in strings are immutable, which means they are thread safe.
• AbstractStringBuilderStringBuffer is the common parent of StringBuilder and StringBuffer. StringBuffer locks methods or methods that are called, so it is thread-safe. StringBuilder does not lock methods synchronously-so it is not thread-safe

• Use String if you operate on a small amount of data
• Single thread manipulation of large amounts of data using StringBuilder
• Multithreading manipulates large amounts of data using stringBuffers

• Modify variables

Any member variable or local variable (called a local variable ina method or code block) that is declared final is called final. Final variables are often used with the static keyword as constants

When final modifies a variable of base data, the initial value must be assigned and the reference variable cannot be modified. The reference variable cannot point to another object

An error is reported when final modifies a primitive datatype variable without assigning an initial value and when the reference variable points to another object

An error is reported when a final modifier base datatype variable is changed

• Modification methods

Final can also be declared as a method, and the final keyword means that the method cannot be overridden by a subclass method. You can also declare a method final if you think that the functionality of a method is complete enough that the subclass doesn’t need to change. Final methods are faster than non-final methods. Because it is statically bound at compile time, there is no need to bind at run time

• decorator

Classes that use final modifiers are called final classes. Final classes are usually complete and cannot be inherited. There are many classes in Java that are final, such as String, Integer, and other wrapper classes

• Annotation: an identifier that allows a class or excuse to attach additional information to help the compiler and JVM perform a particular function. For example, @Override identifies a method as an Override method.

• Meta-annotations: meta-annotations are annotations of custom annotations:

  • @ Target: The values are ElementType enumerated constants, including METHOD methods, VARIABLE variables, TYPE classes/interfaces, PARAMETER METHOD parameters, CONSTRUCTORS, and LOACL_VARIABLE local variables

  • @Retention: Constraint life cycle

    • SOURCE: valid in the SOURCE file, that is, retained in the SOURCE file
    • CLASS: valid in the CLASS file, that is, retained in the CLASS file
    • RUNTIME: valid at RUNTIME, i.e. reserved at RUNTIME

  • Documented: Indicates that this annotation should be Documented by a Javadoc tool and therefore Documented by a Javadoc class tool

  • @Inherited: This is an Annotation that indicates that an annotated type is Inherited. If an Annotation using the @Inherited Annotation is applied to a Class, it will be applied to the Class

/ * * *@author: zsy *@date: Created 2021/6/12 14:48 *@description: * /
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitProvider {
    // Supplier number
    public  int id(a) default- 1;
    // Vendor name
    public String name(a) default "";
    // Supplier address
    public  String address(a) default "";
}
Copy the code

Get annotation data by reflecting information

/ * * *@author: zsy *@date: Created 2021/6/12 14:53 *@description: Annotation processor */
public class FruitInfoUtil {

    public static void getFruitInfo(Class
        clazz) {
        System.out.println("Supplier Information");
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            FruitProvider annotation = declaredField.getAnnotation(FruitProvider.class);
            System.out.println(Supplier No. : + annotation.id());
            System.out.println(Name of Supplier: + annotation.name());
            System.out.println("Supplier address:"+ annotation.address()); System.out.println(annotation); }}}Copy the code

A static class defined inside a class is a static inner class

A static inner class can access static variables and methods of an external class. In a static inner class, you can define static variables, static methods, construct inverse functions, etc. The static inner class passes the outer class. Static inner class

A static inner class can access all the static variables of the outer class, but not the non-static variables of the outer class. Static inner class creation, new outer class. Static inner class (), as follows

/ * * *@author: zsy *@date: Created 2021/6/12 15:07 *@description: static inner class */
public class OuterClass {
    private static String className = "StaticInnerClass";

    public static class StaticInnerClass {
        public void getClassName(a) {
            System.out.println("The className."+ className); }}// Call the static inner class
    public static void main(String[] args) {
        StaticInnerClass staticInnerClass = newStaticInnerClass(); staticInnerClass.getClassName(); }}Copy the code

The Java collection class HashMap maintains an array of static inner class Nodes to hold elements. Node elements are transparent to users. Static inner classes can be used if they are closely related to external classes and do not depend on external class instances

An inner class defined in a method is a local inner class

When a class only needs to use a specific class in a method, it can be done elegantly with a local inner class

Local inner class is created in the corresponding method, new inner class ()

/ * * *@author: zsy *@date: Created 2021/6/12 15:26 *@description: local inner class */
public class OutClass {
    private  static int a;
    private int b;

    public void printClassTest(final int c) {
        final int d = 1;
        class PastClass {
            public void print(a) {
                System.out.println(c);
            }
        }
        PastClass pastClass = new PastClass();
        pastClass.print();
    }

    public static void main(String[] args) {
        OutClass outClass = new OutClass();
        outClass.printClassTest(10); }}Copy the code

• An anonymous inner class must inherit an abstract class or implement an interface
• Anonymous inner classes cannot define any static members or methods
• When the parameter of the method needs to be used by an anonymous inner class, it must be declared final
• An anonymous inner class cannot be abstract; it must implement an inherited class or interfaceAll abstract methods

• An inner class object can access the contents of the external object that created it, including private data
• Inner classes are not seen by other classes in the same package and have good encapsulation
• Inner classes effectively implement multiple inheritance, optimizing the shortcomings of Java single inheritance
• Anonymous inner classes make it easy to define callbacks

Because the lifecycle is different, local variables are stored directly on the stack, and non-final local variables are destroyed when the method execution ends. The local inner class reference to the local variable still exists, if the local inner class to call the local variable will be wrong, add final, can ensure that the variables used by the local inner class and the outer local variable are separated, solve this problem

/ * * *@author: zsy *@date: Created 2021/6/12 15:50 *@description: Tests final */
public class OuterClass {
    private int age = 12;

    class Inner {
        private int age = 13;

        public void print(a) {
            int age = 14;
            System.out.println("Local variable:" + age);
            System.out.println("Inner class variable:" + this.age);
            System.out.println("External class variable:" + OuterClass.this.age); }}public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.new Inner(a).print(a); }}Copy the code

• Abstract classes represent is-A relationships, and interfaces represent Can-do relationships. In contrast to interfaces, abstract classes are relatively concrete abstractions of the same kind of transaction
• Abstract class is template design, including a group of specific features, such as a car, chassis, control circuit and so on are common features abstracted out, but the interior, display screen, seat material can be different according to different levels of configuration
• The interface is designed by contract and is open. It defines method names, parameters, return values, and the types of exceptions thrown. Anyone can implement it, but they must follow the conventions of the interface. For example, all vehicles must apply brakes
• Interface is a top class, abstract class is on the second floor of the interface, the interface combination, and then implements the part of the interface, when entangled with defined interfaces and abstract classes, recommended defined as interface, follow the interface segregation principle, according to the dimensions into multiple interfaces, reuse abstract classes to implement these, facilitate subsequent extension and reconstruction

The nature of generics is to parameterize types and solve the problem of not knowing the exact type of an object. Generics by definition only have the ability to execute Object methods

Benefits of generics:

• Type safe, whatever comes out, no ClassCastException, okay
• To improve readability, the coding phase displays object types that know how generic collections, generic methods, and so on are handled
• Code reuse, combining the same type of processing code

Generic limit

• Limits on generic limits<? extends T>: indicates that the type represented by the wildcard is a subclass of type T or several subinterfaces of type T
• Lower limit on renovation<? super T>: indicates that the type represented by the wildcard is the parent class or parent interface of type T

The initial capacity is 10

In JDK1.7, equivalent to handedness, the first time a no-argument constructor is created, an array of initial capacity 10 is created

In JDK1.8, equivalent to slob, the default initial capacity is allocated only when the add is fully added

Array-to-list: Use arrays.aslist () for the conversion

List toArray: use the toArray() method that comes with List

• Data structure implementation: ArrayList is a data structure implementation of dynamic arrays, while LinkedList is a data structure implementation of bidirectional linked lists
• ArrayList is faster to query and access, but slower to add and delete, and LinkedList is slower to find and access elements, but faster to add and delete
• Arraylists require a contiguous memory space, linkedLists do not require a contiguous memory space (in particular, when creating a collection of ArrayLists, the contiguous memory space must be greater than or equal to the created capacity).
• Both are thread-unsafe

In general, ArrayList is recommended for frequent reads of elements in a collection, and LinkedList is recommended for heavy inserts and deletions

Fail-fast is a Java collection error detection mechanism that can be used when multiple threads make structural changes to a collection

Iterators access the contents of the collection directly during traversal and use a modCount variable during traversal. If the contents of the collection change during traversal, the value of modCount is changed. Whenever the iterator iterates over the next element using hashNext()/next(), it checks whether the modCount variable is the expectedmodCount value and returns the traversal if it is; Otherwise, an exception is thrown and the traversal is terminated

You can use the collections.unmodifiablecollection (Collection C) method to create a read-only Collection, This change of set any operation will throw Java. Lang. UnsupportedOperationException anomalies

The Iterator interface provides an interface to iterate over any Collection. We can get an iterator instance from a Collection using the iterator method. Iterators replace Enumeration in the Java collection framework by allowing callers to remove elements during iteration

Iterator features: only one-way traverse, but more security, because it can guarantee that in the current traverse a collection of elements are changed, will throw ConcurrentModificationException

How do I iterate over and delete elements in a Collection

Iterator<Integer> it = list.iterator();
while(it.hasNext()){
   *// do something*it.remove(); } list.remove(I)Copy the code

TreeMap is implemented based on a red-black tree. The average and worst time complexity of adding, deleting, modifying, and querying is O(LOGN). The Key is ordered

HashMap relies on hashCode and equals to cancel weights, while TreeMap relies on Comparable or Comparator. TreeMap sorted, if the comparator is not null would prefer using the comparator compare method, or use the Key to achieve Comparable compareTo method, neither meet throws an exception

The operation of red-black trees is described in HashMap

Here O1 represents the preceding object and O2 represents the following object

Return -1 (or negative) to indicate that 01 and 02 do not need to be swapped, o1 is placed before O2, and ASC returns 1 (or positive) to indicate that 01 and 02 need to be swapped, o1 is placed after O2, and desc

HashMap, Hashtable, ConcurrentHashMap (1.7, 1.8) source analysis + red-black tree

Four groups of API

IO and NIO

Blocking and non-blocking are ways of dealing with whether the data is ready when the process accesses it.

When data is not prepared

Blocking: It is often necessary to wait until the data in the buffer is ready before doing anything else, or else wait forever.

Non-blocking: When our process accesses our data buffer, if the data is not ready, it returns without waiting, and if the data is ready, it returns

Synchronous and asynchronous are communication mechanisms, and blocking and non-blocking are invocation states

• Synchronous I/O synchronization means that the user thread initiates an I/O request and waits or polls the kernel for the I/O operation to complete
• Asynchronous I/O means that the user thread can continue to execute the I/O request. When the kernel completes the I/O operation, it notifies the user thread or invokes the callback function registered by the user thread
• Blocking I/O indicates that the I/O operation can be returned to user space only after it is complete
• Non-blocking I/O returns a status value immediately after an I/O operation is invoked, without waiting for the OPERATION to complete

NIO is a synchronous non-blocking IO model introduced in Java 1.4, corresponding to the java.nio package, which provides abstractions such as channels, selectors, and buffers. N in NIO can be interpreted as non-blocking, not just New. It supports buffer-oriented, channel-based approaches to I/O operations. NIO provides two different Socket channel implementations, SocketChannel and ServerSocketChannel, that correspond to Socket and ServerSocket in the traditional BIO model. Both channels support both blocking and non-blocking modes. For high-load, high-concurrency (network) applications, NIO’s non-blocking mode should be used for development

NIO non-blocking mode, is a thread from one channel to send request to read data, but it can only get the currently available data, if there is no data is available, you can get nothing, rather than keep thread block, so until data becomes can read, this thread can continue to do other things, a non-blocking write also is so, A thread requests to write some data to a channel, but without waiting for it to write completely, the thread can do something else in the meantime. Threads typically spend idle time of non-blocking IO performing IO operations on other channels, so a single thread can now manage multiple input and output channels

Buffer is a Buffer, which is actually a container, a continuous array. Channel provides a Channel to read data from a file or network. However, the read and write data must pass through Buffer

A Buffer is essentially a block of memory from which data can be written and then read. The block of memory is wrapped as a NIO Buffer object and provides a set of methods for easy access to the module’s memory. To understand how Buffer works, you need to be familiar with its three properties:

• Position: position where data is read or written next time
• Limit: indicates the limit position of read and write operations
• Capacity: indicates the maximum capacity

How to use it: Write data to Buffer, call flip to switch to read mode, read data from Buffer, and call clear or Compact to clear the Buffer

• flipSet position to 0 and limit to the current position
• clearConvert read to write mode (for reading all data, set position to 0 and limit to Capacity)
• compactConvert read to write mode (used when there is unread data and position points to the next unread data)

The direction of the channel is opposite to that of the Buffer. Reading data is equivalent to writing data to and reading data from the Buffer

• According to the flow direction, the flow can be divided into input flow and output flow
• According to the operation unit, it can be divided into byte stream and character stream
• Flows are divided into node flows and processing flows according to their roles

Character streams are used for text files, and byte streams are used for images and other files

The character stream includes the character inputStream Reader and the character OutputStream Writer. The byte stream includes the byte inputStream inputStream and the byte OutputStream OutputStream.

Character streams and byte streams have corresponding buffer streams. Byte streams can also be divided into character streams. The buffer stream has an 8KB buffer array to improve the read and write efficiency of the stream.

In addition to buffering streams, there are FilterReader, CharArrayReader, ByteArrayInputStream, and FileInputStream

Simplifies anonymous inner class code by allowing functions to be passed as arguments to methods

• Why Lambda expressions

  • Avoid overdefining anonymous inner classes
  • The code can look neat

• Definition of a functional interface

  • Any interface that contains only one abstract method is a functional interface

  public interface Runnable {
      public abstract void run(a);
  }
  Copy the code

  • For a functional interface, we can create its interface object through a Lambda expression

  interface Love {
      void lambda(int a);
  }
  
  Love love = (inta) -> {... }Copy the code

• Lambda expression simplification

  • Remove parameter types

  love = (a) -> {... }Copy the code

  • Remove the parenthesis

  love = a -> {... }Copy the code

  • Remove curly braces

  love = a -> ...
  Copy the code

  • Multiple parameter case

  love = (a, b, c) -> ...
  Copy the code

Enter type T to return Boolean

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
Copy the code

The instance

/ * * *@author: zsy *@date: Created 2021/4/21 19:29 *@description: Indicates a qualitative interface */
public class Demo2 {
    public static void main(String[] args) {
        Predicate<String> predicate = str -> {returnstr.isEmpty(); }; predicate.test("zhangsan"); }}Copy the code

Only return type, no input type

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get(a);
}
Copy the code

The instance

/ * * *@author: zsy *@date: Created 2021/4/21 19:37 *@description: consumer interface and supply interface */
public class Demo3 {

    public static void main(String[] args) {
        Consumer<String> consumer = o -> System.out.println(o);

        Supplier<Integer> supplier = () -> 1024; }}Copy the code

The interface can define default methods modified by default, reducing the complexity of interface upgrades, and static methods can be defined.

Strengthened type speculation mechanism, making the code more concise.

The introduction of functional programming style, providing a lot of functionality, make the code more concise. Methods include forEach traversal, count statistics, filter based on conditions, limit taking the first N elements, Skip skipping the first N elements, Map mapping processing, concat merging stream, etc.

A new JavaScript engine is provided that allows specific JavaScript applications to run on the JVM.