How to implement a queue using an array?

When using an array to implement a queue, we must pay attention to the overflow phenomenon. In this case, we can use the method of looping the array to solve it, that is, connecting the ends of the array. Use the front pointer to point to the first position of the queue and the tail pointer to point to the last position of the queue. (Recommended study: java common interview questions)

When an internal class accesses a local variable, why must the variable be modified with final?

Because the life cycle is different. Local variables will be destroyed after the method ends, but the inner class object will not necessarily be destroyed. This will cause the inner class to reference a variable that does not exist.

So the compiler will generate a copy of the local variable in the inner class. The life cycle of this copy is the same as the inner class object, so the above problems will not occur.

But this leads to the problem that one of the variables is modified and the values ??of the two variables may be different. In order to solve this problem, the compiler requires that local variables need to be final modified to ensure that the two variables have the same value.

After JDK8, the compiler does not require that local variables accessed by inner classes must be final modified, but the value of local variables cannot be modified (either in a method or in an inner class), otherwise a compilation error will be reported. Using javap to view the compiled bytecode, you can find that the compiler has added final.

long s = 499999999 * 499999999 In the above code, what is the value of s?

According to the calculation result of the code, the value of s should be -1371654655. This is because the calculation of the right-hand value in Java defaults to the int type.

Can non-static inner classes define static methods?

public class OuterClass{
    private static float f = 1.0f;

    class InnerClass{
        public static float func(){return f;}
    }
}

The above code will cause a compilation error, because only static inner classes can define static methods.

What is the difference between Lock and Synchronized?

1. 使用方法的區(qū)別
- **Synchronized**：在需要同步的對象中加入此控制，`synchronized`可以加在方法上，也可以加在特定代碼塊中，括號中表示需要鎖的對象。
- **Lock**：需要顯示指定起始位置和終止位置。一般使用`ReentrantLock`類做為鎖，多個線程中必須要使用一個`ReentrantLock`類做為對象才能保證鎖的生效。且在加鎖和解鎖處需要通過`lock()`和`unlock()`顯示指出。所以一般會在`finally`塊中寫`unlock()`以防死鎖。
2. 性能的區(qū)別
`synchronized`是托管給JVM執(zhí)行的，而`lock`是java寫的控制鎖的代碼。在Java1.5中，`synchronize`是性能低效的。因為這是一個重量級操作，需要調用操作接口，導致有可能加鎖消耗的系統(tǒng)時間比加鎖以外的操作還多。相比之下使用Java提供的Lock對象，性能更高一些。但是到了Java1.6，發(fā)生了變化。`synchronize`在語義上很清晰，可以進行很多優(yōu)化，有適應自旋，鎖消除，鎖粗化，輕量級鎖，偏向鎖等等。導致在Java1.6上`synchronize`的性能并不比Lock差。
  - **Synchronized**：采用的是CPU悲觀鎖機制，即線程獲得的是獨占鎖。獨占鎖意味著 **其他線程只能依靠阻塞來等待線程釋放鎖**。而在CPU轉換線程阻塞時會引起線程上下文切換，當有很多線程競爭鎖的時候，會引起CPU頻繁的上下文切換導致效率很低。
  - **Lock**：用的是樂觀鎖方式。所謂樂觀鎖就是，**每次不加鎖而是假設沒有沖突而去完成某項操作，如果因為沖突失敗就重試，直到成功為止**。樂觀鎖實現的機制就是`CAS`操作。我們可以進一步研究`ReentrantLock`的源代碼，會發(fā)現其中比較重要的獲得鎖的一個方法是`compareAndSetState`。這里其實就是調用的CPU提供的特殊指令。
3. `ReentrantLock`：具有更好的可伸縮性：比如時間鎖等候、可中斷鎖等候、無塊結構鎖、多個條件變量或者鎖投票。

How do float variables compare to 0?

There are folat types and double types. The possibility of these decimal types directly equaling 0 when approaching 0 is very small. Generally, they approach 0 infinitely, so = cannot be used. = to judge. It should be judged by |x-0|

//用程序表示就是

fabs(x) < 0.00001f

How to create a new non-static inner class?

The inner class must be Outer.Inner a when declared, just like int a. As for the static inner class and the non-static inner class new, there is a difference:

Outer.Inner a = new Outer().new Inner() (non-static, there must be an Outer object before the new inner class can be created)

Outer.Inner a = new Outer.Inner()(static inner class)

Java identifier naming rules

Can contain: letters, numbers, $, _ (underscore), cannot start with a number, and cannot be Java keywords or reserved words.

What design patterns do you know used in JDK?

Decoration mode: java.io

Single case mode: Runtime class

Simple factory mode: Integer.valueOf method

Flyweight mode ：String constant pool, Integer.valueOf(int i), Character.valueOf(char c)

Iterator mode: Iterator

Chain of responsibility mode: ClassLoader’s parent delegation model

Interpreter mode: Regular expression java.util.regex.Pattern

How ConcurrentHashMap ensures thread safety

JDK 1.7 and before:

ConcurrentHashMap allows multiple modification operations to be performed concurrently. The key is the use of lock separation technology. It uses multiple locks to control modifications to different parts of the hash table. ConcurrentHashMap uses segments internally to represent these different parts. Each segment is actually a small hash table, and they have their own locks. Multiple modification operations can occur concurrently as long as they occur on different segments.

JDK 1.8:

Although Segment is retained, its attributes have been simplified just to be compatible with older versions.

Use CAS algorithm when inserting: unsafe.compareAndSwapInt(this, valueOffset, expect, update). CAS (Compare And Swap) means that if the value contained in the valueOffset position is the same as the expect value, then update the value of the valueOffset position to update and return true, otherwise it will not update and return false. The key or value is not allowed to be null when inserting

It is similar to Java8's HashMap. The bottom layer still consists of an "array" linked list red-black tree;

The bottom structure stores TreeBin objects, and Not a TreeNode object;

CAS is a well-known lock-free algorithm, so does ConcurrentHashMap have no locks? Of course not, when the hash value is the same as the head node of the linked list, it will still be synchronized and locked, and the linked list will be locked.

The difference between Thread.sleep() & Thread.yield()&Thread.wait()

Both sleep() and yield() will release the CPU.

sleep() can give low-priority threads a chance to execute. Of course, it can also give threads of the same priority and high-priority a chance to execute; yield() can only give threads of the same priority a chance to execute. There is a chance of execution.

Thread.sleep and Thread.yield() will not cause the lock behavior to change. If the current thread owns the lock, then Thread.sleep will not let the thread release the lock. If it helps you remember, you can simply think that the lock-related methods are defined in the Object class, so calling Thread.sleep will not affect the lock-related behavior.

Thread.sleep and Object.wait will suspend the current thread. For CPU resources, no matter which thread is suspended, it means that it no longer requires CPU execution time. The OS will allocate execution time to other threads. The difference is that after calling wait, other threads need to execute notify/notifyAll to regain the CPU execution time.

What is the difference between arraylist and linkedlist?

Both ArrayList and LinkedList implement the List interface, but there are some differences between them.

(1) ArrayList is a data structure based on an index supported by Array, so it provides random access to elements

(2) Compared with ArrayList, inserting, Adding and deleting an element will be faster

(3) LinkedList consumes more memory than ArrayList because each node in LinkedList stores the reference of the previous and following nodes

The above is the detailed content of Common Java interview questions (with answers). For more information, please follow other related articles on the PHP Chinese website!