Java语言Leetcode中常用的一些基础语法

Java语言Leetcode中常用的一些基础语法

栈与队列

栈

在Java中，栈通常可以通过 java.util.Stack 类来实现。Stack 类继承自 Vector 类，提供了栈特有的操作方法。
栈是一种 后进先出（LIFO, Last In, First Out）结构。栈中的元素按顺序排列，最后加入的元素最先被移除。栈的典型操作包括：

• push：将元素推入栈顶。
• pop：移除栈顶元素。
• peek：查看栈顶元素，但不移除它。
• isEmpty：检查栈是否为空。

队列

在Java中，队列是通过 java.util.Queue 接口定义的，并有多个实现类。常见的实现类有：

• LinkedList：最常用的队列实现之一，它实现了 Queue 接口，因此提供了队列操作方法。
• PriorityQueue：一种基于优先级堆实现的队列，其中的元素是按自然顺序排序或由提供的比较器进行排序的。

常见的队列操作有：

offer(E e)：将元素插入队列末尾。如果队列能够接受此元素，则返回 true，否则返回 false。
poll()：移除并返回队列头部的元素。如果队列为空，则返回 null。
peek()：返回队列头部的元素但不移除它。如果队列为空，则返回 null。
isEmpty()：检查队列是否为空。
size()：返回队列中的元素个数。

在Java中，优先级队列（PriorityQueue）是基于优先级堆实现的队列，元素按照自然顺序或自定义的比较器排序。默认情况下，PriorityQueue 会使用元素的 自然排序（即实现了 Comparable 接口的对象）。但是，如果你需要自定义排序规则，可以通过传入一个比较器（Comparator）来控制元素的顺序。

import java.util.PriorityQueue;
import java.util.Comparator;

class Student {
    String name;
    int score;

    Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return name + ": " + score;
    }
}

public class PriorityQueueWithComparator {
    public static void main(String[] args) {
        // 自定义一个Comparator，按学生的分数降序排序
        Comparator<Student> byScoreDescending = new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                return Integer.compare(s2.score, s1.score); // 分数高的优先
            }
        };

        // 创建优先级队列，并传入自定义的比较器
        PriorityQueue<Student> queue = new PriorityQueue<>(byScoreDescending);

        // 向队列中添加学生
        queue.add(new Student("Alice", 90));
        queue.add(new Student("Bob", 85));
        queue.add(new Student("Charlie", 95));

        // 打印队列中的学生
        while (!queue.isEmpty()) {
            System.out.println(queue.poll()); // 按照分数从高到低打印学生
        }
    }
}

在Java中，双端队列（Deque, Double-Ended Queue）是一种队列，它允许从两端插入和移除元素。Deque 接口继承自 Queue 接口，并提供了更多的操作方法，使得可以从队列的两端进行元素的添加和删除。

Deque 接口
Deque 接口定义了双端队列的基本操作，包括：

• addFirst(E e)：将元素添加到队列的头部。
• addLast(E e)：将元素添加到队列的尾部。
• removeFirst()：移除并返回队列头部的元素。
• removeLast()：移除并返回队列尾部的元素。
• getFirst()：获取队列头部的元素，但不移除它。
• getLast()：获取队列尾部的元素，但不移除它。
• offerFirst(E e)：将元素插入队列头部，如果队列没有容量，则返回 false。
• offerLast(E e)：将元素插入队列尾部，如果队列没有容量，则返回 false。
• pollFirst()：移除并返回队列头部的元素，如果队列为空，返回 null。
• pollLast()：移除并返回队列尾部的元素，如果队列为空，返回 null。

类型转换

字符串与字符数组的转换

1. 字符串转字符数组
   可以通过 String 的 toCharArray() 方法将字符串转换为字符数组。

   String str = "hello";
   char[] charArray = str.toCharArray();
   

2. 字符数组转字符串
   可以通过 String 构造函数将字符数组转换为字符串。

   char[] charArray = {'h', 'e', 'l', 'l', 'o'};
   String str = new String(charArray);
   

数组与 List 的转换

1. 数组转 List
   可以使用 Arrays.asList() 方法将数组转换为 List。但是要注意，使用 Arrays.asList() 返回的 List 是固定大小的，不支持增加或删除元素。

   String[] array = {"apple", "banana", "cherry"};
   List<String> list = Arrays.asList(array);
   

   对于基本类型数组（如 int[]），需要转换为对应的包装类类型（如 Integer[]）：

   int[] arr = {1, 2, 3, 4};
   List<Integer> list = Arrays.stream(arr)  // 将int[]转为Stream
                               .boxed()     // 转换为Stream<Integer>
                               .collect(Collectors.toList());
   
   

2. List 转数组：
   不管是List转数组还是数组转list都可以用for循环赋值实现。

排序

在 Java 中，排序列表（List）通常通过 Collections.sort() 或 List.sort() 方法实现。

使用 Collections.sort()

Collections.sort() 方法是 Java 中最常用的排序方法之一。它按照元素的自然顺序对列表进行排序。该方法是基于归并排序（MergeSort）实现的，因此具有 O(n log n) 的时间复杂度。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortListExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(2);
        list.add(8);
        list.add(1);
        
        // 排序列表
        Collections.sort(list);
        
        // 打印排序后的列表
        System.out.println(list);  // 输出: [1, 2, 5, 8]
    }
}

使用 List.sort()

List.sort() 是 Java 8 引入的另一种排序方法，它是 List 接口的方法，接受一个 Comparator。它可以用于自定义排序规则。

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class ListSortExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(2);
        list.add(8);
        list.add(1);
        
        // 使用 List.sort() 和自定义比较器进行排序
        list.sort(Comparator.reverseOrder());  // 按降序排序
        
        // 打印排序后的列表
        System.out.println(list);  // 输出: [8, 5, 2, 1]
    }
}

自定义对象排序

对于自定义对象（如类的实例），可以通过实现 Comparable 接口来定义排序规则，或者通过传递自定义的 Comparator 对象来控制排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Person implements Comparable<Person> {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);  // 按年龄升序排序
    }

    @Override
    public String toString() {
        return name + ": " + age;
    }
}

public class PersonSortExample {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 25));
        list.add(new Person("Charlie", 35));
        
        // 使用 Collections.sort() 按年龄排序
        Collections.sort(list);
        
        // 打印排序后的列表
        System.out.println(list);  // 输出: [Bob: 25, Alice: 30, Charlie: 35]
    }
}