2020 Java核心面試問題 100+(附代碼)

[本文參考原文地址]http://bjbsair.com/2020-03-09/it/1875/

毋庸置疑，Java是得到豐厚薪資的主要編程選擇之一。畢竟，基於類的通用，面向對象的編程語言是世界上使用最普遍的編程語言之一。

Java面試問題

具備許多強大的功能，編程語言不只是經驗豐富的專家的首選，並且是編程領域的新手所追求的。所以，這裏有一些重要的Java面試問題，能夠幫助您完成Java工做，或者至少能夠提升您的學習水平。

問題：什麼是Java？

答： Java是一種最初由James Gosling設計並由Oracle Corporation進一步開發的面向對象的高級通用編程語言。它是世界上最受歡迎的編程語言之一。

問題：構造函數是什麼意思？

答：構造函數是一種與其所屬類具備相同名稱的方法。一旦建立了新對象，就會調用與該類相對應的構造函數。 儘管用戶能夠顯式建立一個構造函數，可是一旦建立一個類，它就會本身建立。這被稱爲默認構造函數。構造函數能夠重載。

注意：若是顯式建立的構造函數具備參數，則必須建立另外一個沒有參數的構造函數。

問：Java有什麼功能？

答：如下是Java編程語言的各類功能：

• 高性能–使用JIT（即時）編譯器能夠提升Java的性能。JIT編譯器將Java字節碼轉換爲機器語言代碼，而後由JVM執行
• 多線程–線程是執行流程。JVM建立一個稱爲主線程的線程。Java容許經過擴展線程類或實現Runnable接口來建立多個線程
• OOPS概念– Java遵循各類OOPS概念，即抽象，封裝，繼承，面向對象和多態性
• 平臺獨立性 –Java利用Java虛擬機或JVM，使單個Java程序無需修改便可在多個平臺上運行

問題：Java如何實現高性能？

答：在即時編譯中，所需的代碼在運行時執行。一般，它涉及將字節碼轉換爲機器代碼，而後直接執行它。爲了實現高性能，Java能夠利用即時編譯。 JIT編譯器默認在Java中處於啓用狀態，並在調用方法後當即被激活。而後，它將Java方法的字節碼編譯爲本地機器代碼。此後，JVM直接調用已編譯的代碼，而不是對其進行解釋。這能夠提升性能。

問題：Java IDE對您有什麼瞭解？

答：Java IDE是容許Java開發人員輕鬆編寫和調試Java程序的軟件。它基本上是各類編程工具的集合，可經過單個界面訪問，並具備一些有用的功能，例如代碼完成和語法突出顯示。 Codenvy，Eclipse和NetBeans是一些最受歡迎的Java IDE。

問題：請解釋Java中的局部變量和實例變量。

答：只能在聲明它們的方法或代碼塊中訪問的變量稱爲局部變量。另外一方面，實例變量可被類中的全部方法訪問。 雖然局部變量在方法或代碼塊內部聲明，而實例變量在類內部但方法外部聲明。 即便未分配，實例變量的值也能夠爲null，0、0.0或false。須要分配值的局部變量不是這種狀況，不然分配值將產生錯誤。 調用方法時會自動建立局部變量，並在方法退出後當即銷燬。要建立實例變量，必須使用_new_關鍵字。

問題：什麼是對象？

