57个Java技术面试问题 & Answers [2024] | Toptal®-欧博体育app下载

1.

描述和比较故障快速迭代器和故障安全迭代器. Give examples.

View answer

两者的主要区别 fail-fast and fail-safe 迭代器是指是否可以修改集合 while it is being iterated. Fail-safe iterators allow this; fail-fast iterators do not.

Fail-fast 迭代器直接作用于集合本身. During iteration, 快速失败迭代器一旦意识到集合被修改就会失败.e.(当意识到成员已被添加、修改或删除时)，并抛出一个 并发修改异常。. Some examples include ArrayList, HashSet, and HashMap (most JDK1.4 .集合的实现是快速故障的).
Fail-safe iterates operate on a cloned copy 的集合，因此做 not 如果在迭代期间修改了集合，则抛出异常. 返回的迭代器 ConcurrentHashMap or CopyOnWriteArrayList.

2.

ArrayList, LinkedList, and Vector 的所有实现吗 List interface. 在列表中添加和删除元素时，哪一种方法最有效? 解释你的答案，包括你可能知道的任何其他选择.

View answer

Of the three, LinkedList 通常会给你最好的表现吗. Here’s why:

ArrayList and Vector 每个都使用一个数组来存储列表中的元素. As a result, 当一个元素被插入(或从)列表中间移除时, 接下来的元素都必须进行相应的移动. Vector 是同步的，所以如果线程安全的实现是 not 需要时，建议使用 ArrayList rather than Vector.

LinkedList另一方面，它是使用双重链表实现的. As a result, 插入或删除元素只需要更新被插入或删除元素前后的链接.

However, 值得注意的是，如果性能是如此关键, 最好使用数组并自己管理它, 或者使用一个高性能的第三方软件包，比如 Trove or HPPC.

3.

为什么存储敏感数据(如密码、社会保险号等)会更安全.)，而不是在字符串中?

View answer

In Java, Strings are immutable 并存储在String池中. What this means is that, once a String is created, 它会一直留在内存池中，直到被垃圾收集. 因此，即使在处理完字符串值(e.g., the password), 此后，它在内存中可用一段不确定的时间, 直到你无法真正控制的垃圾收集. Therefore, 任何有权访问内存转储的人都有可能提取敏感数据并加以利用.

In contrast, 如果你使用可变对象，比如字符数组, for example, to store the value, 您可以将其设置为空白，一旦您完成它，它将不再保留在内存中.

4.

What is the ThreadLocal class? 你会怎么用，为什么用?

View answer

A single ThreadLocal 实例可以为每个线程独立存储不同的值. 的每个线程 get() or set() method of a ThreadLocal 实例正在访问它自己的、独立初始化的变量副本. ThreadLocal 实例通常是类中的私有静态字段，它们希望将状态与线程(例如线程)相关联.g.(用户ID或事务ID). 下面的例子，来自 ThreadLocal Javadoc，生成每个线程的本地唯一标识符. 线程的id是在它第一次调用时分配的 ThreadId.get() 在随后的呼叫中保持不变.

public class ThreadId {
    //下一个要分配的线程ID
    private static final AtomicInteger nextId = new AtomicInteger(0);

    //包含每个线程ID的线程局部变量
    private static final ThreadLocal threadId =
        new ThreadLocal() {
            @覆盖受保护的整数initialValue() {
                return nextId.getAndIncrement();
        }
    };

    //返回当前线程的唯一ID，必要时赋值
    public static int get() {
        return threadId.get();
    }
}

Each thread holds an implicit reference to its copy of a thread-local variable as long as the thread is alive and the ThreadLocal instance is accessible; after a thread goes away, 它的线程本地实例的所有副本都服从于垃圾收集(除非存在对这些副本的其他引用)。.

5.

What is the volatile keyword? 你会怎么用，为什么用?

View answer

在Java中，每个线程都有自己的堆栈，包括它可以访问的变量的副本. 当创建线程时，它将所有可访问变量的值复制到自己的堆栈中. The volatile 关键字基本上对JVM说"警告，这个变量可能在另一个线程中被修改".

