python适合网站开发吗,淘宝客为什么做网站,龙华做网站哪家好,wordpress 出现广告以下是中高级Java软件工程师常见编程面试题#xff0c;共有20道。
如何判断一个数组是否为有序数组#xff1f; 答案#xff1a;可以通过一次遍历#xff0c;比较相邻元素的大小。如果发现相邻元素的大小顺序不对#xff0c;则数组不是有序数组。
public boolean isSort…
以下是中高级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 ListObserver 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 ArrayListItem 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 来完成相应操作。
