首页手记 Java面试题资料详解与实战

Java面试题资料详解与实战

标签：

Java 面试

概述

本文提供了丰富的Java基础知识面试题资料，涵盖了Java基础语法、面向对象特性、集合框架、多线程、异常处理、设计模式和性能优化等多个方面。通过详细示例代码帮助读者理解和掌握相关知识点，是准备Java面试的绝佳资源。

Java基础知识面试题

Java基础语法

Java 是一种广泛使用的面向对象编程语言，主要用于构建企业级应用、Web 应用和安卓应用。以下是一些常见的 Java 基础语法问题和解答：

Java中的变量类型

变量指的是程序中使用的存储数据的容器，变量在使用前需要声明类型，可以是基本类型或引用类型。

基本类型：int、double、float、boolean、char 等。
引用类型：String、Date、Object 等。

示例代码：

public class VariableExample {
   public static void main(String[] args) {
       // 声明并初始化变量
       int num = 10;
       double d = 20.5;
       boolean isTrue = true;
       char ch = 'A';
       String name = "John Doe";

       // 输出变量值
       System.out.println("整型变量 num: " + num);
       System.out.println("双精度浮点变量 d: " + d);
       System.out.println("布尔变量 isTrue: " + isTrue);
       System.out.println("字符变量 ch: " + ch);
       System.out.println("字符串变量 name: " + name);
   }
}

Java中的常量

常量在程序运行过程中不会改变其值。在 Java 中，可以使用 final 关键字来定义常量。

示例代码：

public class ConstantExample {
   public static void main(String[] args) {
       final int MAX_VALUE = 100;
       final String MESSAGE = "Hello, World!";

       System.out.println("常量 MAX_VALUE: " + MAX_VALUE);
       System.out.println("常量 MESSAGE: " + MESSAGE);
   }
}

Java中的流程控制语句

if 语句：条件判断。
for 语句：循环执行一段代码。
while 语句：循环执行一段代码，直到条件不满足。

示例代码：

public class ControlFlowExample {
   public static void main(String[] args) {
       int num = 10;

       // if 语句
       if (num > 5) {
           System.out.println("num > 5");
       } else {
           System.out.println("num <= 5");
       }

       // for 语句
       for (int i = 0; i < 5; i++) {
           System.out.println("for 循环 i: " + i);
       }

       // while 语句
       int j = 0;
       while (j < 5) {
           System.out.println("while 循环 j: " + j);
           j++;
       }
   }
}

Java中的方法

方法是一段可以重复使用的代码，可以用来执行特定的功能，方法可以有参数和返回值，也可以没有。

示例代码：

public class MethodExample {
   public static void main(String[] args) {
       int result = addNumbers(5, 10);
       System.out.println("addNumbers 返回值: " + result);
   }

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

Java中的构造函数

构造函数用于创建对象时初始化对象的属性。

无参构造函数：如果没有明确定义构造函数，Java 会提供一个默认构造函数。
有参构造函数：可以定义带有参数的构造函数。

示例代码：

public class ConstructorExample {
   private int id;
   private String name;

   // 有参构造函数
   public ConstructorExample(int id, String name) {
       this.id = id;
       this.name = name;
   }

   public void display() {
       System.out.println("ID: " + id + ", Name: " + name);
   }

   public static void main(String[] args) {
       ConstructorExample obj = new ConstructorExample(1, "John Doe");
       obj.display();
   }
}

Java面向对象特性

Java 是一种面向对象的语言，支持封装、继承和多态等特性。

封装

封装是把对象的状态信息（即属性）和行为（即方法）结合在一起，防止外部直接访问对象的状态信息。

使用 private 关键字修饰变量，从而隐藏内部实现。
提供公共方法（getter 和 setter 方法）来访问和修改这些私有变量。

示例代码：

public class EncapsulationExample {
   private int id;
   private String name;

   public int getId() {
       return id;
   }