在所有Java版本中， volatile 关键字保证对变量进行读写时的全局排序. 这意味着每个访问volatile字段的线程都将读取变量的当前值，而不是(潜在地)使用缓存值.

In Java 5 or later, volatile 读和写建立一个 happens-before 关系，很像获取和释放互斥锁.

Using volatile 可能比锁快，但在某些情况下不起作用. The range of situations in which volatile is effective was expanded in Java 5; in particular, double-checked locking now works correctly.

volatile关键字对于64位类型(如long和double)也很有用，因为它们是在两个操作中写入的. 如果没有volatile关键字，您将面临过期或无效值的风险.

的一个常见示例 volatile 是否使用标志来终止线程. If you’ve started a thread, 您希望能够从另一个线程安全地中断它, 您可以让线程定期检查一个标志(例如.e.要阻止它，就把旗子设为 true). 通过使旗子易挥发, 您可以确保检查其值的线程将看到它已被设置为 true 甚至不需要使用同步块. For example:

类Foo扩展线程
    Private volatile Boolean close = false;
    public void run() {
        while(!close) {
            // do work
        }
    }
    public void close() {
        close = true;
        //如果需要，在这里中断
    }
}

6.

Compare the sleep() and wait() 方法，包括何时以及为什么使用一个方法与. the other.

View answer

sleep() 是一个阻塞操作，保持在监视器/锁定的共享对象的指定毫秒数.

wait()，另一方面，简单 pauses the thread until either (a)指定的毫秒数已经过去 or (b)它从另一个线程接收到所需的通知(以先到者为准); without 保持对共享对象的监视器/锁的持有.

sleep() 最常用于轮询，或定期检查某些结果. wait() 通常用于多线程应用程序，与 notify() / notifyAll()，实现同步，避免竞态条件.

7.

尾递归在功能上等同于迭代. 因为Java还不支持尾部调用优化, 描述如何将一个简单的尾递归函数转换为一个循环，以及为什么一个通常比另一个更受欢迎.

View answer

下面是一个典型递归函数的例子，计算等差数列1,2,3…N. 注意在函数调用之后是如何执行加法的. 对于每个递归步骤，我们向堆栈中添加另一帧.

public int sumfrommoneton (int n) {
  if (n < 1) {
    return 0;
  }

  返回n + sumfrommoneton (n - 1);
}

当递归调用位于其封闭上下文中的尾部位置时，即在函数调用自身之后，就会发生尾递归, 它不执行任何额外的工作. 也就是说，一旦基本情况完成，解决方案就显而易见了. For example:

public int sumfrommoneton (int n, int a) {
  if (n < 1) {
    return a;
  }

  返回sumfrommoneton (n - 1, a + n);
}

Here you can see that a 扮演累加器的角色——而不是在堆栈向下的过程中计算总和, we compute it on the way up, 有效地使回程不必要, 因为它不存储额外的状态，也不执行进一步的计算. 一旦我们达到基本情况，工作就完成了——下面是同一个函数，“展开”.

public int sumfrommoneton (int n) {
  int a = 0;

  while(n > 0) {
    a += n--;
  }
  
  return a;
}

许多函数式语言本身支持尾部调用优化，但是JVM不支持. 为了在Java中实现递归函数，我们需要意识到要避免这种限制 StackOverflowErrors. 在Java中，迭代几乎普遍优于递归.

8.

如何交换两个数值变量的值 without using any other variables?

View answer

You can swap two values a and b 不使用任何其他变量，如下所示:

a = a + b;
b = a - b;
a = a - b;

9.

如何在Java中捕获由另一个线程抛出的异常?

View answer

This can be done using Thread.UncaughtExceptionHandler.

Here’s a simple example:

//创建未捕获的异常处理程序
Thread.UncaughtExceptionHandler handler =新线程.UncaughtExceptionHandler () {
    公共void uncaughtException(线程th, Throwable ex) {
        System.out.println("未捕获的异常:" + ex);
    }
};

