Summary of often forgotten Java interview questions

Static classes and static methods

If a class is to be declared as static, there is only one situation, which is a static inner class.

Static inner classes are actually the same as ordinary classes (that is, top-level classes whose class names must be the same as the file names), except that static inner classes are defined inside a certain class. Since they are classes, if you want to use It must be instantiated. Conceptually, they are different from static variables and static methods. Don’t be confused by the word “static” (don’t think that all static things can be used directly without instantiation. Static inner classes are There is a difference), and there are only static inner classes, but there is no concept of static classes (top-level classes).

e.g.

public class Singleton{
    private Singleton(){}

    private static class SingletonHolder{
        private final static Singleton instance;
    }

    public Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

Static methods can only access static members, and instance methods can access static and instance members. The reason why static methods are not allowed to access instance member variables is because instance member variables belong to a certain object, and the object does not necessarily exist when the static method is executed. The keyword this cannot be used in static methods.

Inverted Index

Inverted Index

It may be easier to understand if translated into a transposed index, which is equivalent to a matrix transpose.

Inverted index is an indexing method that is used to store the mapping of the storage location of a word in a document or a group of documents under full-text search.

Reflection

ReflectionThe dynamic proxy provided in API is also a very powerful function that can natively implement the method interception function in AOP. Just like the meaning of the English word reflection, using the reflection API is like looking at the reflection of a Java class in water. After knowing the internal structure of a Java class, you can interact with it, including creating new objects and calling methods in the objects.

This interaction method has the same effect as using it directly in the source code, but it provides additional runtime flexibility. One of the biggest drawbacks of using reflection is poor performance. For the same operation, the time required to use the reflection API is probably one or two orders of magnitude slower than using it directly. However, in the current JVM implementation, the performance of reflection operations has been greatly improved.

The first main function of the Java reflection API is to obtain the internal structure of the program at runtime.

Multi-way merge algorithm

Merge sort is also an effective sorting algorithm implemented using the divide-and-conquer method. It was invented by John von Neumann, the founder of modern computers, in 1945.

Merge sort is a stable sort among many sorting algorithms and has good efficiency. At the same time, merge sort can be used not only for internal sorting, but also for external sorting.

The idea of ​​​​merging sort is as follows (taking two-way merging as an example):

• Divide the array into two sub-arrays;

• Sort the two word arrays;

• Merge the two sorted word arrays.

The so-called N-way merge refers to dividing the array into N sub-arrays, sorting the sub-arrays and then merging them. Therefore, two-way merge is the most general case of merge sort.

e.g.

##Legend

def msort(array):
    length = len(array)
    if length == 1:
        return array
    else:
        mid = length / 2
        left = msort(array[0: mid])
        right = msort(array[mid: length])
        return merge(left, right)

Non-recursive

def msort(array):
    length = len(array)
    step = 1
    while step < length:
        for left in range(0, length - step, 2 * step):
            result = merge(array[left:left + step],
                           array[left + step: min(left + 2 * step,
             length)])
            array = array[0:left] + result + array[min(left + 2 *
                                                       
           step, length)]
        step = step * 2
    return array

def merge(left, right):
    llen = len(left)
    lcur = 0
    rlen = len(right)
    rcur = 0
    result = []
    while lcur < llen and rcur < rlen:
        lone = left[lcur]
        rone = right[rcur]
        result.append(min(lone, rone))
        if lone < rone:
            lcur += 1
        else:
            rcur += 1
    result += left[lcur:]
    result += right[rcur:]
    return result

Enumerated Type

Enumerated Type

enum type does not support the
• constructor

  of the public and protected modifiers, so the constructor must be private or friendly. Because of this, the enumeration object cannot be initialized in the program by directly calling its constructor.

Since the enum type value is actually represented by an object constructed during runtime, in the cluster environment, each virtual machine will construct a synonymous enumeration object. . Therefore, you need to pay attention when doing comparison operations. If you directly use the equal sign (‘==’) operator, these seemingly identical enumeration values ​​must not be equal, because they are not the same object instance.
Multi-threading

There are two ways to implement multi-threading in Java: inheriting the Thread class and implementing the Runnable interface. As long as it is multi-threaded in program development, it must always be Mainly implement the Runnable interface, because implementing the Runnable interface has the following advantages compared to inheriting the Thread class:

1. It can avoid the limitations caused by the single inheritance feature of Java;

2. Enhance the robustness of the program, the code can be shared by multiple threads, and the code and data are independent;

3. It is suitable for situations where multiple thread areas of the same program code process the same resource.

The following is a multi-threaded program implemented by implementing the Runnable interface. The code is as follows:

lass MyThread implements Runnable{  
    private int ticket = 5;  
    public void run(){  
        for (int i=0;i<10;i++)  
        {  
            if(ticket > 0){  
                System.out.println("ticket = " + ticket--);  
            }  
        }  
    }  
}  

public class RunnableDemo{  
    public static void main(String[] args){  
        MyThread my = new MyThread();  
        new Thread(my).start();  
        new Thread(my).start();  
        new Thread(my).start();  
    }  
}

The above is the detailed content of Summary of often forgotten Java interview questions. For more information, please follow other related articles on the PHP Chinese website!