近5年常考Java面试题及答案整理（一）

 1 class AutoUnboxingTest {
 2  
 3     public static void main(String[] args) {
 4         Integer a = new Integer(3);
 5         Integer b = 3;                  // 将3自动装箱成Integer类型
 6         int c = 3;
 7         System.out.println(a == b);     // false 两个引用没有引用同一对象
 8         System.out.println(a == c);     // true a自动拆箱成int类型再和c比较
 9     }
10 }

1 public class Test03 {
2  
3     public static void main(String[] args) {
4         Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
5  
6         System.out.println(f1 == f2);
7         System.out.println(f3 == f4);
8     }
9 }

1 public static Integer valueOf(int i) {
2     if (i >= IntegerCache.low && i <= IntegerCache.high)
3         return IntegerCache.cache[i + (-IntegerCache.low)];
4     return new Integer(i);
5 }

 1 /**
 2      * Cache to support the object identity semantics of autoboxing for values between
 3      * -128 and 127 (inclusive) as required by JLS.
 4      *
 5      * The cache is initialized on first usage.  The size of the cache
 6      * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 7      * During VM initialization, java.lang.Integer.IntegerCache.high property
 8      * may be set and saved in the private system properties in the
 9      * sun.misc.VM class.
10      */
11  
12     private static class IntegerCache {
13         static final int low = -128;
14         static final int high;
15         static final Integer cache[];
16  
17         static {
18             // high value may be configured by property
19             int h = 127;
20             String integerCacheHighPropValue =
21                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
22             if (integerCacheHighPropValue != null) {
23                 try {
24                     int i = parseInt(integerCacheHighPropValue);
25                     i = Math.max(i, 127);
26                     // Maximum array size is Integer.MAX_VALUE
27                     h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
28                 } catch( NumberFormatException nfe) {
29                     // If the property cannot be parsed into an int, ignore it.
30                 }
31             }
32             high = h;
33  
34             cache = new Integer[(high - low) + 1];
35             int j = low;
36             for(int k = 0; k < cache.length; k++)
37                 cache[k] = new Integer(j++);
38  
39             // range [-128, 127] must be interned (JLS7 5.1.7)
40             assert IntegerCache.high >= 127;
41         }
42  
43         private IntegerCache() {}
44     }

String str = new String("hello");

1 String s1 = new StringBuilder("go")
2     .append("od").toString();
3 System.out.println(s1.intern() == s1);
4 String s2 = new StringBuilder("ja")
5     .append("va").toString();
6 System.out.println(s2.intern() == s2);

 1 public class PhoneNumber {
 2     private int areaCode;
 3     private String prefix;
 4     private String lineNumber;
 5  
 6     @Override
 7     public int hashCode() {
 8         final int prime = 31;
 9         int result = 1;
10         result = prime * result + areaCode;
11         result = prime * result
12                 + ((lineNumber == null) ? 0 : lineNumber.hashCode());
13         result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
14         return result;
15     }
16  
17     @Override
18     public boolean equals(Object obj) {
19         if (this == obj)
20             return true;
21         if (obj == null)
22             return false;
23         if (getClass() != obj.getClass())
24             return false;
25         PhoneNumber other = (PhoneNumber) obj;
26         if (areaCode != other.areaCode)
27             return false;
28         if (lineNumber == null) {
29             if (other.lineNumber != null)
30                 return false;
31         } else if (!lineNumber.equals(other.lineNumber))
32             return false;
33         if (prefix == null) {
34             if (other.prefix != null)
35                 return false;
36         } else if (!prefix.equals(other.prefix))
37             return false;
38         return true;
39     }
40  
41 }

 1 using System;
 2  
 3 namespace CS01 {
 4  
 5     class Program {
 6         public static void swap(ref int x, ref int y) {
 7             int temp = x;
 8             x = y;
 9             y = temp;
10         }
11  
12         public static void Main (string[] args) {
13             int a = 5, b = 10;
14             swap (ref a, ref b);
15             // a = 10, b = 5;
16             Console.WriteLine ("a = {0}, b = {1}", a, b);
17         }
18     }
19 }

 1 class StringEqualTest {
 2  
 3     public static void main(String[] args) {
 4         String s1 = "Programming";
 5         String s2 = new String("Programming");
 6         String s3 = "Program";
 7         String s4 = "ming";
 8         String s5 = "Program" + "ming";
 9         String s6 = s3 + s4;
10         System.out.println(s1 == s2);
11         System.out.println(s1 == s5);
12         System.out.println(s1 == s6);
13         System.out.println(s1 == s6.intern());
14         System.out.println(s2 == s2.intern());
15     }
16 }

