一般來說，實習中常問這些問題：
基本的有
1、對這個職位有多少了解？
2、對工作中產生的問題如何解決？
3、對這個工作是否感興趣？是否打算長期做這種工作？
對於我們IT行業來說,除了問以上三個問題以外，基本上，還會通過問你一些專業知識來了解你對這個行業，對技術的瞭解有多深！
以下，是我總結的常見的java實習生的一些筆試或者面試的題目：
1.Java有那些基本數據類型，String是不是基本數據類型，他們有何區別。
Java語言提供了八種基本類型：
六種數字類型（四個整數型，兩個浮點型）
字節型byte 8位 短整型short 16位 整型int 32位
長整型long 64位 單精度float 32位 雙精度double 64位
一種字符類型
字符型char 8位
還有一種布爾型
布爾型：boolean 8位 可存儲”True”和”false”。
String本身就是一個對象而不是基本數據類型，String的變量名是對String類的引用。
2.字符串的操作：
寫一個方法，實現字符串的反轉，如：輸入abc，輸出cba
public static String reverse(String s){
int length=s.length();
StringBuffer result=new StringBuffer(length);
for(int i=length-1;i>=0;i--)
result.append(s.charAt(i));
return result.toString();
}寫一個方法，實現字符串的替換，如：輸入bbbwlirbbb，輸出bbbhhtccc。
String s = "bbbwlirbbb";
s.replaceAll("wlirbbb","hhtccc");3.數據類型之間的轉換
如何將數值型字符轉換爲數字（Integer，Double）
使用Integer.parseInt()和Double.parseDouble()方法。
如何將數字轉換爲字符
class my
{
int a=12;
Label label=new Label();
label.setText(String.valueOf(a));
}
如何取小數點前兩位，並四捨五入。
System.out.println(“四捨五入取整:(3.856)=”
+ new BigDecimal(i).setScale(2, BigDecimal.ROUND_HALF_UP));
**4.日期和時間
如何取得年月日，小時分秒**
Date dat=new Date();
dat.getYear(); dat.getMonth(); dat.getDay(); dat.getHours(); dat.getMinutes(); dat.getSeconds();
如何取得從1970年到現在的毫秒數
long now=dat.getTime();
如何獲取某個日期是當月的最後一天
DateFormate df=DateFormate.getInstance();df.Format(dat);
如何格式化日期
DateFormate df=DateFormate.getInstance();
df.Format(dat);
5.數組和集合
數組與集合的區別:一：數組聲明瞭它容納的元素的類型，而集合不聲明。這是由於集合以object形式來存儲它們的元素。二：一個數組實例具有固定的大小，不能伸縮。集合則可根據需要動態改變大小。三：數組是一種可讀/可寫數據結構沒有辦法創建一個只讀數組。然而可以使用集合提供的ReadOnly方 只讀方式來使用集合。該方法將返回一個集合的只讀版本。
**6.文件和目錄（I/O）操作
如何列出某個目錄下的所有文件
如何列出某個目錄下的所有子目錄
判斷一個文件或目錄是否存在
如何讀寫文件**
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class FileOpreate {
public static void main(String [] args)
{
FileOpreate fo=new FileOpreate();
try
{
//文件的寫入
/*String[] testStr=new String[50];
for(int i=0;i<testStr.length;i++)
{
testStr[i]="我的測試數據00"+i;
}
fo.writeFile("D:\\","test.txt",testStr);
*/
//文件的寫入
/*String str="測試";
fo.writeFile("D:\\","test001.txt",str);*/
//創建或者刪除文件
/*if(fo.createAndDeleteFile("D:\\","test001.txt"))
{
fo.createAndDeleteFile("D:\\","test002.txt");
}*/
//創建或者刪除文件夾
/*fo.createAndDeleteFolder("D:\\","2009-07-06");*/
//輸出一個文件內的文件名稱
/*fo.readFolderByFile("D:\\");*/
//判斷一個文件是否是空的
/*fo.fileIsNull("D:\\","test002.txt");*/
//讀取全部的文件內容
/*fo.readAllFile("D:\\","test.txt");*/
//一行一行讀取文件內容
fo.readLineFile("D:\\","test.txt");
}
catch(Exception e)
{
e.printStackTrace();
}
}7.Java多態的實現（繼承、重載、覆蓋）
多態可分爲：
1)編譯多態：主要是體現在重載，系統在編譯時就能確定調用重載函數的哪個版本。
2)運行多態：主要體現在OO設計的繼承性上，子類的對象也是父類的對象，即上溯造型，所以子類對象可以作爲父類對象使用，父類的對象變量可以指向子類對象。因此通過一個父類發出的方法調用可能執行的是方法在父類中的實現，也可能是某個子類中的實現，它是由運行時刻具體的對象類型決定的。
8.編碼轉換，怎樣實現將GB2312編碼的字符串轉換爲ISO-8859-1編碼的字符串。
String str = new String(“字符串”.getBytes(“GB2312”),”ISO-8859-1”);
9.使用StringBuffer類與String類進行字符串連接時有何區別？
JAVA平臺提供了兩個類：String和StringBuffer，它們可以儲存和操作字符串，即包含多個字符的字符數據。這個String類提供了數值不可改變的字符串。而這個StringBuffer類提供的字符串進行修改。當你知道字符數據要改變的時候你就可以使用StringBuffer。典型地，你可以使用StringBuffers來動態構造字符數據。
10.談談final, finally, finalize的區別。
final 用於聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。
finally是異常處理語句結構的一部分，表示總是執行。
finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等。
11.String s = new String(“xyz”);創建了幾個String Object?
兩個，一個是string s，另一個是”xyz”。
12.Java有沒有goto?
goto是java中的保留字，現在沒有在java中使用。
13.數組有沒有length()這個方法? String有沒有length()這個方法？
數組沒有length()這個方法，有length的屬性。String有length()這個方法。
14.Overload和Override的區別。
override（重寫）
1）方法名、參數、返回值相同。
2）子類方法不能縮小父類方法的訪問權限。
3）子類方法不能拋出比父類方法更多的異常(但子類方法可以不拋出異常)。
4）存在於父類和子類之間。
5）方法被定義爲final不能被重寫。
overload（重載）
1）參數類型、個數、順序至少有一個不相同。
2）不能重載只有返回值不同的方法名。
3）存在於父類和子類、同類中。
15.abstract class和interface有什麼區別?
Interface只能有成員常量，只能是方法的聲明；
而abstract class可以有成員變量，可以聲明普通方法和抽象方法。
聲明方法的存在而不去實現它的類被叫做抽象類（abstract class），它用於要創建一個體現某些基本行爲的類，併爲該類聲明方法，但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以創建一個變量，其類型是一個抽象類，並讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract 類的子類爲它們父類中的所有抽象方法提供實現，否則它們也是抽象類爲。取而代之，在子類中實現該方法。知道其行爲的其它類可以在類中實現這些方法。
接口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可通過實現這樣的接口而獲得。接口中的所有方法都是抽象的，沒有一個有程序體。接口只可以定義static final成員變量。接口的實現與子類相似，除了該實現類不能從接口定義中繼承行爲。當類實現特殊接口時，它定義（即將程序體給予）所有這種接口的方法。然後，它可以在實現了該接口的類的任何對象上調用接口的方法。由於有抽象類，它允許使用接口名作爲引用變量的類型。通常的動態聯編將生效。引用可以轉換到接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了接口。
16.是否可以繼承String類?
String類是final類故不可以繼承。
17.面向對象的特徵有哪些方面?
1）抽象：抽象就是忽略一個主題中與當前目標無關的那些方面，以便更充分地注意與當前目標有關的方面。抽象並不打算了解全部問題，而只是選擇其中的一部分，暫時不用部分細節。抽象包括兩個方面，一是過程抽象，二是數據抽象。
2）繼承：繼承是一種聯結類的層次模型，並且允許和鼓勵類的重用，它提供了一種明確表述共性的方法。對象的一個新類可以從現有的類中派生，這個過程稱爲類繼承。新類繼承了原始類的特性，新類稱爲原始類的派生類（子類），而原始類稱爲新類的基類（父類）。派生類可以從它的基類那裏繼承方法和實例變量，並且類可以修改或增加新的方法使之更適合特殊的需要。
3)封裝：封裝是把過程和數據包圍起來，對數據的訪問只能通過已定義的界面。面向對象計算始於這個基本概念，即現實世界可以被描繪成一系列完全自治、封裝的對象，這些對象通過一個受保護的接口訪問其他對象。
4) 多態性：多態性是指允許不同類的對象對同一消息作出響應。多態性包括參數化多態性和包含多態性。多態性語言具有靈活、抽象、行爲共享、代碼共享的優勢，很好的解決了應用程序函數同名問題。
18.int 和 Integer 有什麼區別?
Java 提供兩種不同的類型：引用類型和原始類型（或內置類型）。
Int是java的原始數據類型，
Integer是java爲int提供的封裝類。
Java爲每個原始類型提供了封裝類。
原始類型封裝類booleanBoolean charCharacter byteByte shortShort intInteger longLong floatFloat doubleDouble
引用類型和原始類型的行爲完全不同，並且它們具有不同的語義。引用類型和原始類型具有不同的特徵和用法，它們包括：大小和速度問題，這種類型以哪種類型的數據結構存儲，當引用類型和原始類型用作某個類的實例數據時所指定的缺省值。對象引用實例變量的缺省值爲 null，而原始類型實例變量的缺省值與它們的類型有關。
19.作用域public,private,protected,以及不寫時的區別?
訪問 Public Protected 缺省的 Private
同類 √ √ √ √
同包 √ √ √ ×
子類 √ √ × ×
通用性 √ × × ×
20.用java寫一個冒泡排序。
/**
* 對int數組進行升序排序
*
* @param intVal：要排序的數組
* @param asc：值爲true，表示升序排序；傳入值爲false，表示降序排序
* @return 返回排序後的int數組
*/
public static int[] intArraySort(int [] intVal,boolean asc){
int [] vals=intVal;
int temp;
if(vals.length>0){
if(asc==true){
for(int i=0;i<=vals.length-2;i++){
for(int j=0;j<vals.length-i-1;j++){
if(vals[j]>vals[j+1]){
//升序排列
temp=vals[j];
vals[j]=vals[j+1];
vals[j+1]=temp;
}
}
}
}else{
for(int i=0;i<=vals.length-2;i++){
for(int j=0;j<vals.length-i-1;j++){
if(vals[j]<vals[j+1]){
//降序排列
temp=vals[j];
vals[j]=vals[j+1];
vals[j+1]=temp;
}
}
}
}
}
return vals;
}21.short s1 =1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?
short s1 = 1; s1 = s1 + 1; （s1+1運算結果是int型，需要強制轉換類型） short s1 = 1; s1 += 1;（可以正確編譯）
22.float型float f=3.4是否正確?
不正確。精度不準確,應該用強制類型轉換，如下所示：float f=(float)3.4 或float f = 3.4f
在java裏面，沒小數點的默認是int,有小數點的默認是 double;
23.ArrayList和Vector的區別,HashMap和Hashtable的區別。
ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元素移動等內存操作，所以索引數據快而插入數據慢，Vector由於使用了synchronized方法（線程安全），通常性能上較ArrayList差。
HashMap是Hashtable的輕量級實現（非線程安全的實現），他們都完成了Map接口，主要區別在於HashMap允許空（null）鍵值（key）,由於非線程安全，效率上可能高於Hashtable。
HashMap允許將null作爲一個entry的key或者value，而Hashtable不允許。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因爲contains方法容易讓人引起誤解。 Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Map interface的一個實現。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不需要自己爲它的方法實現同步，而HashMap 就必須爲之提供外同步。
24.Error與Exception有什麼區別？
error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內存溢出。不可能指望程序能處理這樣的情況。
exception 表示一種設計或實現問題。也就是說，它表示如果程序運行正常，從不會發生的情況。
25.statement 和preparestatement區別
1）創建時的區別：
Statement stm=con.createStatement();
PreparedStatement pstm=con.prepareStatement(sql);
執行的時候:
stm.execute(sql);
pstm.execute();
2）pstm一旦綁定了SQL,此pstm就不能執行其他的Sql，即只能執行一條SQL命令。
stm可以執行多條SQL命令。
3）對於執行同構的sql（只有值不同，其他結構都相同）,用pstm的執行效率比較的高，對於異構的SQL語句，Statement的執行效率要高。
4）當需要外部變量的時候，pstm的執行效率更高.
26.寫一個數據庫連接類，包括查詢及結果存儲。
import java.sql.*; //需要加入的包
//類的定義
class DBConnect {
private String con1 = "sun.jdbc.odbc.JdbcOdbcDriver"; //連接SQL所需要的字符串
private String url = "jdbc:odbc:test";
private String user = "sa", password = ""; //這裏請根據您的數據庫用戶和密碼自行修改
Connection con; //用於連接數據庫用的
PreparedStatement ps; //其實用Statement也行,PreparedStatement集成了Statement.
ResultSet rs; //一個集合,可以用於執行SQL命令
//構造函數
DBConnect() {
try {
Class.forName(con1); //Class.forName()用於將一些類加載到JVM
this.Connect(); //函數調用
try {
this.execute();
} catch (SQLException ex) {
System.out.println(ex.toString());
}
} catch (ClassNotFoundException ce) {
System.out.println(ce);
}
}
public void Connect() {
try {
con = DriverManager.getConnection(url, user, password); //做這部之前先把ODBC配置好
if (con != null) {
System.out.println("Connection Sucessfully!");
}
} catch (SQLException ex) {
System.out.println(ex.toString());
}
}
public void execute() throws SQLException {
ps = con.prepareStatement("select *from friends"); //把SQL語句搞給ps
rs = ps.executeQuery(); //這裏執行,之後讓rs知道信息
while (rs.next()) //這裏必須加next(),偏移量移動.
{
System.out.print(rs.getString(2) + "\t");
System.out.print(rs.getString(3) + "\t");
System.out.print(rs.getString(4) + "\t");
System.out.print(rs.getDate(5) + "\t");
System.out.print(rs.getInt(6) + "\t");
System.out.println("");
}
}
public void close() //用於釋放資源,Java裏沒有析構函數,但是通過重寫protected void finalize(),
{ //之後在調用System.runFinalization()和System.gc()可以提醒JVM執行finalize()以釋放,
try{ //在以前的J2SE版本里可以通過以上方法調用finalize(),但目前的J2SE5.0只能提醒JVM,但JVM不一定執行
rs.close(); //最好的方案還是自己寫析構close();
ps.close();
con.close();
}catch(SQLException ce)
{
System.out.println(ce.toString());
}
System.out.println("Connection released!!!");
}
public static void main(String[] args) {
DBConnect dbc=new DBConnect();
dbc.close();
}
}String、StringBuffer與StringBuilder之間區別
關於這三個類在字符串處理中的位置不言而喻，那麼他們到底有什麼優缺點，到底什麼時候該用誰呢？下面我們從以下幾點說明一下
1.三者在執行速度方面的比較：StringBuilder > StringBuffer > String
2.String <（StringBuffer，StringBuilder）的原因
String：字符串常量
StringBuffer：字符創變量
StringBuilder：字符創變量
從上面的名字可以看到，String是“字符創常量”，也就是不可改變的對象。對於這句話的理解你可能會產生這樣一個疑問 ，比如這段代碼：
1 String s = “abcd”;
2 s = s+1;
3 System.out.print(s);// result : abcd1
我們明明就是改變了String型的變量s的，爲什麼說是沒有改變呢? 其實這是一種欺騙，JVM是這樣解析這段代碼的：首先創建對象s，賦予一個abcd，然後再創建一個新的對象s用來 執行第二行代碼，也就是說我們之前對象s並沒有變化，所以我們說String類型是不可改變的對象了，由於這種機制，每當用String操作字符串時，實際上是在不斷的創建新的對象，而原來的對象就會變爲垃圾被ＧＣ回收掉，可想而知這樣執行效率會有多底。
而StringBuffer與StringBuilder就不一樣了，他們是字符串變量，是可改變的對象，每當我們用它們對字符串做操作時，實際上是在一個對象上操作的，這樣就不會像String一樣創建一些而外的對象進行操作了，當然速度就快了。
3.一個特殊的例子：
1 String str = “This is only a” + “ simple” + “ test”;
3 StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
你會很驚訝的發現，生成str對象的速度簡直太快了，而這個時候StringBuffer居然速度上根本一點都不佔優勢。其實這是JVM的一個把戲，實際上：
String str = “This is only a” + “ simple” + “test”;
其實就是：
String str = “This is only a simple test”;
所以不需要太多的時間了。但大家這裏要注意的是，如果你的字符串是來自另外的String對象的話，速度就沒那麼快了，譬如：
String str2 = “This is only a”;
String str3 = “ simple”;
String str4 = “ test”;
String str1 = str2 +str3 + str4;
這時候JVM會規規矩矩的按照原來的方式去做。
4.StringBuilder與 StringBuffer
StringBuilder：線程非安全的
StringBuffer：線程安全的
當我們在字符串緩衝去被多個線程使用是，JVM不能保證StringBuilder的操作是安全的，雖然他的速度最快，但是可以保證StringBuffer是可以正確操作的。當然大多數情況下就是我們是在單線程下進行的操作，所以大多數情況下是建議用StringBuilder而不用StringBuffer的，就是速度的原因。
對於三者使用的總結： 1.如果要操作少量的數據用 = String
2.單線程操作字符串緩衝區 下操作大量數據 = StringBuilder
3.多線程操作字符串緩衝區 下操作大量數據 = StringBuffer
偶是初學者，只是總結了自己學習的東西，難免寫的東西里有別人的，學習是記憶的過程，這些東西只是用來學習罷了，有些東西可能不對，希望各位給予指正。