今日一学，5道Java基础面试题（附Java面试题及答案整理）

前言

马上国庆了，本来想着给自己放松一下，刷刷博客，慕然回首，自动拆装箱？equals？==？HashCode? instanceof？似乎有点模糊了，那就大概看一下5道Java基础面试题吧。好记性不如烂键盘~

instanceof 关键字的作用

instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：

if (object instanceof Json) {

	Json json = (Json)object;

}

其中 object 为一个对象，Json表示一个类或者一个接口，当 object 为 Json的对象，或者是其直接

或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。

注意：编译器会检查 object 是否能转换成右边的Json类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。

nt i = 0;

System.out.println(i instanceof Integer);//编译不通过 i必须是引用类型，不能是基本类型

System.out.println(i instanceof Object);//编译不通过

Integer integer = new Integer(1);

System.out.println(integer instanceof Integer);//true

System.out.println(null instanceof Object);//false ,在 JavaSE规范 中对 instanceof 运算符的规定就是：如果 obj 为 null，那么将返回 false。

Java自动装箱与拆箱

装箱就是自动将基本数据类型转换为包装器类型（int-->Integer）；调用方法：Integer的

valueOf(int) 方法

拆箱就是自动将包装器类型转换为基本数据类型（Integer-->int）。调用方法：Integer的

intValue方

为什么会需要这功能呢？

在Java SE5之前，如果要生成一个数值为100的Integer对象，必须这样进行：

Integer i = new Integer(100);

而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为100的Integer对象，只需要这样就可以了：

Integer i = 100

面试题1：以下代码会输出什么？

public class Main {

	public static void main(String[] args) {

		Integer i1 = 100;

		Integer i2 = 100;

		Integer i3 = 200;

		Integer i4 = 200;

		System.out.println(i1==i2);

		System.out.println(i3==i4);

	}

}

true

false

为什么会出现这样的结果？时只需一看源码便知究竟

public static Integer valueOf(int i) {

        if (i >= IntegerCache.low && i <= IntegerCache.high)

            return IntegerCache.cache[i + (-IntegerCache.low)];

        return new Integer(i);

  		}

private static class IntegerCache {

        static final int low = -128;

        static final int high;

        static final Integer cache[];

        static {

            // high value may be configured by property

            int h = 127;

            String integerCacheHighPropValue =

                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");

            if (integerCacheHighPropValue != null) {

                try {

                    int i = parseInt(integerCacheHighPropValue);

                    i = Math.max(i, 127);

                    // Maximum array size is Integer.MAX_VALUE

                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);

                } catch( NumberFormatException nfe) {

                    // If the property cannot be parsed into an int, ignore it.

                }

            }

            high = h;

            cache = new Integer[(high - low) + 1];

            int j = low;

            for(int k = 0; k < cache.length; k++)

                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)

            assert IntegerCache.high >= 127;

        }

        private IntegerCache() {}

    }

从这2段代码可以看出问题了吗？第一段代码，if判断，true拿缓存，false就new一个，是不是很熟悉

面试题2：以下代码输出什么

public class Main {

	public static void main(String[] args) {

		Double i1 = 100.0;

		Double i2 = 100.0;

		Double i3 = 200.0;

		Double i4 = 200.0;

		System.out.println(i1==i2); // false

		System.out.println(i3==i4); // false

	}

}

在某个范围内的整型数值的个数是有限的，而浮点数却没有，本身没做这数值的缓存

equals与==的区别

首先，先看定义

== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作

public static void main(String[] args) {

		System.out.println(10L == 10); // true

		}

当你使用 == 操作符比较这两个值时，Java会自动进行类型提升，将较小的数据类型（这里是 int）转换为较大的数据类型（这里是 long），以便进行比较。

equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话（String就是很好的例子），调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断，

public class Object {

	public boolean equals(Object obj) {

	        return (this == obj);

	    }

}

public class String{

	public boolean equals(Object anObject) {

        if (this == anObject) {

            return true;

        }

        if (anObject instanceof String) {

            String anotherString = (String)anObject;

            int n = value.length;

            if (n == anotherString.value.length) {

                char v1[] = value;

                char v2[] = anotherString.value;

                int i = 0;

                while (n-- != 0) {

                    if (v1[i] != v2[i])

                        return false;

                    i++;

                }

                return true;

            }

        }

        return false;

    }

}

Hashcode的作用

在Java中，集合框架主要分为两大类：List 和 Set。List 是有序且允许重复元素的集合，而 Set 则是无序且不允许重复元素的集合。

当我们向 Set 中插入元素时，需要确保该元素之前没有被添加过。这通常通过调用元素的 equals 方法来实现。然而，当集合中的元素数量非常大时，直接使用 equals 方法进行逐个比较会变得效率低下。

为了解决这个问题，引入了哈希算法。哈希算法能够提高查找、插入和删除操作的效率。每个对象都有一个 hashCode 方法，该方法返回一个整数值，这个值被称为哈希码。哈希码用于确定对象应该存储在集合内部的哪个位置（也称为桶或槽）。具体来说，哈希码可以用来快速定位到可能包含该对象的存储区域。

在实际操作中，当尝试向 Set 添加新元素时，首先计算该元素的哈希码，并根据哈希码找到对应的存储区域。如果该区域为空，则可以直接将新元素存入；如果该区域已包含其他元素，那么就需要进一步调用 equals 方法来确认这些元素是否与新元素相同。只有当 equals 方法返回 false 时，才会将新元素存入集合中（这里面就涉及到另一个面试题，hashcode相等的对象是否相等）。

通过这种方式，哈希码减少了直接使用 equals 方法进行比较的次数，从而大大提高了性能。理想情况下，即使集合中有很多元素，查找特定元素的操作也可以接近常数时间复杂度 O(1)。

需要注意的是，为了保证哈希表的高效运行，hashCode 方法的实现必须满足以下条件：

相等的对象必须具有相等的哈希码（即如果 x.equals(y) 返回 true，那么 x.hashCode() 必须等于 y.hashCode()）。(hashcode相等的对象是否相等)
不相等的对象最好拥有不同的哈希码，以减少碰撞（不同对象具有相同的哈希码的情况），尽管这是不可能完全避免的。

因此，正确地重写 equals 和 hashCode 方法对于自定义类型的对象是非常重要的，这样可以确保它们能够在基于哈希的集合中正确工作。

重载和重写的区别

重载（Overloading）
- 定义：在同一个类中，允许存在多个方法名相同但参数列表不同的方法。
- 目的：提供一种方式来执行相似功能的方法，但是针对不同类型的输入或数量的参数。

public class Calculator {

    public int add(int a, int b) { return a + b; }

    public double add(double a, double b) { return a + b; } // 重载

}

重写（Overriding）
- 定义：子类重新定义从父类继承下来的方法，以实现特定的行为。
- 目的：当子类认为父类的方法不能满足需求时，可以覆盖该方法以实现新的行为，子类方法的访问级别不能比父类更严格（例如，如果父类方法是 public，那么子类方法也必须是 public），如果父类方法被声明为 final 或 private，则子类无法重写这些方法，使用 @Override 注解可以帮助编译器检查是否正确实现了重写

class Animal {

    public void sound() {

        System.out.println("Some generic animal sound");

    }

}

class Dog extends Animal {

    @Override

    public void sound() { // 重写

        System.out.println("Bark");

    }

}