   public void setId(int id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }
}

继承

继承使子类可以继承父类的属性和方法，从而实现代码重用。

示例代码：

public class InheritanceExample {
   public static void main(String[] args) {
       ChildClass child = new ChildClass();
       child.show();
   }
}

class ParentClass {
   public void display() {
       System.out.println("ParentClass display");
   }
}

class ChildClass extends ParentClass {
   public void show() {
       display();
       System.out.println("ChildClass show");
   }
}

多态

多态允许子类可以实现父类的方法，从而实现不同的功能。

示例代码：

public class PolymorphismExample {
   public static void main(String[] args) {
       ParentClass obj = new ChildClass();
       obj.display();
   }
}

class ParentClass {
   public void display() {
       System.out.println("ParentClass display");
   }
}

class ChildClass extends ParentClass {
   public void display() {
       System.out.println("ChildClass display");
   }
}

异常处理

异常处理机制使程序能够捕获并处理运行时发生的异常情况。

示例代码：

public class ExceptionExample {
   public static void main(String[] args) {
       try {
           int result = 10 / 0;
       } catch (ArithmeticException e) {
           System.out.println("ArithmeticException caught");
       }
   }
}

常见数据类型与操作

Java 中的数据类型分为基本类型和引用类型。

基本类型
- byte：8位，有符号整数。
- short：16位，有符号整数。
- int：32位，有符号整数。
- long：64位，有符号整数。
- float：32位，带小数点的数值。
- double：64位，带小数点的数值。
- char：16位，单个字符。
- boolean：true 或 false。

引用类型

String
List
Map
Object

示例代码：

public class DataTypeExample {
   public static void main(String[] args) {
       byte b = 10;
       short s = 20;
       int i = 30;
       long l = 40L;
       float f = 123.45f;
       double d = 123.456789;
       char ch = 'A';
       boolean isTrue = true;

       System.out.println("byte: " + b);
       System.out.println("short: " + s);
       System.out.println("int: " + i);
       System.out.println("long: " + l);
       System.out.println("float: " + f);
       System.out.println("double: " + d);
       System.out.println("char: " + ch);
       System.out.println("boolean: " + isTrue);
   }
}

String 操作

length()：获取字符串长度。
charAt(index)：获取指定索引位置的字符。
substring(beginIndex)：获取从指定索引位置开始的子串。
trim()：去除字符串前后的空白字符。
toUpperCase()：将字符串转换为大写。
toLowerCase()：将字符串转换为小写。

示例代码：

public class StringExample {
   public static void main(String[] args) {
       String str = " Hello, World! ";

       // 获取字符串长度
       int len = str.length();
       System.out.println("Length: " + len);

       // 获取指定索引位置的字符
       char ch = str.charAt(6);
       System.out.println("Char at 6: " + ch);

       // 获取子串
       String sub = str.substring(7);
       System.out.println("Substring: " + sub);

       // 去除前后空白字符
       String trimmed = str.trim();
       System.out.println("Trimmed: " + trimmed);

       // 转换为大写
       String upper = str.toUpperCase();
       System.out.println("Upper: " + upper);

       // 转换为小写
       String lower = str.toLowerCase();
       System.out.println("Lower: " + lower);
   }
}

Java集合框架面试题

集合框架概述

Java 集合框架提供了很多接口和实现类，用于存储和操作对象集合。主要接口有 List、Set 和 Map。

List 接口

ArrayList：实现基于数组的动态增长列表。
LinkedList：实现基于链表的动态增长列表。

示例代码：

import java.util.ArrayList;
import java.util.LinkedList;

public class ListExample {
   public static void main(String[] args) {
       ArrayList<String> list = new ArrayList<>();
       list.add("元素1");
       list.add("元素2");
       list.add("元素3");
       System.out.println("ArrayList 输出: " + list.toString());

       LinkedList<String> linkedList = new LinkedList<>();
       linkedList.add("元素1");
       linkedList.add("元素2");
       linkedList.add("元素3");
       System.out.println("LinkedList 输出: " + linkedList.toString());
   }
}

Set 接口

HashSet：实现无序的集合，不允许重复元素。
TreeSet：实现有序的集合，不允许重复元素。

示例代码：

import java.util.HashSet;
import java.util.TreeSet;

public class SetExample {
   public static void main(String[] args) {
       HashSet<String> hashSet = new HashSet<>();
       hashSet.add("元素1");
       hashSet.add("元素2");
       hashSet.add("元素3");
       System.out.println("HashSet 输出: " + hashSet.toString());

       TreeSet<String> treeSet = new TreeSet<>();
       treeSet.add("元素1");
       treeSet.add("元素2");
       treeSet.add("元素3");
       System.out.println("TreeSet 输出: " + treeSet.toString());
   }
}

Map 接口

HashMap：实现无序的键值对集合，不允许重复键。
TreeMap：实现有序的键值对集合，不允许重复键。

示例代码：

import java.util.HashMap;
import java.util.TreeMap;

public class MapExample {
   public static void main(String[] args) {
       HashMap<String, Integer> hashMap = new HashMap<>();
       hashMap.put("元素1", 1);
       hashMap.put("元素2", 2);
       hashMap.put("元素3", 3);
       System.out.println("HashMap 输出: " + hashMap.toString());

       TreeMap<String, Integer> treeMap = new TreeMap<>();
       treeMap.put("元素1", 1);
       treeMap.put("元素2", 2);
       treeMap.put("元素3", 3);
       System.out.println("TreeMap 输出: " + treeMap.toString());
   }
}

HashMap与Hashtable的区别

线程安全性
- HashMap：非线程安全，可以在多线程环境下使用 ConcurrentHashMap。
- Hashtable：线程安全，内部所有方法都是同步的。
null 键和值
- HashMap：允许 null 键和一个 null 值。
- Hashtable：不允许 null 键和 null 值。
键和值的类型
- HashMap：键和值可以是任意类型，对键和值的限制较少。
- Hashtable：键和值必须是 Object 类型，对键和值的限制较多。
迭代器
- HashMap：迭代器不是强一致性迭代器。
- Hashtable：迭代器是强一致性迭代器。

示例代码：

import java.util.Hashtable;
import java.util.HashMap;

public class HashTableExample {
   public static void main(String[] args) {
       HashMap<String, Integer> hashMap = new HashMap<>();
       hashMap.put("元素1", 1);
       hashMap.put("元素2", 2);
       hashMap.put("元素3", 3);
       System.out.println("HashMap 输出: " + hashMap.toString());

       Hashtable<String, Integer> hashTable = new Hashtable<>();
       hashTable.put("元素1", 1);
       hashTable.put("元素2", 2);
       hashTable.put("元素3", 3);
       System.out.println("Hashtable 输出: " + hashTable.toString());
   }
}

Java多线程面试题

多线程基础概念

线程：线程是进程中的一个执行单元，多个线程可以共享相同的内存空间。
线程调度器：负责管理和调度线程的执行顺序。
线程状态：
- 新建状态（新建）：线程刚被创建，尚未启动。
- 运行状态（可运行）：线程已准备好执行，等待获取 CPU 时间片。
- 阻塞状态（阻塞）：线程在等待其他事件的发生。
- 终止状态（终止）：线程已完成其任务，退出执行。

示例代码：

public class ThreadExample {
    public static void main(String[] args) {
        // 创建线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程运行中");
            }
        });

        // 启动线程
        thread.start();
    }
}

