Häufige Java-Interviewfragen (mit Antworten)

Wie implementiert man eine Warteschlange mithilfe eines Arrays?

Wenn wir ein Array zum Implementieren einer Warteschlange verwenden, müssen wir auf das Überlaufphänomen achten. In diesem Fall können wir das Problem mithilfe der Schleife des Arrays lösen, d. h. durch Verbinden Enden des Arrays. Verwenden Sie den vorderen Zeiger, um auf die erste Position der Warteschlange zu zeigen, und den hinteren Zeiger, um auf die letzte Position der Warteschlange zu zeigen. (Empfohlene Studie: Allgemeine Java-Interviewfragen)

Wenn eine innere Klasse auf eine lokale Variable zugreift, warum muss die Variable dann mit final geändert werden?

Weil der Lebenszyklus anders ist. Lokale Variablen werden nach Beendigung der Methode zerstört, das innere Klassenobjekt wird jedoch nicht unbedingt zerstört. Dies führt dazu, dass die innere Klasse auf eine nicht vorhandene Variable verweist.

Der Compiler generiert also eine Kopie der lokalen Variablen in der inneren Klasse. Der Lebenszyklus dieser Kopie ist der gleiche wie der des inneren Klassenobjekts, sodass die oben genannten Probleme nicht auftreten.

Dies führt jedoch zu dem Problem, dass bei einer Änderung einer der Variablen die Werte der beiden Variablen unterschiedlich sein können. Um dieses Problem zu lösen, erfordert der Compiler, dass lokale Variablen endgültig geändert werden müssen, um sicherzustellen, dass die beiden Variablen denselben Wert haben.

Nach JDK8 verlangt der Compiler nicht, dass lokale Variablen, auf die von inneren Klassen zugegriffen wird, endgültig geändert werden müssen, lokale Variablenwerte können jedoch nicht geändert werden (weder in Methoden noch in inneren Klassen), da sonst ein Kompilierungsfehler auftritt gemeldet. Wenn Sie Javap verwenden, um den kompilierten Bytecode anzuzeigen, können Sie feststellen, dass der Compiler final hinzugefügt hat.

long s = 499999999 * 499999999 Welchen Wert hat s im obigen Code?

Den Berechnungsergebnissen des Codes zufolge sollte der Wert von s -1371654655 sein. Dies liegt daran, dass die Berechnung des rechten Werts in Java standardmäßig den Typ int verwendet.

Können nicht statische innere Klassen statische Methoden definieren?

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

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

Der obige Code verursacht einen Kompilierungsfehler, da nur statische innere Klassen statische Methoden definieren können.

Was ist der Unterschied zwischen Lock und Synchronized?

1. 使用方法的区别
- **Synchronized**：在需要同步的对象中加入此控制，`synchronized`可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。
- **Lock**：需要显示指定起始位置和终止位置。一般使用`ReentrantLock`类做为锁，多个线程中必须要使用一个`ReentrantLock`类做为对象才能保证锁的生效。且在加锁和解锁处需要通过`lock()`和`unlock()`显示指出。所以一般会在`finally`块中写`unlock()`以防死锁。
2. 性能的区别
`synchronized`是托管给JVM执行的，而`lock`是java写的控制锁的代码。在Java1.5中，`synchronize`是性能低效的。因为这是一个重量级操作，需要调用操作接口，导致有可能加锁消耗的系统时间比加锁以外的操作还多。相比之下使用Java提供的Lock对象，性能更高一些。但是到了Java1.6，发生了变化。`synchronize`在语义上很清晰，可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。导致在Java1.6上`synchronize`的性能并不比Lock差。
  - **Synchronized**：采用的是CPU悲观锁机制，即线程获得的是独占锁。独占锁意味着 **其他线程只能依靠阻塞来等待线程释放锁**。而在CPU转换线程阻塞时会引起线程上下文切换，当有很多线程竞争锁的时候，会引起CPU频繁的上下文切换导致效率很低。
  - **Lock**：用的是乐观锁方式。所谓乐观锁就是，**每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止**。乐观锁实现的机制就是`CAS`操作。我们可以进一步研究`ReentrantLock`的源代码，会发现其中比较重要的获得锁的一个方法是`compareAndSetState`。这里其实就是调用的CPU提供的特殊指令。
3. `ReentrantLock`：具有更好的可伸缩性：比如时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者锁投票。

Wie schneidet eine Float-Variable im Vergleich zu 0 ab?

Es gibt Folattypen und Doppeltypen. Die Wahrscheinlichkeit, dass diese Dezimaltypen direkt 0 sind, nähert sich 0 unendlich, daher kann = nicht verwendet werden. Es sollte nach |x-0|

//用程序表示就是

fabs(x) < 0.00001f

Wie erstelle ich eine neue nicht statische innere Klasse?

Die innere Klasse muss Outer.Inner a sein, wenn sie deklariert wird, genau wie int a. Was die statische innere Klasse und die nicht statische innere Klasse new betrifft, gibt es einen kleinen Unterschied:

Outer.Inner a = new Outer().new Inner() (nicht statisch, es muss ein Outer-Objekt vorhanden sein, bevor die neue innere Klasse erstellt werden kann)