答：Java類的實例稱爲對象。Java對象的兩個重要屬性是行爲和狀態。JVM遇到_new_關鍵字後，即會建立一個對象。(https://stackoverflow.com/questions/18219339/trouble-understanding-object-state-behavior-and-identity)

問題：您能解釋一下OOPS概念嗎？

答：如下是各類OOPS概念：

• 抽象–表示基本功能，而無需給出背景細節。該技術用於爲某些特定應用建立新的合適數據類型
• 聚合–全部對象都有各自的生命週期，但存在全部權。子對象除父對象外，不能屬於其餘對象
• 關聯–兩個對象之間的關係，其中每一個對象都有其獨立的生命週期。沒有全部權
• 類–一組類似的實體
• 組合–也稱爲死亡關係，它是彙集的一種特殊形式。子對象沒有生命週期。這樣，若是刪除了關聯的父對象，它們會自動被刪除
• 封裝–指將數據和代碼包裝到單個實體中。容許類的變量只能由父類訪問，而不能由其餘類訪問
• 繼承–當對象獲取其餘對象的屬性時，稱爲繼承。這致使所涉及的班級之間造成親子關係。提供組織和結構化軟件的強大而天然的機制
• 對象–表示類的實例。任何類均可以具備多個實例。一個對象包含數據以及將對數據進行操做的方法
• 多態性–指 方法，對象或變量採起幾種形式的能力

問題：請解釋Java中的方法重寫？

答：Java中的方法重寫容許子類提供其父類或父類已經提供的方法的特定實現。若是子類方法和超類方法具備：

• 同名
• 一樣的論點
• 相同的返回類型

問題：重載是什麼意思？

回答：重載是兩種或多種不一樣方法（方法重載）或運算符（運算符重載）具備相同表示形式時的現象。 例如，+運算符將兩個整數值相加，但將兩個字符串鏈接在一塊兒。一樣，名爲Add的重載函數可用於兩個目的

1. 加兩個整數
2. 鏈接兩個字符串

與方法重寫不一樣，方法重載要求兩個重載的方法具備相同的名稱但參數不一樣。重載的函數能夠具備或能夠不具備不一樣的返回類型。

問題：請解釋一下String，String Builder和String Buffer之間的區別。

答：字符串變量存儲在常量字符串池中。隨着字符串引用的更改，沒法刪除舊值。例如，若是字符串存儲了值「 Old」，則添加新值「 New」不會刪除舊值。可是，它仍處於休眠狀態。 在字符串緩衝區中，值存儲在堆棧中。經過更改字符串引用，新值將替換舊值。 字符串緩衝區是同步的（所以是線程安全的），而且比字符串生成器（它也是一個字符串緩衝區但未同步）提供的性能要慢。所以，在String Builder中，性能比String Buffer快。

問題：Java中設置了什麼？另外，在Java Collections中解釋其類型。

答：在Java中，Set是惟一對象的集合。它使用_equals()_方法肯定兩個對象是否相同。Java集合中各類類型的Set是：

1. 哈希集–使用對象的哈希碼添加值的無序和未排序集。當集合的順序不重要時使用
2. 連接哈希集–這是哈希集的有序版本，維護全部元素的雙鏈表。在強制執行迭代順序時使用。插入順序與將元素添加到集合中的方式相同。
3. 樹集–Java中兩個排序的集合之一，它使用Read-Black樹結構並確保元素以升序出現。

問題：請比較notify()和notifyAll()方法。

答：_notify()_方法用於發送信號以喚醒等待池中的單個線程。相反，_notifyAll()_方法用於發送信號以喚醒等待池中的全部線程。

問題：何時Runnable接口優先於線程類，反之亦然？

答：在Java中，只能擴展一個類。所以，僅當不須要擴展其餘類時才擴展線程類。若是一個類須要擴展除線程類以外的其餘類，那麼咱們須要使用Runnable接口。

問：請解釋Java中的各類類型的垃圾收集器嗎？

答：Java編程語言具備四種類型的垃圾收集器：

1. 串行垃圾收集器–僅使用單個線程進行垃圾收集，串行垃圾收集器經過保存全部應用程序線程來工做。它是專爲單線程環境而設計的。由於串行垃圾收集器在執行垃圾收集時會凍結全部應用程序線程，因此它最僅適用於命令行程序。爲了使用串行垃圾收集器，須要打開-XX：+ UseSerialGC JVM參數。
2. 並行垃圾收集器–也稱爲吞吐量收集器，並行垃圾收集器是JVM的默認垃圾收集器。它使用多個線程進行垃圾回收，就像串行垃圾回收器在垃圾回收期間凍結全部應用程序線程同樣。
3. CMS垃圾收集器–併發標記掃描的縮寫，CMS垃圾收集器使用多個線程掃描堆內存以將實例標記爲驅逐，而後清除標記的實例。CMS垃圾收集器擁有全部應用程序線程時，只有兩種狀況：
   1. 在終身生成空間中標記參考對象時
   2. 若是在執行垃圾收集時堆內存發生了一些變化，則 CMS垃圾收集器將經過使用更多的CPU來確保與並行垃圾收集器相比更好的應用程序吞吐量。爲了使用CMS垃圾收集器，須要打開XX：+ USeParNewGC JVM參數。
4. G1垃圾收集器–用於大型堆內存區域，G1垃圾收集器的工做原理是將堆內存分紅多個區域，而後在其中並行執行垃圾收集。與CMS垃圾收集器在STW狀況下壓縮內存不一樣，G1垃圾收集器在回收內存後當即壓縮可用堆空間。一樣，G1垃圾收集器會優先處理垃圾最多的區域。使用G1垃圾收集器須要打開–XX：+ UseG1GC JVM參數。(https://stackoverflow.com/questions/16695874/why-does-the-jvm-full-gc-need-to-stop-the-world)

問題：如何區分HashMap和HashTable？

答：Java中的HashMap是基於Map的集合類，用於存儲鍵和值對。它表示爲HashMap <Key，Value>或HashMap <K，V> HashTable是一個列表數組，其中每一個列表稱爲存儲區。HashTable中包含的值是惟一的，而且取決於鍵。方法在HashMap中不一樣步，而關鍵方法在HashTable中同步。可是，HashMap沒有線程安全性，而HashTable具備相同的線程安全性。對於迭代值，HashMap使用迭代器，而HashTable使用枚舉器。HashTable不容許任何空值，而HashMap容許一個空鍵和多個空值。在性能方面，HashTable較慢。相對而言，HashMap更快。

問題：Java中的集合是什麼意思？Java中Collections的組成是什麼？

答：Java中的一組對象稱爲集合。Java.util包包含日期和時間功能，國際化，舊版收集類等，以及用於收集的各類類和接口。或者，能夠將集合視爲設計用於存儲對象和操縱對象存儲在其中的設計的框架。您可使用集合對對象執行如下操做：

• 刪除中
• 插入
• 操縱
• 正在搜尋
• 排序

如下是集合框架的各個組成部分：

• 類–數組列表，連接列表，列表和向量
• 接口–集合，列表，地圖，隊列，集合，排序的地圖和排序的集合
• 圖– HashMap，HashTable，LinkedHashMap和TreeMap
• 隊列–優先隊列
• 集–哈希集，連接哈希集和樹集

問題：請在Java中解釋Map及其類型。

答：Java Map是一個將鍵映射到值的對象。它不能包含重複的鍵，而且每一個鍵只能映射到一個值。爲了肯定兩個鍵是相同仍是不一樣，Map使用equals()方法。Java中有4種類型的Map，以下所述：

• HashMap-它是無序且未排序的地圖，所以，當不強調順序時，它是一個不錯的選擇。HashMap容許一個null鍵和多個null值，而且不維護任何插入順序。
• HashTable–不容許爲空而且具備同步的方法。因爲它容許線程安全，所以性能很慢。
• LinkedHashMap –比HashMap慢，但保持插入順序並具備更快的迭代速度。
• TreeMap–排序的Map，它支持使用構造函數構造排序順序。

問題：Java中的優先級隊列是什麼意思？

答：優先級隊列與常規隊列同樣，是一種抽象數據類型，不一樣之處在於優先級隊列與它所包含的每一個元素相關聯。在優先級隊列中，高優先級的元素在低優先級的元素以前獲得服務。優先隊列中的元素根據比較器或天然排序。優先級隊列中元素的順序表明它們的相對優先級。

問題：抽象類與接口有何不一樣？

答：在Java中，抽象類和接口之間存在一些區別，總結以下：

• 組成部分–抽象類包含實例變量，而接口只能包含常量。
• 構造函數和實例化–接口既沒有構造函數也不能實例化，則抽象類能夠具備默認的構造函數，該實例在實例化具體子類時就被調用。
• 方法的實現–實現接口的全部類都須要爲其包含的全部方法提供實現。可是，擴展抽象類的類不須要實現包含在其中的全部方法。在具體的子類中只需實現抽象方法。
• 方法類型–任何抽象類都具備抽象方法和非抽象方法。另外一方面，接口只有一個抽象方法。

問題：您能解釋一下Java中的各類異常嗎？另外，請告訴咱們有關處理它們的不一樣方法。

答：Java提供了兩種類型的異常：

• 檢查異常–擴展Throwable類的類（運行時異常和錯誤除外）稱爲檢查異常。此類異常由編譯器在編譯期間檢查。這些類型的異常必須具備適當的try / catch塊，或者必須使用throws關鍵字聲明。ClassNotFoundException是一個檢查的異常。
• 未檢查的異常–編譯期間，編譯器不會檢查此類異常。這樣，編譯器無需處理未經檢查的異常。算術異常和ArrayIndexOutOfBounds異常是未經檢查的異常。

Java中的異常以兩種方式處理：

class ExceptionCheck{
public static void main(String[] args){
add();
}
public void add() throws Exception{
addition();
}
}

class ExceptionCheck{
public static void main (String[] args) {
add();
}
public void add(){
try{
addition();
}catch(Exception e){
e.printStacktrace();
}
}
}

問題：您能夠繪製Java異常層次結構嗎？

答：

問題：final關鍵字在Java中扮演什麼角色？它對變量，方法和類有什麼影響？

答：Java中的final關鍵字是一個非訪問修飾符，僅適用於類，方法或變量。根據使用環境的不一樣，它有不一樣的用途。

• 使用class：

當一個類被聲明爲最終類時，則禁止其被子類化，即，沒有任何類能夠擴展最終類。

• 使用方法：

帶有final關鍵字的任何方法都不能被子類覆蓋。

• 用帶有變量：

緊跟着final關鍵字的變量不能在程序執行期間更改其持有的值。所以，它的行爲就像一個常量。

問題：如何在Java中建立線程？舉個例子。

答：爲了在Java中建立線程，有兩種選擇：

• 擴展線程類 –線程在java.lang.Thread類中可用。爲了建立線程，您須要擴展線程類並覆蓋run方法。例如，

public class Addition extends Thread {
public void run() {
}
}

使用線程類的缺點是沒法擴展任何其餘類。可是，能夠在類中重載run()方法

• 實現可運行接口–在Java中建立線程的另外一種方法是經過實現可運行接口。爲此，有必要提供

  public class Addition implements Runnable {
  public void run() {
  }
  }

問題：爲何咱們使用yield()方法？

答：yield()方法屬於線程類。它將當前正在運行的線程轉移到可運行狀態，並容許其餘線程執行。換句話說，它爲優先級相同的線程提供了運行的機會。由於yield()是靜態方法，因此它不會釋聽任何鎖。

問：您能解釋一下Java中的線程生命週期嗎？

答：線程生命週期具備如下狀態，並遵循如下順序：

• 建立–在線程生命週期的第一個狀態下，將建立線程實例，而且還沒有調用start（）方法。該線程如今被認爲是活動的。
• 可運行-調用start()方法以後但調用run()方法以前，線程處於可運行狀態。線程也能夠從等待或睡眠狀態返回到可運行狀態。
• 正在運行–調用run()方法後，線程進入運行狀態。這是線程開始執行的時間。
• 不可運行–儘管線程處於活動狀態，但沒法運行。一般，一段時間後它將返回到可運行狀態。
• 終止– run()方法完成執行後，線程進入終止狀態。如今還不活着。

問題：看看下面的兩個代碼片斷：

一

class Adder {
Static int add(int a, int b)
{
return a+b;
}
Static double add( double a, double b)
{
return a+b;
}
public static void main(String args[])
{
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(12.3,12.6));
}}

二

class Car {
void run(){
System.out.println(「bjbsair.com」);
}
Class Audi extends Car{
void run()
{
System.out.prinltn(「Audi is running at bjbsair.com」);
}
public static void main( String args[])
{
Car b=new Audi();
b.run();
}
}

二者之間的重要區別是什麼？

答案：代碼段i。是代碼片斷ii中方法重載的示例。演示方法重載。

問題：您對Java的同步有什麼瞭解？它最大的缺點是什麼？

答：若是多個線程嘗試訪問單個代碼塊，那麼產生不許確結果的機會就會增長。爲防止這種狀況，請使用同步。使用sync關鍵字使線程須要鍵才能訪問同步的代碼。簡而言之，同步一次只容許一個線程訪問一個代碼塊。每一個Java對象都有一個鎖，每一個鎖只有一個鍵。線程只有在能夠獲取對象鎖定的鍵的狀況下，才能訪問同步方法。如下示例演示了同步：

public class ExampleThread implements Runnable {
public static void main (String[] args){
Thread t = new Thread();
t.start();
}
public void run(){
synchronized(object){
{
}
}

注意：建議避免對全部方法實施同步。這是由於當只有一個線程可以訪問同步的代碼時，下一個線程須要等待。所以，它致使程序性能下降。

問題：是否能夠在單個try塊下寫入多個catch塊？

回答：是的，能夠在一個try塊下寫入多個catch塊。可是，該方法須要從特定到通常。下面的示例演示了相同的內容：

public class Example {
public static void main(String args[]) {
try {
int a[]= new int[10];
a[10]= 10/0;
}
catch(ArithmeticException e)
{
System.out.println("Arithmetic exception in first catch block");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array index out of bounds in second catch block");
}
catch(Exception e)
{
System.out.println("Any exception in third catch block");
}
}

問題：您可否分辨出execute()，executeQuery()和executeUpdate()之間的區別？

答：

• execute()–用於執行SQL查詢。若是結果是ResultSet（如運行Select查詢），則返回TRUE；若是結果不是ResultSet（如運行Insert或Update查詢），則返回FALSE。
• executeQuery()–用於執行Select查詢。它返回ResultSet，即便沒有匹配查詢的記錄，也不爲null。執行選擇查詢時必須使用executeQuery()方法，以便在有人嘗試執行Insert或Update語句時，拋出帶有「 executeQuery方法沒法用於更新」的消息的java.sql.SQLException。
• executeUpdate()–用於執行Delete / Insert / Update語句或不返回任何內容的DDL語句。輸出取決於語句是數據操做語言（DML）語句仍是數據定義語言（DDL）語句而有所不一樣。輸出爲整數，等於前一種狀況的總行數，後一種狀況爲0。

注意：execute()方法僅在不肯定語句類型的狀況下才須要使用。在全部其餘狀況下，請使用executeQuery()或executeUpdate()方法。

問題：提供一個Hibernate體系結構示例：

答：

問題：您可否經過代碼示例演示如何在JSP中刪除cookie？

回答：如下代碼演示瞭如何在JSP中刪除cookie：

Cookie mycook = new Cookie("bjbsair.com","value1");
response.addCookie(mycook1);
Cookie killmycook = new Cookie("bjbsair.com","value1");
killmycook.set MaxAge ( 0 );
killmycook.set Path ("/");
killmycook.addCookie ( killmycook 1 );

問題：編寫合適的代碼示例來演示final，final和finalize的用法。

答：final關鍵字用於限制類，方法和變量。不能繼承final類，不能覆蓋final方法，而且final變量變爲常量，即其值沒法更改。

class FinalVarExample {
public static void main( String args[])
{
final int a=10;
a=50; /* Will result in an error as the value can’t be changed now*/
}

最終：不管是否處理異常，都將執行finally塊內的任何代碼。

class FinallyExample {
public static void main(String args[]){
try {
int x=100;
}
catch(Exception e) {
System.out.println(e);
}
finally {
System.out.println("finally login to bjbsair.com");}
}
}
}

Finalize ：finalize方法在對象被垃圾回收以前執行清理。

class FinalizeExample {
public void finalize() {
System.out.println("bjbsair.com is called");
}
public static void main(String args[])
{
FinalizeExample f1=new FinalizeExample();
FinalizeExample f2=new FinalizeExample();
f1= NULL;
f2=NULL;
System.gc();
}
}

問題：throw關鍵字與throws關鍵字有何不一樣？

答：throws關鍵字容許聲明異常，而throw關鍵字用於顯式拋出異常。受檢查的異常不能僅經過throw傳播，而throw容許這樣作而無需任何其餘操做。throws關鍵字後跟一個類，而throw關鍵字後跟一個實例。方法中使用throw關鍵字，但方法簽名中使用throws關鍵字。此外，不可能拋出多個異常，可是能夠聲明多個異常。

問題：如何區分進程和線程？

答：進程和線程之間有幾個基本區別，以下所述：

• 定義–進程是程序的執行實例，而線程是進程的子集。
• 更改–對父流程所作的更改不會影響子流程。可是，主線程的更改可能致使同一進程的其餘線程的行爲發生更改。
• 通訊–進程須要進程間通訊才能與同級進程進行通訊，而線程卻可以直接與屬於同一進程的其餘線程進行通訊。
• 控制–進程由操做系統控制，而且只能控制子進程。相反，線程是由程序員控制的，而且可以對它們所屬的同一進程的線程進行控制。
• 依賴關係–進程是獨立的實體，而線程是依賴的實體
• 內存–線程在共享內存空間中運行，但進程在單獨的內存空間中運行。

問題：可否在Array和ArrayList之間進行比較？

答：數組必須在聲明時給出大小，而數組列表不必定須要大小，由於它會動態更改大小。爲了將對象放入數組，須要指定索引。可是，對於數組列表，沒有這樣的要求。參數化數組列表時，不參數化數組。

問題：請解釋一下Abstract類和Abstract方法是什麼意思？

答：Java中的抽象類是沒法實例化的類。這樣的類一般用於爲子類提供基礎，以便擴展以及實現抽象方法以及覆蓋或使用抽象類中定義的已實現方法。爲了建立抽象類，須要在其後跟隨abstract關鍵字。任何抽象類均可以具備抽象方法和非抽象方法。Java中僅具備聲明而沒有實現的方法被稱爲抽象方法。一樣，抽象方法名稱後跟abstract關鍵字。任何擴展抽象類的具體子類都必須提供抽象方法的實現。

問：您對Java接口有什麼瞭解？

答：Java接口是僅包含方法聲明而不包含方法實現的模板。這是一種在Java中實現多重繼承的解決方法。一些值得記住的有關Java接口的要點是：

• 實現接口的類必須爲接口中聲明的全部方法提供實現
• 接口中的全部方法在內部都是公共抽象void
• 接口中的全部變量都是內部公共的static final
• 類不擴展但實現接口

問題：什麼是join()方法？舉個例子。

答：咱們使用join()方法將一個線程與當前正在運行的線程的末端鏈接起來。它是一種非靜態方法，而且具備重載版本。考慮下面的示例：

public static void main (String[] args) {
Thread t = new Thread();
t.start();
t.join();
}

主線程在上述示例中開始執行。一旦執行到達代碼t.start()，線程t就會啓動其本身的堆棧以執行。JVM在主線程和那裏的線程之間切換。一旦執行達到t.join()，則線程t單獨執行並被容許完成其任務。以後，主線程恢復執行。

問題：如何在Java中使線程中止？

答：Java中有三種方法能夠中止執行線程：

• 阻塞–此方法用於將線程置於阻塞狀態。知足阻塞條件後，將當即恢復執行。例如，ServerSocket.accept()是一種阻塞方法，它偵聽傳入的套接字鏈接，而且僅在創建鏈接時才恢復被阻塞的線程。
• 睡眠–此方法用於將線程的執行延遲一段時間。使用sleep()方法的線程被稱爲進入睡眠狀態。喚醒後即進入睡眠狀態，即進入可運行狀態。在sleep()方法的花括號內提到了線程須要進入睡眠狀態的時間。這是一種靜態方法。
• 等待中-儘管能夠在任何Java對象上調用它，可是wait()方法只能從同步塊中調用。

問題：Volatile變量在Java中起什麼做用？

答：易失性變量中存儲的值不是從線程的高速緩存存儲器中讀取的，而是從主存儲器中讀取的。易失變量主要在同步期間使用。

問題：請比較Java中的序列化與反序列化。

答：序列化是將Java對象轉換爲字節流的過程。反序列化與序列化的過程剛好相反，在序列化過程當中，從字節流中檢索Java對象。經過將Java對象寫入ObjectOutputStream來序列化Java對象，並經過從ObjectInputStream讀取Java對象來反序列化Java對象。

問題：您對Java中的OutOfMemoryError瞭解什麼？

答：一般，當JVM因爲內存不足而沒法分配對象時，將引起OutOfMemoryError異常。在這種狀況下，垃圾收集器沒法回收任何內存。 致使OutOfMemoryError異常的緣由可能有多種，其中最著名的是：

• 保持物體太長時間
• 嘗試同時處理太多數據
• 使用第三方庫來緩存字符串
• 部署後使用不執行內存清理的應用程序服務器
• 當沒法知足本機分配時

這就完成了Java面試的主要問題清單。您如何看待咱們編制的清單？將您的評論放在下面的專用窗口中，讓咱們知道。另外，請查看這些最佳Java教程，以進一步完善Java技能。

問題：關於集合的排序和排序是什麼？

回答：

1.順序

這意味着值以特定順序存儲在集合中，但順序與值無關。例如。列表

2.排序

這意味着集合的順序取決於元素的值。

例如。SortedSet

問題：解釋Java中處理關鍵字的各類異常嗎？

回答：

Java中有兩個關鍵的異常處理關鍵字，其後是第三個關鍵字final，它們在處理異常後可能會或可能不會使用。

try:

若是代碼段有機會出現異常或錯誤，則將其放置在try塊中。引起異常時，將由catch塊對其進行處理和捕獲。

try塊必須在其後具備catch（）或final（）或兩個塊。

catch：

在try塊中引起異常時，將在塊中對其進行處理。

final:

無論異常如何，都執行該塊。能夠將其放置在try {}或catch {}塊以後。

問題：解釋異常傳播

答：若是未捕獲，則堆棧頂部的方法將引起異常。它移至下一個方法，並繼續這樣直到被捕獲。

例：

public class Sum()
{
public static void main(String args[])
{
addition()
}
public void addition()
{
add();
}
}

上面的代碼棧是：

add()
addition()
main()

若是未捕獲到add（）方法中發生的異常，則它將移至方法add（）。而後將其移至main（）方法，該處的執行流程中止。這稱爲異常傳播。

問題：在Java中解釋public static void main（String args []）

答：執行Java程序從公共靜態void main（String args []）開始，也稱爲main（）方法。

• public：它是一個訪問修飾符，定義了類或方法的可訪問性。程序中的任何類均可以訪問定義爲public的main（）方法。
• static：關鍵字指示變量，或方法爲類方法。將方法main（）設爲靜態，以便無需建立類的實例便可對其進行訪問。當main（）方法不是靜態的時，編譯器會拋出一個錯誤，由於JVM在建立任何對象以前調用了main（），而且只能經過該類直接調用靜態方法。
• void：方法的返回類型。無效定義該方法不返回任何類型的值。
• main ：JVM在開始執行任何程序時（僅具備特定簽名）搜索此方法。
• 字符串args []：傳遞給main方法的參數。

問題：Java是與平臺無關的語言。爲何？

答： Java編程語言不依賴任何特定的硬件或軟件，由於它是由編譯器編譯而後轉換爲字節碼的。字節碼與平臺無關，能夠在多個系統上運行。惟一的要求是Java須要一個運行時環境，即JRE，它是用於開發Java應用程序的一組工具。

問題：Java中的包裝器類是什麼？

答：包裝器類負責將Java原語轉換爲引用類型（對象）。一個類專用於每種原始數據類型。它們被稱爲包裝器類，由於它們將原始數據類型包裝到該類的對象中。它存在於java.lang包中。下表顯示了不一樣的原始類型，包裝器類。

<table class=""><tbody><tr><td><strong>簡單類型</strong></td><td><strong>包裝類</strong></td></tr><tr><td>boolean</td><td>Boolean</td></tr><tr><td>char</td><td>Character</td></tr><tr><td>double</td><td>Double</td></tr><tr><td>float</td><td>Float</td></tr><tr><td>int</td><td>Integer</td></tr><tr><td>long</td><td>Long</td></tr></tbody></table>

問題：解釋裝箱，拆箱，自動裝箱和自動拆箱的概念。

回答：

• 裝箱：將原始值放入對象內的概念稱爲裝箱。
• 拆箱：從對象獲取原始值。
• 自動裝箱：將值直接分配給整數對象。
• 自動拆箱：將原始值直接放入整數對象。

問題：解釋類型轉換

答：將一種數據類型的變量分配給另外一種數據類型的變量的概念。布爾數據類型是不可能的。

它有兩種類型：

• 隱含的
• 明確的

問題：解釋不一樣類型的類型轉換。

答：不一樣類型的類型轉換是：

• 隱式：將值從較小的數據類型存儲到較大的數據類型。它由編譯器自動完成。
• 顯式：將較大數據類型的值存儲到較小數據類型中。這致使信息丟失：

1. 截斷
2. 超出範圍

讓咱們看一下代碼示例，以進一步瞭解這一點：

int i = 10;
long l = i; 
long l = 10,000;
int i = (int) l; 
float f = 3.14f 
int i = (int) f;
i=3; 
long l = 123456789;
byte b = (byte) l;

問題：擴展名爲.java的空文件名是否爲有效文件名？

答：是的，Java只容許經過.java保存咱們的java文件。它由javac .java編譯，並由java類名運行。

讓咱們舉一個簡單的例子：

public class Any()
{
public static void main(String args[])
{
System.out.println("Hello bjbsair.com!");
}
}

編譯：javac.java

運行：java Any

問題：在Java中定義Singleton類。如何使一個class成爲Singleton？

答： Singleton類僅容許建立該類的一個實例。

能夠經過如下步驟使一個類成爲單例：

1. 用該類建立該類的靜態實例。

2. 經過不容許用戶經過定義私有構造函數來使用默認構造函數建立實例。

3. 建立一個靜態方法以返回A實例的對象。

   public class Singleton
   {
   public static void main(String args[])
   {
   Single obj1 = Single.getInstance();  /* both would point to one and same instance of the class */
   Single obj2 = Single.getInstance();
   }
   }
   class Single
   {
   static Single obj = new Single(); /* step a*/
   private Single() /* step b*/ 
   {
   }
   public static Single getInstance()
   {
   return obj; /* step c*/ 
   }
   }

問題：若是將公共靜態無效空間替換爲靜態公共無效空間，程序仍將運行嗎？

答：是的，程序的編譯和運行不會出現任何錯誤，由於說明符的順序可有可無。

問題：Java中的軟件包是什麼？在Java中說明Packages的一些優勢？

答：包是Java將各類類和/或接口組合在一塊兒的方式。對象的功能決定了如何對其進行分組。打包程序充當類的「容器」。

下面列出了Packages的優勢：

1. 其餘程序的類能夠重用。
2. 兩個相同的類能夠存在於兩個不一樣的包中。
3. 包能夠隱藏類，從而拒絕訪問僅供內部使用的某些程序和類。
4. 他們還將設計與編碼分開。

問題：區分==和equals()嗎？

回答

Equals()	==
是一個字符串類	是操做符
比較的是內容	比較的是地址
class Operator { public static void main(String[]args) { /* integer-type*/ System.out.println(10 == 20); /* char-type*/ System.out.println('a' == 'b'); /* char and double type*/ System.out.println('a' == 97.0); /* boolean type*/ System.out.println(true == true); }}	public class Equals{ public static void main(String[] args) { String s1 = new String("HELLO"); String s2 = new String("HELLO"); System.out.println(s1 == s2); System.out.println(s1.equals(s2)); }}

問題：咱們爲何不在Java中使用指針？

答：指針被認爲是不安全的，並增長了程序的複雜性，添加

指針的概念多是矛盾的。並且，JVM負責隱式內存分配；所以，爲避免用戶直接訪問內存，在Java中不建議使用指針。

問題：區分中斷和繼續

答

<table class=""><tbody><tr><td><strong>break</strong></td><td><strong>continue</strong></td></tr><tr><td>與循環和開關語句一塊兒使用</td><td>與僅循環語句一塊兒使用。</td></tr><tr><td>它終止循環或開關塊。</td><td>它不會終止，但會跳到下一個迭代。</td></tr></tbody></table>

問題：區分this()和super()

答：

<table class=""><tbody><tr><td><strong>this()</strong></td><td><strong>super()</strong></td></tr><tr><td>表示該類的當前實例。</td><td>表示父/基類的當前實例。</td></tr><tr><td>它用於調用同一類的默認構造函數</td><td>它用於調用父/基類的默認構造函數。</td></tr><tr><td>訪問當前類的方法</td><td>訪問基類的方法</td></tr><tr><td>點當前類的實例</td><td>指向超類實例。</td></tr><tr><td>必須是該塊的第一行</td><td>它必須是該塊的第一行。</td></tr></tbody></table>

問題：Java中的字符串池是什麼？

答：堆內存中存儲的字符串集合是指字符串池。每當建立新對象時，都會檢查它是否已存在於字符串池中。若是已經存在，則將相同的引用返回到變量，不然在字符串池中建立新對象，並返回相應的引用。

問題：解釋Java中的訪問修飾符。

答：訪問修飾符是Java中的預約義關鍵字，用於限制對另外一個類中的類，方法，構造函數和數據成員的訪問。

Java支持四個訪問修飾符：

• 默認
• 私有(private)
• 受保護的(protected)
• 公開(public)

<table class=""><tbody><tr><td><strong>編輯</strong></td><td><strong>默認</strong></td><td><strong>私有</strong></td><td><strong>受保護的</strong></td><td><strong>公開</strong></td></tr><tr><td>同類</td><td>是</td><td>是</td><td>是</td><td>是</td></tr><tr><td>相同的包子類</td><td>是</td><td>沒有</td><td>是</td><td>是</td></tr><tr><td>同一包非子類</td><td>是</td><td>沒有</td><td>是</td><td>是</td></tr><tr><td>不一樣的包子類</td><td>沒有</td><td>沒有</td><td>是</td><td>是</td></tr><tr><td>不一樣的包非子類</td><td>沒有</td><td>沒有</td><td>沒有</td><td>是</td></tr></tbody></table>

問題：什麼是多重繼承？Java是否支持多重繼承？若是沒有，如何實現？

答：若是子類或子類有兩個父類，這意味着它從兩個基類繼承屬性，則它是多重繼承。Java沒有多重繼承，以防萬一父類具備相同的方法名稱，那麼在運行時它就變得模棱兩可，而且編譯器沒法決定從子類執行哪一個方法。

Java編碼面試問題

問題：不使用內置函數進行字符串反轉的程序

答：

public class Reversal
{
public static void main(String args[])
{
String input = "bjbsair.com";
System.out.println("Given String -> " + "bjbsair.com");
char charArray[] = input.toCharArray();
System.out.println("Reversed String -> ");
for(int i = charArray.length-1;i>=0; i--)
{
System.out.print(charArray[i]);
}
System.out.println();
}
}

問題：從數組中刪除重複項的程序

答：

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
class RemoveDuplicates 
{
public static void main(String args[])
{
/*create ArrayList with duplicate elements*/
ArrayList duplicate = new ArrayList();
duplicate.add(5);
duplicate.add(7);
duplicate.add(1);
duplicate.add(4);
duplicate.add(1);
duplicate.add(7);
System.out.println("bjbsair.com: "+ duplicate);
Set <Integer> withoutDuplicates = new LinkedHashSet<Integer>(duplicate);
duplicate.clear();
duplicate.addAll(withoutDuplicates);
System.out.println("Array without duplicates: "+ duplicate);
}
}

問題：將數字取反的程序

import java.util.Scanner;
public class NumberReversal
{
public static void main(String args[])
{
System.out.println("Please enter the number to be reversed");
Scanner sc = new Scanner (System.in);
int number = sc.nextInt();
int reverse = reverse(number); 
System.out.println("Reverse of number: " + number + " is " + reverse(number)); 
 }
 public static int reverse(int number){
 int reverse = 0;
 int remainder = 0;
 do{
 remainder = number%10;
 reverse = reverse*10 + remainder;
 number = number/10;
 }while(number > 0);
    return reverse;
 }
}

問題：二進制搜索程序

答：

import java.util.Scanner;
import java.util.Arrays;
public class Binary {
 public static void main(String[] args) {
 System.out.println("Enter total number of elements : ");
 Scanner s = new Scanner (System.in);
 int length = s.nextInt();
 int[] input = new int[length];
 System.out.printf("Enter %d integers", length);
 for (int i = 0; i < length; i++) {
 input[i] = s.nextInt();
 }
 /* binary search requires the input array to be sorted so we must sort the array first*/
 Arrays.sort(input);
 System.out.print("the sorted array is: ");
 for(int i= 0; i<= length-1;i++)
 {
 System.out.println(input[i] + " ,");
 }
 System.out.println("Please enter number to be searched in sorted array");
 int key = s.nextInt();
 int index = BSearch(input, key);
 if (index == -1) {
 System.out.printf("Sorry, %d is not found in array %n", key);
 } else {
 System.out.printf("%d is found in array at index %d %n", key,
 index);
 }
 }
 public static int BSearch(int[] input, int number) {
 int low = 0;
 int high = input.length - 1;
 while (high >= low) {
 int middle = (low + high) / 2;
 if (input[middle] == number) {
 return middle;
 } else if (input[middle] < number) {
 low = middle + 1;
 } else if (input[middle] > number) {
 high = middle - 1;
 }
 }
 return -1;
 }
}

問題：檢查數字是否爲質數的程序。

import java.util.Scanner;
public class Prime
{
public static void main(String args[])
{
System.out.println("Enter the number to check: ");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
boolean isPrime = false;
   if(num!=0)
   {
   isPrime = checkPrime(num);
   }else
   {
   System.out.println("Enter valid number");
   }
   if(isPrime == false)
   {
   System.out.println(" NOT PRIME!!");
   }
   else
   {
   System.out.println("PRIME!!");
   }
}
public static boolean checkPrime(int number)
{
int sqrt = (int) Math.sqrt(number) + 1;
for(int i = 2; i<sqrt; i++)
{
if(number % i== 0)
{
return false;
}
}
return true;
}
}

答：

import java.util.Scanner;
public class Fibo
{
public static void main(String args[])
{
System.out.println("Enter the number upto which Fibonacci series should be printed ");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
System.out.println("Fibonacci Series upto %d is" + num);
for(int i=1; i<=num; i++)
{
System.out.print(fib(i) + " ");
}
}
public static int fib(int n)
{
if(n ==1 || n==2)
{
return 1;
}
return fib(n-1) + fib(n-2);
}
}

問題：打印斐波那契數列的程序

答：

import java.util.Scanner; 
public class PalinDrome
{
public static void main(String args[])
{
System.out.println("Enter the string to check");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
boolean isPalindrome;
isPalindrome = checkPalindrome(str);
if(str.equals(" "))
{
System.out.println("Enter valid string");
}
else
{
if(isPalindrome)
{
System.out.println("PALINDROME!!");
}
else
{
System.out.println("NOT A PALINDROME!!");
}
}
}
public static boolean checkPalindrome(String input)
{
int str_length = input.length();
int i=0, j= str_length-1;
while(i<j)
{
if(input.charAt(i) != input.charAt(j))
return false;
i++;
j--;
}
return true;
}
}

問題：程序檢查給定的字符串是不是迴文。

答：

public class Pattern
{
public static void main(String args[])
{
  for(int i=5; i>=0; i--)
  {
  System.out.println();
  for(int j=i; j<5;j++)
  {
  System.out.print(" * ");
  }
  }
  System.out.println();
}
}

問題：圖案印刷

<strong> </strong><br><strong> </strong><br><strong> </strong><br><strong> </strong><br><strong> * </strong>

答：

import java.util.Scanner;
public class Swap
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
System.out.println("Enter a number: ");
int a = s.nextInt();
System.out.println("Enter second number: ");
int b = s.nextInt();
System.out.println("Value of a and b before swapping: " + "a = " +a  + " b = " + b);
swap(a,b);
}
public static void swap(int a , int b)
{
int swap_variable; 
swap_variable = a;
a = b;
b = swap_variable;
System.out.println("Value of a and b after swapping: " + "a = " +a  + " b = " + b);
}
}

問題：交換兩個數字的程序

答：

import java.util.Scanner;
public class Swap
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
System.out.println("Enter a number: ");
int a = s.nextInt();
System.out.println("Enter second number: ");
int b = s.nextInt();
System.out.println("Value of a and b before swapping: " + "a = " +a  + " b = " + b);
swap(a,b);
}
public static void swap(int a , int b)
{
int swap_variable; 
swap_variable = a;
a = b;
b = swap_variable;
System.out.println("Value of a and b after swapping: " + "a = " +a  + " b = " + b);
}
}

問題：程序檢查給定的號碼是否爲阿姆斯特朗號碼。

import java.util.Scanner;
public class Armstrong
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
System.out.println("Enter a number: ");
int number = s.nextInt();
int a=number, sum = 0, num=0;
   while(a%10 !=0)
   {
   num = a%10;
   sum = sum + (num*num*num);
a = a/10;
   }
   if(sum == number)
   {
   System.out.println("Armstrong Number!");
   }
   else
   {
   System.out.println("Not an Armstrong Number!");
   }
 }
}