Java14新特性-Record类

Java 中的 Record 类

Record 类是 Java 14 引入的一种新特性，旨在简化不可变数据类的定义。它类似于枚举类，用于标记不可变的数据类。Record 类通过减少样板代码，使得类的定义更加简洁和紧凑1 2。

Record 类的定义

使用 record 关键字可以定义一个 Record 类。例如，定义一个包含 start 和 end 两个字段的 range 类，可以这样写：

public record range(int start, int end) {}

这相当于定义了一个 final 类，并自动实现了 equals、hashCode 和 toString 方法2。

使用示例

以下是一个使用 Record 类的示例：

public class Main {
    public static void main(String[] args) {
        range r = new range(100, 200);
        System.out.println(r.start()); // 输出: 100
        System.out.println(r.end()); // 输出: 200
        System.out.println(r); // 输出: range[start=100, end=200]
    }
}

在这个示例中，range 类自动生成了构造方法、字段访问方法以及 toString 方法特点和优势
Record 类具有以下特点和优势：

简洁性：使用 record 关键字可以一行代码定义一个不可变类，减少了样板代码1。
自动生成方法：编译器会自动生成构造方法、equals、hashCode 和 toString 方法2。
不可变性：Record 类是 final 类，所有字段也是 final 的，保证了类的不可变性3。

扩展功能

虽然 Record 类简化了类的定义，但它仍然允许添加自定义方法、静态方法和构造方法。例如，可以为 range 类添加一个计算距离的方法：

public record range(int start, int end) {
    public int distance() {
        return end - start;
    }
}

还可以添加静态方法来创建实例：

public record range(int start, int end) {
    public static range of(int start, int end) {
        return new range(start, end);
    }
}

通过这些扩展功能，Record 类不仅简化了类的定义，还提供了灵活性2 3。

Record 类是 Java 14 引入的一种新特性，旨在简化不可变数据类的定义。它通过减少样板代码，使得类的定义更加简洁和紧凑，同时提供了自动生成的方法和不可变性1 2。此外，Record 类还允许添加自定义方法和静态方法，提供了灵活性3。

例题: Codeforce Problem - D - Codeforces

采用record记录pair快速操作

import java.util.*;

public class Main {
    static void solve(Scanner sc) {
        String s = sc.next();
        var h = s.length();
        var n = sc.nextInt();

        List<String> cp = new ArrayList<>(Collections.nCopies(n + 1, ""));
        for (int i = 1; i <= n; i++) {
            cp.set(i, sc.next());
        }

        var is = new int[h + 1];
        Map<Integer, Integer> res = new HashMap<>();

        for (int i = 0; i < h; i++) {
            int maxp = 0, P = -1;
            for (int k = 1; k <= n; k++) {
                if (ck(cp.get(k), s, i, is) && maxp < cp.get(k).length()) {
                    maxp = cp.get(k).length();
                    P = k;
                }
            }
            if (P != -1) {
                res.put(i, P);
                work(cp.get(P), is, i);
            }
        }

        for (int i = 0; i < h; i++) {
            if (is[i] == 0) {
                System.out.println(-1);
                return;
            }
        }

        List<Move> ans = new ArrayList<>();
        for (var entry : res.entrySet()) {
            int x = entry.getKey(), y = entry.getValue();
            int tp = 0;
            for (int i = 0; i < cp.get(y).length(); i++) {
                if (is[x + i] >= 2) {
                    tp++;
                }
            }
            if (tp == cp.get(y).length()) {
                for (int i = 0; i < cp.get(y).length(); i++) {
                    is[x + i]--;
                }
            } else {
                ans.add(new Move(y, x));
            }
        }

        System.out.println(ans.size());
        for (Move move : ans) {
            System.out.println(move.k() + " " + (move.pos() + 1));
        }
    }

    static boolean ck(String p, String s, int pos, int[] is) {
        int c = 0, h = s.length();
        for (int i = 0; i < p.length(); i++) {
            if (i + pos >= h || p.charAt(i) != s.charAt(pos + i)) return false;
            if (is[i + pos] > 0) c++;
        }
        return c != p.length();
    }

    static void work(String p, int[] is, int pos) {
        for (int i = 0; i < p.length(); i++) {
            is[pos + i]++;
        }
    }

    record Move(int k, int pos) {}

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            int t = scanner.nextInt();
            while (t-- > 0) {
                solve(scanner);
            }
        }
    }
}