synchronized关键字与Lock接口

synchronized

synchronized 关键字可以用来声明方法或代码块，以实现线程同步。方法级别的 synchronized 会锁住整个对象，而代码块级别的 synchronized 可以锁定指定对象。

示例代码：

public class SynchronizedExample {
   public synchronized void method() {
       System.out.println("方法级别的 synchronized");
   }

   public void method2() {
       synchronized (this) {
           System.out.println("代码块级别的 synchronized");
       }
   }

   public static void main(String[] args) {
       SynchronizedExample obj = new SynchronizedExample();
       obj.method();
       obj.method2();
   }
}

Lock接口

Lock 接口提供了比 synchronized 更灵活的锁定机制，支持公平锁、非公平锁、可重入锁等。

示例代码：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
   private Lock lock = new ReentrantLock();

   public void method() {
       lock.lock();
       try {
           System.out.println("Lock 接口的使用");
       } finally {
           lock.unlock();
       }
   }

   public static void main(String[] args) {
       LockExample obj = new LockExample();
       obj.method();
   }
}

wait()、notify() 和 notifyAll() 方法

wait()：使当前线程等待，直到被唤醒。
notify()：唤醒一个等待的线程。
notifyAll()：唤醒所有等待的线程。

示例代码：

public class WaitNotifyExample {
   private Object lock = new Object();

