Las siguientes son preguntas comunes de entrevistas de programación para ingenieros de software Java de nivel intermedio y superior. Hay 20 preguntas en total.
- ¿Cómo determinar si una matriz es una matriz ordenada?
Respuesta: Puede comparar los tamaños de elementos adyacentes mediante un recorrido. Si se encuentra que los elementos adyacentes tienen un orden de tamaño incorrecto, la matriz no está ordenada.
public boolean isSortedArray(int[] nums) {
for (int i = 0; i < nums.length - 1; i++) {
if (nums[i] > nums[i + 1]) {
return false;
}
}
return true;
}
- ¿Cómo eliminar elementos duplicados de una matriz ordenada?
Respuesta: Los elementos duplicados adyacentes se pueden eliminar mediante un recorrido.
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;
}
- ¿Cómo fusionar dos matrices ordenadas?
Respuesta: Se pueden fusionar dos matrices ordenadas en una nueva matriz ordenada en una sola pasada.
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;
}
- ¿Cómo invertir una matriz?
Respuesta: Puedes voltear cada elemento de la matriz de una sola vez.
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;
}
}
- ¿Cómo calcular el promedio de una matriz?
Respuesta: Sume todos los elementos de la matriz y divida por la longitud de la matriz.
public double averageArray(int[] nums) {
long sum = 0;
for (int num : nums) {
sum += num;
}
return (double) sum / nums.length;
}
- ¿Cómo calcular la mediana de una matriz?
Respuesta: Después de ordenar la matriz, busque el elemento del medio. Si la longitud de la matriz es par, entonces el promedio de los dos elementos del medio es la mediana.
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];
}
}
- ¿Cómo calcular la moda de una matriz?
Respuesta: Puede contar el número de apariciones de cada elemento a través de un recorrido. El elemento que ocurre con mayor frecuencia es la moda.
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;
}
- ¿Cómo calcular la varianza de una matriz?
Respuesta: Resta todos los elementos de la matriz, elevalos al cuadrado, luego súmalos y finalmente divídelos por la longitud de la matriz.
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;
}
- ¿Cómo calcular la desviación estándar de una matriz?
Respuesta: Después de calcular la varianza, saque la raíz cuadrada de la varianza.
public double standardDeviationArray(int[] nums) {
double variance = varianceArray(nums);
return Math.sqrt(variance);
}
- ¿Cómo determinar si una cuerda es una cuerda palíndromo?
Respuesta: Puede utilizar dos recorridos para comparar si la primera mitad y la segunda mitad de la cadena son iguales.
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;
}
- ¿Cómo eliminar todos los caracteres duplicados de una cadena?
Respuesta: Puede agregar cada carácter de la cadena a una nueva matriz de caracteres en una sola pasada o, si el carácter no está presente en la matriz de caracteres, agregarlo a la matriz de caracteres. Finalmente convierta la matriz de caracteres en una cadena.
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);
}
- ¿Cómo fusionar dos cadenas?
Respuesta: Puede combinar caracteres de dos cadenas en una nueva cadena en una sola pasada.
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();
}
- ¿Cómo calcular la distancia de edición de dos cadenas?
Respuesta: Puede utilizar la programación dinámica para calcular la cantidad mínima de operaciones necesarias para convertir una cadena en otra.
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];
}
- ¿Cómo implementar un patrón singleton?
Respuesta: Puede utilizar el estilo perezoso y el estilo hambriento para implementar el patrón singleton.
Estilo de hombre perezoso:
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
Estilo chino hambriento:
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
- ¿Cómo implementar un patrón de fábrica?
Respuesta: Cree una clase de fábrica y cree los objetos correspondientes según los parámetros pasados.
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");
}
}
- ¿Cómo implementar un patrón de observador?
Respuesta: Cree una interfaz de observador, una interfaz de sujeto y clases concretas de observador y sujeto. Notifique a todos los observadores cuando cambie el estado del tema.
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!");
}
}
}
}
- ¿Cómo implementar un patrón de estrategia?
Respuesta: Cree una interfaz de estrategia y una clase de estrategia específica. En tiempo de ejecución, se seleccionan estrategias apropiadas para su ejecución en función de diferentes situaciones.
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");
}
}
}
- ¿Cómo implementar un patrón de adaptador?
La implementación del patrón de adaptador requiere los siguientes pasos:
- Determine la interfaz de destino: primero, debe aclarar la interfaz de destino que se adaptará, es decir, la interfaz que el cliente espera utilizar. Esta interfaz puede ser una interfaz existente o una interfaz abstracta.
- Cree una clase de adaptador: cree una clase de adaptador que implementará la interfaz de destino y contendrá una instancia de la clase adaptada en su interior. La clase adaptadora necesita implementar todos los métodos de la interfaz de destino y llamar a los métodos correspondientes de la clase adaptada en estos métodos.
- Implementar la interfaz de destino: implemente todos los métodos de la interfaz de destino en la clase de adaptador, que será utilizada por el cliente. Al implementar estos métodos, debe pasar los parámetros pasados por el cliente a los métodos correspondientes de la clase adaptada y devolver los resultados devueltos por los métodos de la clase adaptada al cliente.
A continuación se muestra un ejemplo de implementación simple del patrón de adaptador:
// 目标接口
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();
}
}
En este ejemplo, Targetes la interfaz de destino, Adapteela clase que se está adaptando Adaptery la clase de adaptador. La clase adaptadora Adapterimplementa la interfaz de destino Targety llama al método de request()la clase adaptada en su método . El código del cliente utiliza la clase de adaptador a través de la interfaz de destino para implementar la llamada a la clase adaptada .AdapteespecificRequest()TargetAdapterAdaptee
- Título: Problema de la Torre de Hanoi
Descripción del problema: Utilice Java para implementar una solución para resolver el problema de la Torre de Hanoi. La Torre de Hanoi es un problema recursivo clásico que requiere mover N discos en un poste de un lado a otro según ciertas reglas.
Respuesta: El siguiente es un código de muestra que implementa el problema de la Torre de Hanoi en 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);
}
}
}
- Título: Clase de carrito de compras
Descripción del problema: Diseñe una clase de carrito de compras, que incluya funciones como agregar productos, eliminar productos, calcular el precio total, etc.
Respuesta: La siguiente es una implementación simple de una clase de carrito de compras:
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;
}
}
La clase de carrito de compras usa ArrayList para almacenar objetos de productos. Los métodos para agregar productos, eliminar productos y calcular el precio total atraviesan respectivamente ArrayList para completar las operaciones correspondientes.