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

李老头探索

于 2024-09-30 17:46:14 发布

阅读量1.3k

点赞数 39

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2401_87718562/article/details/142660142

版权

前言

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

*** 12万字的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");
    }
}