   public void producer() {
       synchronized (lock) {
           System.out.println("生产者生产了一个产品");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           lock.notify();
       }
   }

   public void consumer() {
       synchronized (lock) {
           System.out.println("消费者等待产品");
           try {
               lock.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("消费者获取了产品");
       }
   }

   public static void main(String[] args) {
       WaitNotifyExample example = new WaitNotifyExample();

       Thread producerThread = new Thread(() -> example.producer());
       Thread consumerThread = new Thread(() -> example.consumer());

       producerThread.start();
       consumerThread.start();
   }
}

线程同步

使用 synchronized 或 Lock 实现线程同步。

示例代码：

public class SynchronizedExample {
   private int counter = 0;

   public synchronized void increment() {
       counter++;
       System.out.println("counter: " + counter);
   }

   public static void main(String[] args) {
       SynchronizedExample example = new SynchronizedExample();

       Thread t1 = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               example.increment();
           }
       });

       Thread t2 = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               example.increment();
           }
       });

       t1.start();
       t2.start();
   }
}

Java异常处理面试题

异常与错误的区别

异常：程序运行时发生的异常情况，可以通过 try-catch 语句捕获和处理。
错误：程序无法处理的严重错误，如内存溢出、硬件故障等。

示例代码：

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException caught");
        }
    }
}

异常处理机制

try-catch 语句

使用 try 块捕获异常，使用 catch 块处理异常。

示例代码：

public class ExceptionExample {
   public static void main(String[] args) {
       try {
           int result = 10 / 0;
       } catch (ArithmeticException e) {
           System.out.println("ArithmeticException caught");
       }
   }
}

finally 语句

finally 块用于无论是否发生异常都会执行的清理操作。

示例代码：

public class FinallyExample {
   public static void main(String[] args) {
       try {
           int result = 10 / 0;
       } catch (ArithmeticException e) {
           System.out.println("ArithmeticException caught");
       } finally {
           System.out.println("finally block executed");
       }
   }
}

throw 和 throws

throw：手动抛出异常。
throws：声明方法可能抛出的异常。

示例代码：

public class ThrowThrowsExample {
   public void method() throws ArithmeticException {
       throw new ArithmeticException("ArithmeticException thrown");
   }

   public static void main(String[] args) {
       ThrowThrowsExample example = new ThrowThrowsExample();

       try {
           example.method();
       } catch (ArithmeticException e) {
           System.out.println("ArithmeticException caught");
       }
   }
}

自定义异常

可以通过继承 Exception 类或其子类来自定义异常。

示例代码：

public class CustomException extends Exception {
   public CustomException(String message) {
       super(message);
   }
}

public class CustomExceptionExample {
   public static void main(String[] args) {
       try {
           throw new CustomException("自定义异常抛出");
       } catch (CustomException e) {
           System.out.println("CustomException caught: " + e.getMessage());
       }
   }
}