Outer.Inner a = new Outer.Inner( ) (statische innere Klasse)

Benennungsregeln für Java-Bezeichner

können Folgendes enthalten: Buchstaben, Zahlen, $, _ (Unterstrich), dürfen nicht mit einer Zahl beginnen und dürfen nicht Dies können Java-Schlüsselwörter oder reservierte Wörter sein.

Welche Entwurfsmuster kennen Sie, die in JDK verwendet werden?

Dekorationsmodus: java.io

Singleton-Modus: Laufzeitklasse

Einfacher Factory-Modus: Integer.valueOf-Methode

Fliegengewichtsmodus: String Konstantenpool, Integer.valueOf(int i), Character.valueOf(char c)

Iteratormodus: Iterator

Verantwortungskettenmodus: Das übergeordnete Delegationsmodell von ClassLoader

Interpreter Modus: Regulärer Ausdruck java.util.regex.Pattern

Wie ConcurrentHashMap Thread-Sicherheit gewährleistet

JDK 1.7 und früher:

ConcurrentHashMap ermöglicht mehrere Änderungsvorgänge Der Schlüssel liegt in der Verwendung der Lock-Separation-Technologie. Es verwendet mehrere Sperren, um Änderungen an verschiedenen Teilen der Hash-Tabelle zu steuern. ConcurrentHashMap verwendet intern Segmente, um diese verschiedenen Teile darzustellen. Jedes Segment ist eigentlich eine kleine Hash-Tabelle und sie haben ihre eigenen Sperren. Mehrere Änderungsvorgänge können gleichzeitig ausgeführt werden, solange sie in verschiedenen Segmenten erfolgen.

JDK 1.8:

Obwohl Segment beibehalten wird, wurden seine Attribute vereinfacht, um mit älteren Versionen kompatibel zu sein.

Verwenden Sie beim Einfügen den CAS-Algorithmus: unsafe.compareAndSwapInt(this, valueOffset, Expect, Update). CAS (Compare And Swap) bedeutet, dass, wenn der in der ValueOffset-Position enthaltene Wert mit dem erwarteten Wert übereinstimmt, der Wert der ValueOffset-Position aktualisiert wird, um zu aktualisieren und true zurückzugeben. Andernfalls erfolgt keine Aktualisierung und es wird false zurückgegeben. Der Schlüssel oder Wert darf beim Einfügen nicht null sein

Es ähnelt der HashMap von Java8. Die unterste Ebene besteht immer noch aus einem rot-schwarzen „Array“-Baum Struktur speichert TreeBin-Objekte und kein TreeNode-Objekt;

CAS ist ein bekannter sperrenfreier Algorithmus. Hat ConcurrentHashMap also keine Sperren? Natürlich nicht. Wenn der Hash-Wert mit dem Kopfknoten der verknüpften Liste übereinstimmt, wird er dennoch synchronisiert und gesperrt, und die verknüpfte Liste wird gesperrt.

Sowohl sleep() als auch yield() geben die CPU frei.

sleep() kann Threads mit niedriger Priorität eine Chance zur Ausführung geben. Natürlich kann es auch Threads mit derselben Priorität eine Chance geben, und yield() kann nur Threads mit derselben Ausführungsmöglichkeit geben Priorität eine Chance zur Ausführung Es besteht eine Chance zur Ausführung.

Thread.sleep und Thread.yield() führen nicht dazu, dass sich das Sperrverhalten ändert. Wenn der aktuelle Thread die Sperre besitzt, lässt Thread.sleep den Thread die Sperre nicht frei. Wenn es Ihnen hilft, sich daran zu erinnern, können Sie einfach denken, dass die sperrenbezogenen Methoden in der Object-Klasse definiert sind, sodass der Aufruf von Thread.sleep das sperrenbezogene Verhalten nicht beeinflusst.

Thread.sleep und Object.wait unterbrechen den aktuellen Thread. Unabhängig davon, welcher Thread angehalten ist, bedeutet dies, dass er keine CPU-Ausführungszeit mehr benötigt. Das Betriebssystem weist anderen Threads Ausführungszeit zu. Der Unterschied besteht darin, dass nach dem Aufruf von wait andere Threads notify/notifyAll ausführen müssen, um die CPU-Ausführungszeit zurückzugewinnen.

Was ist der Unterschied zwischen Arraylist und Linkedlist?

Sowohl ArrayList als auch LinkedList implementieren die List-Schnittstelle, es gibt jedoch einige Unterschiede zwischen ihnen.

(1) ArrayList ist eine Datenstruktur, die auf einem von Array unterstützten Index basiert und daher wahlfreien Zugriff auf Elemente ermöglicht.

(2) Im Vergleich zu ArrayList ist das Einfügen, Hinzufügen und Löschen eines Elements möglich schneller sein

(3) LinkedList verbraucht mehr Speicher als ArrayList, da jeder Knoten in LinkedList die Referenz des vorherigen und folgenden Knotens speichert

Das obige ist der detaillierte Inhalt vonHäufige Java-Interviewfragen (mit Antworten). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!