以下是中高级Java软件工程师常见编程面试题，共有20道。
- 如何判断一个数组是否为有序数组？
答案：可以通过一次遍历，比较相邻元素的大小。如果发现相邻元素的大小顺序不对，则数组不是有序数组。
public boolean isSortedArray(int[] nums) { for (int i = 0; i < nums.length - 1; i++) { if (nums[i] > nums[i + 1]) { return false; } } return true;
}
- 如何删除一个有序数组中的重复元素？
答案：可以通过一次遍历，将相邻的重复元素删除。
public int[] removeDuplicates(int[] nums) { if (nums == null || nums.length == 0) { return null; } int i = 0; for (int j = 0; j < nums.length; j++) { if (i == 0 || nums[j]!= nums[i]) { nums[i++] = nums[j]; } } int[] result = new int[i]; System.arraycopy(nums, 0, result, 0, i); return result;
}
- 如何合并两个有序数组？
答案：可以通过一次遍历，将两个有序数组合并成一个新的有序数组。
public int[] mergeTwoSortedArrays(int[] nums1, int[] nums2) { int[] result = new int[nums1.length + nums2.length]; int i = 0, j = 0, k = 0; while (i < nums1.length && j < nums2.length) { if (nums1[i] < nums2[j]) { result[k++] = nums1[i++]; } else { result[k++] = nums2[j++]; } } while (i < nums1.length) { result[k++] = nums1[i++]; } while (j < nums2.length) { result[k++] = nums2[j++]; } return result;
}
- 如何反转一个数组？
答案：可以通过一次遍历，将数组的每个元素翻转。
public void reverseArray(int[] nums) { for (int i = 0; i < nums.length; i++) { int temp = nums[i]; nums[i] = nums[nums.length - 1 - i]; nums[nums.length - 1 - i] = temp; }
}
- 如何计算一个数组的平均值？
答案：将数组的所有元素相加，然后除以数组的长度。
public double averageArray(int[] nums) { long sum = 0; for (int num : nums) { sum += num; } return (double) sum / nums.length;
}
- 如何计算一个数组的中位数？
答案：将数组排序后，找到中间的元素。如果数组长度为偶数，则中间的两个元素的平均值是中位数。
public double medianArray(int[] nums) { Arrays.sort(nums); int length = nums.length; if (length % 2 == 0) { return (double) (nums[length / 2 - 1] + nums[length / 2]) / 2.0; } else { return (double) nums[length / 2]; }
}
- 如何计算一个数组的众数？
答案：可以通过一次遍历，统计每个元素出现的次数。出现次数最多的元素是众数。
public int mostCommon(int[] nums) { int[] count = new int[101]; for (int num : nums) { count[num]++; } int max = 0; int resfor (int i = 0; i < 101; i++) { if (count[i] > max) { max = count[i]; res = i; } } return res;
}
- 如何计算一个数组的方差？
答案：将数组的所有元素相减后求平方，然后求和，最后除以数组的长度。
public double varianceArray(int[] nums) { long sum = 0; for (int num : nums) { sum += num; } double mean = (double) sum / nums.length; double sumSqr = 0; for (int num : nums) { double d = num - mean; sumSqr += d * d; } return sumSqr / nums.length;
}
- 如何计算一个数组的标准差？
答案：计算方差后，对方差开平方根。
public double standardDeviationArray(int[] nums) { double variance = varianceArray(nums); return Math.sqrt(variance);
}
- 如何判断一个字符串是否为回文字符串？
答案：可以通过两次遍历，比较字符串的前半部分和后半部分是否相同。
public boolean isPalindrome(String s) { int i = 0; int j = s.length() - 1; while (i < j) { if (s.charAt(i)!= s.charAt(j)) { return false; } i++; j--; } return true;
}
- 如何删除一个字符串中的所有重复字符？
答案：可以通过一次遍历，将字符串中的每个字符添加到一个新的字符数组中，如果字符数组中没有该字符，则将该字符添加到字符数组中。最后将字符数组转换为字符串。
public String removeDuplicates(String s) { if (s == null || s.length() == 0) { return null; } char[] chars = new char[s.length()]; for (int i = 0; i < s.length(); i++) { if (chars[i]!= s.charAt(i)) { chars[chars.length - 1] = s.charAt(i); } } return new String(chars);
}
- 如何合并两个字符串？
答案：可以通过一次遍历，将两个字符串中的字符合并到一个新的字符串中。
public String mergeStrings(String s1, String s2) { if (s1 == null) { return s2; } if (s2 == null) { return s1; } StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(s1.length(), s2.length()); i++) { char c1 = (i < s1.length())? s1.charAt(i) : '\0'; char c2 = (i < s2.length())? s2.charAt(i) : '\0'; sb.append(c1); sb.append(c2); } return sb.toString();
}
- 如何计算两个字符串的编辑距离？
答案：可以通过动态规划的方法，计算将一个字符串转换为另一个字符串所需的最少操作次数。
public int editDistance(String s1, String s2) { int m = s1.length(); int n = s2.length(); int[][] dp = new int[m + 1][n + 1];for (int i = 0; i <= m; i++) { for (int j = 0; j <= n; j++) { if (i == 0) { dp[i][j] = j; } else if (j == 0) { dp[i][j] = i; } else if (s1.charAt(i - 1) == s2.charAt(j - 1)) { dp[i][j] = dp[i - 1][j - 1]; } else { dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1; } } } return dp[m][n];
}
- 如何实现一个单例模式？
答案：可以使用懒汉式和饿汉式实现单例模式。
懒汉式：
public class Singleton { private static Singleton instance;private Singleton() { }public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; }
}
饿汉式：
public class Singleton { private static final Singleton instance = new Singleton();private Singleton() { }public static Singleton getInstance() { return instance; }
}
- 如何实现一个工厂模式？
答案：创建一个工厂类，根据传入的参数创建相应的对象。
public class Factory { public static void main(String[] args) { Product productA = factory.createProductA(); Product productB = factory.createProductB();productA.display(); productB.display(); }public static Product createProductA() { return new ProductA(); }public static Product createProductB() { return new ProductB(); }
}
abstract class Product { public abstract void display();
}
class ProductA extends Product { public void display() { System.out.println("Product A"); }
}
class ProductB extends Product { public void display() { System.out.println("Product B"); }
}
- 如何实现一个观察者模式？
答案：创建一个观察者接口，一个主题接口，以及具体的观察者和主题类。当主题状态发生变化时，通知所有观察者。
public class ObserverPattern { public static void main(String[] args) { Subject subject = new Subject(); Observer observer1 = new ConcreteObserver(subject); Observer observer2 = new ConcreteObserver(subject);subject.addObserver(observer1); subject.addObserver(observer2);subject.notifyObservers(); }public static interface Subject { void addObserver(Observer observer); void removeObserver(Observer observer); void notifyObservers(); }public static interface Observer { void update(String message); }public static class ConcreteObserver implements Observer { private Subject subject;public ConcreteObserver(Subject subject) { this.subject = subject; }@Override public void update(String message) { System.out.println("Received: " + message); } }public static class ConcreteSubject implements Subject { private List<Observer> observers;public ConcreteSubject() { observers = new ArrayList<>(); }@Override public void addObserver(Observer observer) { observers.add(observer); }@Override public void removeObserver(Observer observer) { observers.remove(observer); }@Override public void notifyObservers() { for (Observer observer : observers) { observer.update("Hello, World!"); } } }
}
- 如何实现一个策略模式？
答案：创建一个策略接口，以及具体的策略类。在运行时，根据不同的情况选择相应的策略来执行。
public class StrategyPattern { public static void main(String[] args) { Strategy strategy = new DefaultStrategy(); strategy.execute();strategy = new CustomStrategy(); strategy.execute(); }public static interface Strategy { void execute(); }public static class DefaultStrategy implements Strategy { @Override public void execute() { System.out.println("Default strategy"); } }public static class CustomStrategy implements Strategy { @Override public void execute() { System.out.println("Custom strategy"); } }
}
- 如何实现一个适配器模式？
实现适配器模式需要以下几个步骤：
- 确定目标接口：首先需要明确要适配的目标接口，即客户端期望使用的接口。这个接口可以是一个现有的接口，也可以是一个抽象的接口。
- 创建适配器类：创建一个适配器类，该类将实现目标接口，并在其内部包含一个被适配的类的实例。适配器类需要实现目标接口的所有方法，并在这些方法中调用被适配的类的相应方法。
- 实现目标接口：在适配器类中实现目标接口的所有方法，这些方法将被客户端使用。在实现这些方法时，需要将客户端传入的参数传递给被适配的类的相应方法，并将被适配的类的方法返回的结果返回给客户端。
下面是一个简单的适配器模式实现示例：
// 目标接口
public interface Target { void request();
}
// 被适配的类
public class Adaptee { public void specificRequest() { System.out.println("被适配的类的方法被调用"); }
}
// 适配器类
public class Adapter implements Target { private Adaptee adaptee;public Adapter(Adaptee adaptee) { this.adaptee = adaptee; }@Override public void request() { adaptee.specificRequest(); }
}
// 客户端代码
public class Client { public static void main(String[] args) { Adaptee adaptee = new Adaptee(); Target target = new Adapter(adaptee); target.request(); }
}
在这个示例中，Target 是目标接口，Adaptee 是被适配的类，Adapter 是适配器类。适配器类 Adapter 实现了目标接口 Target，并在其 request() 方法中调用了被适配的类 Adaptee 的 specificRequest() 方法。客户端代码通过目标接口 Target 使用适配器类 Adapter，实现了对被适配的类 Adaptee 的调用。
- 题目：汉诺塔问题
问题描述：请用 Java 实现一个解决方案，解决汉诺塔问题。汉诺塔是一个经典的递归问题，要求将一个杆子上的 N 个圆盘按照一定的规则从一边移动到另一边。
答案：以下是一个 Java 实现汉诺塔问题的示例代码：
public class HanoiTower { public static void main(String[] args) { int n = 3; // 设置盘子的数量 hanoi(n, 'A', 'B', 'C'); }/** * 汉诺塔递归方法 * @param n 盘子数量 * @param from 源柱子 * @param auxiliary 辅助柱子 * @param to 目标柱子 */ public static void hanoi(int n, char from, char auxiliary, char to) { if (n == 1) { // 当只有一个盘子时，直接从源柱子移动到目标柱子 System.out.println("Move disk 1 from " + from + " to " + to); } else { // 将 n-1 个盘子从源柱子借助目标柱子移动到辅助柱子 hanoi(n - 1, from, to, auxiliary); // 将第 n 个盘子从源柱子移动到目标柱子 System.out.println("Move disk " + n + " from " + from + " to " + to); // 将 n-1 个盘子从辅助柱子借助源柱子移动到目标柱子 hanoi(n - 1, auxiliary, from, to); } }
}
- 题目：购物车类
问题描述：请设计一个购物车类，包含添加商品、删除商品、计算总价等功能。
答案：以下是一个简单的购物车类实现：
public class ShoppingCart { private ArrayList<Item> items;public ShoppingCart() { items = new ArrayList<>(); }/** * 向购物车添加商品 * @param item 商品对象 */ public void addItem(Item item) { for (int i = 0; i < items.size(); i++) { if (items.get(i) == item) { items.set(i, item); return; } } items.add(item); }/** * 从购物车中删除商品 * @param item 商品对象 * @return 是否成功删除 */ public boolean removeItem(Item item) { for (int i = 0; i < items.size(); i++) { if (items.get(i) == item) { items.remove(i); return true; } } return false; }/** * 计算购物车中商品的总价 * @return 总价 */ public double calculateTotal() { double total = 0; for (Item item : items) { total += item.getPrice(); } return total; }
}
购物车类使用一个 ArrayList 来存储商品对象。添加商品、删除商品和计算总价的方法分别遍历 ArrayList 来完成相应操作。