Java常用设计模式面试题

单例模式

单例模式保证一个类只有一个实例，并提供一个全局访问点。

饿汉式

在类加载时就创建实例，线程安全。

示例代码：

public class SingletonExample {
  private static final SingletonExample INSTANCE = new SingletonExample();

  private SingletonExample() {}

  public static SingletonExample getInstance() {
      return INSTANCE;
  }
}

懒汉式

在需要实例时才创建实例，线程安全。

示例代码：

public class SingletonExample {
  private static SingletonExample INSTANCE;

  private SingletonExample() {}

  public static synchronized SingletonExample getInstance() {
      if (INSTANCE == null) {
          INSTANCE = new SingletonExample();
      }
      return INSTANCE;
  }
}

使用双重检查锁（Double-Checked Locking）优化：

public class SingletonExample {
  private volatile static SingletonExample INSTANCE;

  private SingletonExample() {}

  public static SingletonExample getInstance() {
      if (INSTANCE == null) {
          synchronized (SingletonExample.class) {
              if (INSTANCE == null) {
                  INSTANCE = new SingletonExample();
              }
          }
      }
      return INSTANCE;
  }
}

工厂模式

工厂模式用于创建对象的工厂类，可以减少类与类之间的耦合度，提高程序的扩展性和维护性。

简单工厂模式

增加新的具体工厂类，只需修改工厂类，不修改客户端代码。

示例代码：

public interface Product {
  void use();
}

public class ProductA implements Product {
  @Override
  public void use() {
      System.out.println("ProductA 使用");
  }
}

public class ProductB implements Product {
  @Override
  public void use() {
      System.out.println("ProductB 使用");
  }
}

public class SimpleFactory {
  public Product createProduct(String type) {
      if ("A".equals(type)) {
          return new ProductA();
      } else if ("B".equals(type)) {
          return new ProductB();
      }
      return null;
  }
}

public class SimpleFactoryExample {
  public static void main(String[] args) {
      SimpleFactory factory = new SimpleFactory();
      Product productA = factory.createProduct("A");
      productA.use();
      Product productB = factory.createProduct("B");
      productB.use();
  }
}

工厂方法模式

提供一个创建对象的接口，但允许子类决定实例化哪一个类。

示例代码：

public interface Factory {
  Product createProduct();
}

public class ConcreteFactoryA implements Factory {
  @Override
  public Product createProduct() {
      return new ProductA();
  }
}

public class ConcreteFactoryB implements Factory {
  @Override
  public Product createProduct() {
      return new ProductB();
  }
}

public class FactoryMethodExample {
  public static void main(String[] args) {
      Factory factoryA = new ConcreteFactoryA();
      Product productA = factoryA.createProduct();
      productA.use();

      Factory factoryB = new ConcreteFactoryB();
      Product productB = factoryB.createProduct();
      productB.use();
  }
}

装饰者模式

装饰者模式动态地给一个对象添加一些额外的功能，而不会影响其他对象。

装饰者模式

示例代码：

public interface Component {
  void operation();
}

public class ConcreteComponent implements Component {
  @Override
  public void operation() {
      System.out.println("ConcreteComponent 执行");
  }
}

public class Decorator implements Component {
  private Component component;

  public Decorator(Component component) {
      this.component = component;
  }

  @Override
  public void operation() {
      component.operation();
  }
}

public class ConcreteDecoratorA extends Decorator {
  public ConcreteDecoratorA(Component component) {
      super(component);
  }

  @Override
  public void operation() {
      super.operation();
      additionalOperation();
  }

  private void additionalOperation() {
      System.out.println("ConcreteDecoratorA 添加额外的操作");
  }
}

public class ConcreteDecoratorB extends Decorator {
  public ConcreteDecoratorB(Component component) {
      super(component);
  }

  @Override
  public void operation() {
      super.operation();
      additionalOperation();
  }