// create another thread
线程otherThread = new Thread() {
    public void run() {
        System.out.println("Sleeping ...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.out.println("Interrupted.");
        }
        System.out.println(“抛出异常 ...");
        抛出新的RuntimeException();
    }
};

//将未捕获的异常处理程序设置为新线程运行时使用的异常处理程序
//抛出未捕获的异常
otherThread.setUncaughtExceptionHandler(处理器);

//启动另一个线程——我们未捕获的异常处理程序将被调用
//另一个线程抛出未捕获的异常
otherThread.start();

10.

什么是Java类加载器? 列出并解释这三种类型的类装入器的用途.

View answer

The Java Classloader 是Java运行时环境的一部分，它按需将类(惰性加载)加载到JVM (Java虚拟机)中。. 类可以从本地文件系统、远程文件系统甚至web加载.

当JVM启动时，使用三个类加载器: 1. Bootstrap Classloader: Loads core java API file rt.jar from folder. 2. Extension Classloader: 从文件夹加载jar文件. 3. 系统/应用程序类加载器: 从CLASSPATH环境变量中指定的路径加载jar文件.

11.

Is a finally 类抛出异常时执行的块 try block that does not have a catch block, and if so, when?

View answer

A finally 块执行，即使抛出异常或将异常传播到调用代码块.

Example:

公共类FinallyExecution {
	public static void main(String[] args) {	
		try{			
			FinallyExecution.divide(100, 0);}
		finally{
			System.out.Println ("finally in main");
		}
	}	
	Public static void divide(int n, int div){
		try{
			int ans = n/div; }
		finally{
			System.out.Println(“finally of divide”);
		}
	}
}

输出可以有所不同，可以是:

finally of divide
finally in main
线程"main"中的异常.lang.arithmelceexception: / by 0
	at exceptions.FinallyExecution.divide(FinallyExecution.java:20)
	at exceptions.FinallyExecution.main(FinallyExecution.java:9)

…or…

线程"main"中的异常.lang.arithmelceexception: / by 0
	at exceptions.FinallyExecution.divide(FinallyExecution.java:20)
	at exceptions.FinallyExecution.main(FinallyExecution.java:9)
finally of divide
finally in main

12.

在设计抽象类时, 为什么要避免在构造函数内部调用抽象方法?

View answer

这是初始化顺序的问题. 子类构造函数还没有机会运行，也没有办法强制它在父类之前运行它. 考虑下面的示例类:

        公共抽象类Widget {
	        private final int cachedWidth;
	        private final int cachedHeight;
	
	        public Widget() {
	            this.cachedWidth = width();
	            this.cachedHeight = height();
	        }
	
	        受保护的抽象int宽度();
	        受保护抽象int height();
	    }

这似乎是一个抽象Widget的良好开端:它允许子类填充 width and height，并缓存它们的初始值. 然而，看看当你指定一个典型的子类实现，像这样:

        公共类SquareWidget扩展Widget {
	        private final int size;
	
	        公共SquareWidget(int size) {
	            this.size = size;
	        }
	
	        @Override
	        protected int width() {
	            return size;
	        }
	
	        @Override
	        protected int height() {
	            return size;
	        }
	    }

现在我们引入了一个微妙的bug: Widget.cachedWidth and Widget.cachedHeight will always be zero for SquareWidget instances! This is because the this.size = size assignment occurs after the Widget constructor runs.

避免在抽象类的构造函数中调用抽象方法, 因为它限制了这些抽象方法的实现方式.

13.

泛型类型参数的变化是多么大啊? Java在这方面给了你多大的控制权?

View answer

Java的泛型类型参数是 invariant. 这意味着对于任何不同的类型 A and B, G 不是子类型还是超类型 G. As a real world example, List 不是超类型还是子类型 List

21个基本的Java面试问题 *

最好的Java开发人员和工程师可以回答的全部来源的基本问题. 在我们社区的推动下，我们鼓励专家提交问题并提供反馈.

Interview Questions

Why Toptal

提出面试问题

寻找Java开发人员?

Julie Wetherbee

Jean-François Savard

Claudio Aldana