国庆中秋特辑（七）Java软件工程师常见20道编程面试题

傷城~ 2023-10-16 17:18 34阅读 0赞

![在这里插入图片描述][eb617570dfe24f5b98918ba8dd85282b.png_pic_center]

以下是中高级Java软件工程师常见编程面试题，共有20道。

1.  如何判断一个数组是否为有序数组？  
    答案：可以通过一次遍历，比较相邻元素的大小。如果发现相邻元素的大小顺序不对，则数组不是有序数组。

public boolean isSortedArray(int[] nums) {
          
       for (int i = 0; i < nums.length - 1; i++) {
          
           if (nums[i] > nums[i + 1]) {
          
               return false;  
           }  
       }  
       return true;  
    }

1.  如何删除一个有序数组中的重复元素？  
    答案：可以通过一次遍历，将相邻的重复元素删除。

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;  
    }

1.  如何合并两个有序数组？  
    答案：可以通过一次遍历，将两个有序数组合并成一个新的有序数组。

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;  
    }

1.  如何反转一个数组？  
    答案：可以通过一次遍历，将数组的每个元素翻转。

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;  
       }  
    }

1.  如何计算一个数组的平均值？  
    答案：将数组的所有元素相加，然后除以数组的长度。

public double averageArray(int[] nums) {
          
       long sum = 0;  
       for (int num : nums) {
          
           sum += num;  
       }  
       return (double) sum / nums.length;  
    }

1.  如何计算一个数组的中位数？  
    答案：将数组排序后，找到中间的元素。如果数组长度为偶数，则中间的两个元素的平均值是中位数。

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];  
       }  
    }

1.  如何计算一个数组的众数？  
    答案：可以通过一次遍历，统计每个元素出现的次数。出现次数最多的元素是众数。

public int mostCommon(int[] nums) {
          
       int[] count = new int[101];  
       for (int num : nums) {
          
           count[num]++;  
       }  
       int max = 0;  
       int res
    
       for (int i = 0; i < 101; i++) {
            
           if (count[i] > max) {
            
               max = count[i];    
               res = i;    
           }    
       }    
       return res;    
    }

1.  如何计算一个数组的方差？  
    答案：将数组的所有元素相减后求平方，然后求和，最后除以数组的长度。

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;    
    }

1.  如何计算一个数组的标准差？  
    答案：计算方差后，对方差开平方根。

public double standardDeviationArray(int[] nums) {
            
       double variance = varianceArray(nums);    
       return Math.sqrt(variance);    
    }

1.  如何判断一个字符串是否为回文字符串？  
    答案：可以通过两次遍历，比较字符串的前半部分和后半部分是否相同。

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;    
    }

1.  如何删除一个字符串中的所有重复字符？  
    答案：可以通过一次遍历，将字符串中的每个字符添加到一个新的字符数组中，如果字符数组中没有该字符，则将该字符添加到字符数组中。最后将字符数组转换为字符串。

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);    
    }

1.  如何合并两个字符串？  
    答案：可以通过一次遍历，将两个字符串中的字符合并到一个新的字符串中。

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();    
    }

1.  如何计算两个字符串的编辑距离？  
    答案：可以通过动态规划的方法，计算将一个字符串转换为另一个字符串所需的最少操作次数。

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];  
    }

1.  如何实现一个单例模式？  
    答案：可以使用懒汉式和饿汉式实现单例模式。  
    懒汉式：

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;  
       }  
    }

1.  如何实现一个工厂模式？  
    答案：创建一个工厂类，根据传入的参数创建相应的对象。

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");  
       }  
    }

1.  如何实现一个观察者模式？  
    答案：创建一个观察者接口，一个主题接口，以及具体的观察者和主题类。当主题状态发生变化时，通知所有观察者。

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!");  
               }  
           }  
       }  
    }

1.  如何实现一个策略模式？  
    答案：创建一个策略接口，以及具体的策略类。在运行时，根据不同的情况选择相应的策略来执行。

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");  
           }  
       }  
    }

1.  如何实现一个适配器模式？

实现适配器模式需要以下几个步骤：

1.  确定目标接口：首先需要明确要适配的目标接口，即客户端期望使用的接口。这个接口可以是一个现有的接口，也可以是一个抽象的接口。
2.  创建适配器类：创建一个适配器类，该类将实现目标接口，并在其内部包含一个被适配的类的实例。适配器类需要实现目标接口的所有方法，并在这些方法中调用被适配的类的相应方法。
3.  实现目标接口：在适配器类中实现目标接口的所有方法，这些方法将被客户端使用。在实现这些方法时，需要将客户端传入的参数传递给被适配的类的相应方法，并将被适配的类的方法返回的结果返回给客户端。  
    下面是一个简单的适配器模式实现示例：

// 目标接口  
    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` 的调用。

1.  题目：汉诺塔问题  
    问题描述：请用 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);  
           }  
       }  
    }

1.  题目：购物车类  
    问题描述：请设计一个购物车类，包含添加商品、删除商品、计算总价等功能。  
    答案：以下是一个简单的购物车类实现：

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 来完成相应操作。

[eb617570dfe24f5b98918ba8dd85282b.png_pic_center]: https://img-blog.csdnimg.cn/eb617570dfe24f5b98918ba8dd85282b.png#pic_center