  private void additionalOperation() {
      System.out.println("ConcreteDecoratorB 添加额外的操作");
  }
}

public class DecoratorExample {
  public static void main(String[] args) {
      Component component = new ConcreteComponent();
      component = new ConcreteDecoratorA(component);
      component = new ConcreteDecoratorB(component);
      component.operation();
  }
}

Java性能优化面试题

JVM调优

JVM 内存模型

JVM 内存模型包括堆内存（Heap）和非堆内存（Non-heap）。
- 堆内存：用于存储对象实例。
- 非堆内存：包括方法区（Method Area）、JVM 栈（JVM Stack）、本地方法栈（Native Method Stack）等。
JVM 参数
- -Xms：设置堆内存的初始大小。
- -Xmx：设置堆内存的最大大小。
- -Xmn：设置年轻代的大小。
- -XX:PermSize：设置永久代的初始大小。
- -XX:MaxPermSize：设置永久代的最大大小。
- -XX:NewRatio：设置年轻代与老年代的比例。
- -XX:SurvivorRatio：设置 Eden 区与 Survivor 区的比例。
- -XX:MaxTenuringThreshold：设置对象晋升老年代的年龄阈值。
- -XX:ParallelGCThreads：设置并行垃圾收集线程的数量。
- -XX:+UseConcMarkSweepGC：使用 CMS 垃圾收集器。
- -XX:+UseG1GC：使用 G1 垃圾收集器。

GC机制与常见算法

垃圾收集器
- Serial GC：单线程垃圾收集器，适用于单核 CPU 和小型应用。
- Parallel GC：多线程垃圾收集器，适用于多核 CPU 和大型应用。
- CMS GC：低延迟垃圾收集器，适用于对响应时间要求高的应用。
- G1 GC：并行和并发的垃圾收集器，适用于大规模数据集。
常见算法
- 标记-清除算法：标记无用对象，清除这些对象。
- 复制算法：将对象从一个区域复制到另一个区域。
- 标记-整理算法：标记无用对象，然后将所有存活对象向一端移动。
- 分代收集算法：根据对象的年龄，将内存划分为年轻代和老年代。

内存泄漏与解决方法

内存泄漏

内存泄漏是指程序中已经不再使用的对象没有被回收，导致可用内存减少。
- 静态集合：静态集合中存放的对象不会被垃圾回收。
- 静态引用：静态引用对象不能被垃圾回收。
- 集合元素引用丢失：集合中的元素被移除，但仍然被外部引用。
- 单例对象：单例对象的引用不会被回收。
- 线程局部变量：线程局部变量不会被回收。
解决方法
- 及时清理静态集合。
- 避免静态引用。
- 确保集合元素被正确移除。
- 使用软引用或弱引用。
- 使用工具检测内存泄漏。

示例代码：

public class MemoryLeakExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        while (true) {
            String str = new String("Memory Leak Example");
            list.add(str);
        }
    }
}

以上是 Java 面试题的相关内容，涵盖了 Java 的基础语法、面向对象特性、集合框架、多线程、异常处理、常用设计模式和性能优化等多方面知识。掌握这些知识将有助于面试者更好地应对 Java 相关的面试。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

蝴蝶不菲

手记
篇

粉丝

81

获赞与收藏

384

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19500 319

Java 并发原理入门教程

26个小节 39374 574

Java 入门教程

50个小节 345205 3198

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Java面试题资料详解与实战

Java基础知识面试题

Java基础语法

Java面向对象特性

常见数据类型与操作

Java集合框架面试题

集合框架概述

Java多线程面试题

多线程基础概念

synchronized关键字与Lock接口

Java异常处理面试题

异常与错误的区别

异常处理机制

Java常用设计模式面试题

单例模式

工厂模式

装饰者模式

Java性能优化面试题

JVM调优

GC机制与常见算法

内存泄漏与解决方法

阅读免费教程