1 float max(int a, int b);
2 int max(int a, int b);

 1 /**
 2  * 扑克类（一副扑克）
 3  *
 4  */
 5 public class Poker {
 6     private static String[] suites = {"黑桃", "红桃", "草花", "方块"};
 7     private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
 8  
 9     private Card[] cards;
10  
11     /**
12      * 构造器
13      * 
14      */
15     public Poker() {
16         cards = new Card[52];
17         for(int i = 0; i < suites.length; i++) {
18             for(int j = 0; j < faces.length; j++) {
19                 cards[i * 13 + j] = new Card(suites[i], faces[j]);
20             }
21         }
22     }
23  
24     /**
25      * 洗牌 （随机乱序）
26      * 
27      */
28     public void shuffle() {
29         for(int i = 0, len = cards.length; i < len; i++) {
30             int index = (int) (Math.random() * len);
31             Card temp = cards[index];
32             cards[index] = cards[i];
33             cards[i] = temp;
34         }
35     }
36  
37     /**
38      * 发牌
39      * @param index 发牌的位置
40      * 
41      */
42     public Card deal(int index) {
43         return cards[index];
44     }
45  
46     /**
47      * 卡片类（一张扑克）
48      * [内部类]
49      *
50      */
51     public class Card {
52         private String suite;   // 花色
53         private int face;       // 点数
54  
55         public Card(String suite, int face) {
56             this.suite = suite;
57             this.face = face;
58         }
59  
60         @Override
61         public String toString() {
62             String faceStr = "";
63             switch(face) {
64             case 1: faceStr = "A"; break;
65             case 11: faceStr = "J"; break;
66             case 12: faceStr = "Q"; break;
67             case 13: faceStr = "K"; break;
68             default: faceStr = String.valueOf(face);
69             }
70             return suite + faceStr;
71         }
72     }
73 }

 1 class PokerTest {
 2  
 3     public static void main(String[] args) {
 4         Poker poker = new Poker();
 5         poker.shuffle();                // 洗牌
 6         Poker.Card c1 = poker.deal(0);  // 发第一张牌
 7         // 对于非静态内部类Card
 8         // 只有通过其外部类Poker对象才能创建Card对象
 9         Poker.Card c2 = poker.new Card("红心", 1);    // 自己创建一张牌
10  
11         System.out.println(c1);     // 洗牌后的第一张
12         System.out.println(c2);     // 打印: 红心A
13     }
14 }

 1 class Outer {
 2  
 3     class Inner {}
 4  
 5     public static void foo() { new Inner(); }
 6  
 7     public void bar() { new Inner(); }
 8  
 9     public static void main(String[] args) {
10         new Inner();
11     }
12 }

 1 import java.util.Arrays;
 2 import java.util.EmptyStackException;
 3  
 4 public class MyStack<T> {
 5     private T[] elements;
 6     private int size = 0;
 7  
 8     private static final int INIT_CAPACITY = 16;
 9  
10     public MyStack() {
11         elements = (T[]) new Object[INIT_CAPACITY];
12     }
13  
14     public void push(T elem) {
15         ensureCapacity();
16         elements[size++] = elem;
17     }
18  
19     public T pop() {
20         if(size == 0) 
21             throw new EmptyStackException();
22         return elements[--size];
23     }
24  
25     private void ensureCapacity() {
26         if(elements.length == size) {
27             elements = Arrays.copyOf(elements, 2 * size + 1);
28         }
29     }
30 }

 1 import java.io.ByteArrayInputStream;
 2 import java.io.ByteArrayOutputStream;
 3 import java.io.ObjectInputStream;
 4 import java.io.ObjectOutputStream;
 5 import java.io.Serializable;
 6  
 7 public class MyUtil {
 8  
 9     private MyUtil() {
10         throw new AssertionError();
11     }
12  
13     @SuppressWarnings("unchecked")
14     public static <T extends Serializable> T clone(T obj) throws Exception {
15         ByteArrayOutputStream bout = new ByteArrayOutputStream();
16         ObjectOutputStream oos = new ObjectOutputStream(bout);
17         oos.writeObject(obj);
18  
19         ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
20         ObjectInputStream ois = new ObjectInputStream(bin);
21         return (T) ois.readObject();
22  
23         // 说明：调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义
24         // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放
25     }
26 }

 1 import java.io.Serializable;
 2  
 3 /**
 4  * 人类
 5  * @author nnngu
 6  *
 7  */
 8 class Person implements Serializable {
 9     private static final long serialVersionUID = -9102017020286042305L;
10  
11     private String name;    // 姓名
12     private int age;        // 年龄
13     private Car car;        // 座驾
14  
15     public Person(String name, int age, Car car) {
16         this.name = name;
17         this.age = age;
18         this.car = car;
19     }
20  
21     public String getName() {
22         return name;
23     }
24  
25     public void setName(String name) {
26         this.name = name;
27     }
28  
29     public int getAge() {
30         return age;
31     }
32  
33     public void setAge(int age) {
34         this.age = age;
35     }
36  
37     public Car getCar() {
38         return car;
39     }
40  
41     public void setCar(Car car) {
42         this.car = car;
43     }
44  
45     @Override
46     public String toString() {
47         return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
48     }
49  
50 }

 1 /**
 2  * 小汽车类
 3  * @author nnngu
 4  *
 5  */
 6 class Car implements Serializable {
 7     private static final long serialVersionUID = -5713945027627603702L;
 8  
 9     private String brand;       // 品牌
10     private int maxSpeed;       // 最高时速
11  
12     public Car(String brand, int maxSpeed) {
13         this.brand = brand;
14         this.maxSpeed = maxSpeed;
15     }
16  
17     public String getBrand() {
18         return brand;
19     }
20  
21     public void setBrand(String brand) {
22         this.brand = brand;
23     }
24  
25     public int getMaxSpeed() {
26         return maxSpeed;
27     }
28  
29     public void setMaxSpeed(int maxSpeed) {
30         this.maxSpeed = maxSpeed;
31     }
32  
33     @Override
34     public String toString() {
35         return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
36     }
37  
38 }

 1 class CloneTest {
 2  
 3     public static void main(String[] args) {
 4         try {
 5             Person p1 = new Person("郭靖", 33, new Car("Benz", 300));
 6             Person p2 = MyUtil.clone(p1);   // 深度克隆
 7             p2.getCar().setBrand("BYD");
 8             // 修改克隆的Person对象p2关联的汽车对象的品牌属性
 9             // 原来的Person对象p1关联的汽车不会受到任何影响
10             // 因为在克隆Person对象时其关联的汽车对象也被克隆了
11             System.out.println(p1);
12         } catch (Exception e) {
13             e.printStackTrace();
14         }
15     }
16 }