import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        
        int n = Integer.parseInt(br.readLine());
        String[] times = br.readLine().split(" ");
        
        long prev = parseTime(times[0]);
        for (int i = 1; i < n; i++) {
            long current = parseTime(times[i]);
            long diff = current - prev;
            if (diff < 0) {
                diff += 24 * 60 * 60; 
            }
            double circles = diff / 60.0;
            pw.printf("%.2f\n", circles);
            prev = current;
        }
        pw.flush();
    }
    
    private static long parseTime(String time) {
        String[] parts = time.split(":");
        int hour = Integer.parseInt(parts[0]);
        int minute = Integer.parseInt(parts[1]);
        int second = Integer.parseInt(parts[2]);
        return hour * 3600L + minute * 60L + second;
    }
}

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        
        while ((line = br.readLine()) != null) { // 逐行读取
            int n = Integer.parseInt(line.trim());
            int[] nums = new int[n];
            
            String[] parts = br.readLine().split(" ");
            for (int i = 0; i < n; i++) {
                nums[i] = Integer.parseInt(parts[i]);
            }
            // 处理逻辑
            // 输出结果
            System.out.println(result);
        }
    }
}
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.next();
        System.out.println(replaceNumber(s));
        scanner.close();
    }

import java.util.*;
import java.io.*;

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String s = scanner.next();
    System.out.println(replaceNumber(s));
    scanner.close();
}

public class Main {
    public static void main(String[] args) {
        // 示例1: 数组输入
        int[] nums = {1, 3, 5, 2, 4};
        int target = 5;
        
        // 示例2: 矩阵/二维数组
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 示例3: 链表（需要先定义ListNode类）
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        
        // 示例4: 字符串
        String s = "hello world";
        String pattern = "hello";
        
        // 调用你的算法函数
        int result = twoSum(nums, target);
        System.out.println("结果: " + result);
    }
    
    // 你的算法函数
    public static int twoSum(int[] nums, int target) {
        // 算法实现...
        return 0;
    }
}
//字符串数组
String[] words1 = {"hello", "world", "java", "algorithm"};

// 链表节点定义
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

public class RandomDemo {
    public static void main(String[] args) {
        int n = 10;
        //0~9
        // 方法1: Math.random()
        int random1 = (int) (Math.random() * n);
        System.out.println("Math.random(): " + random1);

        // 方法2: Random类
        Random rand = new Random();
        int random2 = rand.nextInt(n);
        System.out.println("Random: " + random2);

        // 方法3: ThreadLocalRandom（多线程安全）
        int random3 = ThreadLocalRandom.current().nextInt(n);
        System.out.println("ThreadLocalRandom: " + random3);
    }
}

// ========== 数组声明与初始化 ==========
int[] arr = new int[5];              // 创建空数组 [0,0,0,0,0]
int[] nums = {3,1,4,5,2};            // 直接初始化
String[] strArr = {"A", "B", "C"};   // 字符串数组
int[][] matrix = {{1,2}, {3,4,5}};   // 二维数组
// ========== 基本操作 ==========
// 访问元素
int first = nums[0];                
nums[2] = 9;                        
// 获取长度
int len = nums.length;                // 一维数组长度 → 5
int cols = matrix[1].length;          // 二维数组第二维长度 → 3

// ========== 遍历操作 ==========
// 普通for循环
for(int i=0; i<nums.length; i++) {
    System.out.print(nums[i] + " "); // 3 1 9 5 2
}
// 增强for循环
for(int num : nums) {
    System.out.print(num + " ");
}
// 二维数组遍历
for(int[] row : matrix) {
    for(int n : row) {
        System.out.print(n + " ");   // 1 2 / 3 4 5
    }
}

// ========== 数组工具操作 ==========
// ========== 排序操作 ==========
//升序排序
Arrays.sort(array);
//降序排序
Arrays.sort(Collections.reverseOrder());
//自定义排序
Arrays.sort(array, (a, b) -> a - b); //升序
Arrays.sort(array, (a, b) -> b - a); //降序
// 复制
int[] copy1 = Arrays.copyOf(nums, 3); // 复制前3元素 → [1,2,3]
int[] copy2 = Arrays.copyOfRange(nums, 1, 4); // 复制1-3索引 → [2,3,5]
// 比较
boolean isEqual = Arrays.equals(nums, copy1); // false
// 填充
Arrays.fill(nums, 0);                // 全部填充0 → [0,0,0,0,0]
Arrays.fill(nums, 1, 3, 5);          // 索引1-2填充5 → [0,5,5,0,0]
// ========== 类型转换 ==========
// 数组转List（固定大小）
List<Integer> list = Arrays.asList(1,2,3); 
// 数组转Stream
IntStream stream = Arrays.stream(nums);
// ========== 其他操作 ==========
// 二分查找（需先排序）
int index = Arrays.binarySearch(nums, 5);  // 返回元素索引
// 多维数组操作
int[][] matrixCopy = Arrays.copyOf(matrix, matrix.length); // 浅拷贝
String deepStr = Arrays.deepToString(matrix); // "[[1, 2], [3, 4, 5]]"
// 反转数组
for(int i=0; i<nums.length/2; i++) {
    int temp = nums[i];
    nums[i] = nums[nums.length-1-i];
    nums[nums.length-1-i] = temp;
}

public int[] maxSubsequence(int[] nums, int k) {
    int n=nums.length;
    int ans[]=new int[k];
    Integer idx[]=new Integer[n];
    Arrays.setAll(idx, i->i);
    Arrays.sort(idx,(a,b)->nums[a]-nums[b]);
    int j=0;
    for(int i=n-k;i<n;i++) {
        ans[j++]=idx[i];
    }
    Arrays.sort(ans);
    for(int i=0;i<k;i++) {
        ans[i]=nums[ans[i]];
    }
    return ans;
}

Integer[] arr = {1,2,3};
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(arr));
ArrayList<Integer> list = new ArrayList<>();
Integer[] arr = list.toArray(new Integer[0]);
//但是如何转成int[]数组呢
//方法1 
arr = list.stream().mapToInt(Integer::valueOf).toArray();

// ====================== 1. 初始化 List ======================
List<String> arrayList = new ArrayList<>();   // 可修改列表
List<Integer> linkedList = new LinkedList<>(); 
List<String> immutableList = List.of("A", "B", "C");  // Java9+ 不可变列表

// ====================== 2. 添加元素 ======================
arrayList.add("Apple");       // 末尾添加
arrayList.add(0, "Banana");   // 索引0插入
arrayList.addAll(List.of("Orange", "Grape"));  // 批量添加

// ====================== 3. 访问元素 ======================
String firstElement = arrayList.get(0);               // "Banana"
boolean containsApple = arrayList.contains("Apple");  // true
int indexOfOrange = arrayList.indexOf("Orange");      // 2

// ====================== 4. 删除元素 ======================
arrayList.remove("Banana");    // 按值删除
arrayList.remove(0);          // 按索引删除
arrayList.clear();            // 清空列表

// ====================== 5. 修改元素 ======================
arrayList.add("Mango");
arrayList.set(0, "Pineapple");  // 修改索引0的元素

// ====================== 6. 遍历 List ======================
Collections.sort(path); // 直接修改原List
Collections.sort(path, Collections.reverseOrder()); // 降序排序
// 方式1: 普通for循环
for (int i = 0; i < arrayList.size(); i++) {
    System.out.println(arrayList.get(i));
}

// 方式2: 增强for循环
for (String fruit : arrayList) {
    System.out.println(fruit);
}

// 方式3: 迭代器
Iterator<String> it = arrayList.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// 方式4: forEach + Lambda
arrayList.forEach(System.out::println);

// ====================== 7. 其他操作 ======================
int size = arrayList.size();                     // 列表长度
boolean isEmpty = arrayList.isEmpty();           // 是否为空
List<String> subList = arrayList.subList(0, 2);  // 截取子列表
Object[] array = arrayList.toArray();            // 转为数组

// ====================== 8. 注意事项 ======================
/*
1. ArrayList初始容量10，扩容1.5倍 
2. LinkedList用节点链接实现
3. 线程不安全，多线程环境使用：
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
4. 快速失败机制(fast-fail)：遍历时修改会抛出ConcurrentModificationException
*/

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class TwoDListExample {
    public static void main(String[] args) {
        // ======================
        // 1. 创建二维List
        // ======================
        List<Integer>[] ls = new ArrayList[26];
        Arrays.setAll(ls,i->new ArrayList<>());
        // 方法1: 使用Arrays.asList()初始化
        List<List<Integer>> matrix1 = new ArrayList<>();
        matrix1.add(Arrays.asList(1, 2, 3));
        matrix1.add(Arrays.asList(4, 5, 6));
        matrix1.add(Arrays.asList(7, 8, 9));
        
        // 方法2: 动态创建空二维List
        List<List<String>> matrix2 = new ArrayList<>();
        
        // 方法3: 使用嵌套循环初始化
        List<List<Character>> matrix3 = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            List<Character> row = new ArrayList<>();
            for (int j = 0; j < 4; j++) {
                row.add((char) ('A' + i + j));
            }
            matrix3.add(row);
        }
        // ======================
        // 2. 添加元素
        // ======================
        // 添加新行
        matrix2.add(new ArrayList<>(Arrays.asList("Java", "Python")));
        matrix2.add(new ArrayList<>(Arrays.asList("C++", "JavaScript")));
        
        // 在指定行添加元素
        matrix2.get(0).add("Ruby");      // 第一行添加元素
        matrix2.get(1).add(0, "Go");     // 第二行开头插入元素
        
        // 添加新行（空行）
        matrix2.add(new ArrayList<>());
        matrix2.get(2).add("Swift");     // 给新行添加元素

        // ======================
        // 3. 访问元素
        // ======================
        
        // 访问单个元素
        int element = matrix1.get(1).get(2);  // 获取第二行第三列元素 → 6
        String lang = matrix2.get(0).get(1);  // 获取第一行第二列元素 → "Python"
        
        // 获取行数
        int rows = matrix1.size();
        
        // 获取列数（特定行）
        int colsRow0 = matrix1.get(0).size();
        int colsRow2 = matrix2.get(2).size();

        // ======================
        // 4. 修改元素
        // ======================
        
        matrix1.get(0).set(0, 100);     // 修改第一行第一列: 1 → 100
        matrix2.get(1).set(2, "TypeScript"); // 修改第二行第三列

        // ======================
        // 5. 删除元素
        // ======================
        
        // 删除指定位置的元素
        matrix1.get(2).remove(1);       // 删除第三行第二列元素(8)
        
        // 删除整行
        matrix2.remove(2);              // 删除第三行

        // ======================
        // 6. 遍历二维List
        // ======================
        
        System.out.println("\n遍历matrix1:");
        // 方法1: 索引遍历
        for (int i = 0; i < matrix1.size(); i++) {
            for (int j = 0; j < matrix1.get(i).size(); j++) {
                System.out.print(matrix1.get(i).get(j) + " ");
            }
            System.out.println();
        }
        
        System.out.println("\n遍历matrix2:");
        // 方法2: 增强for循环
        for (List<String> row : matrix2) {
            for (String item : row) {
                System.out.print(item + " ");
            }
            System.out.println();
        }
        
        System.out.println("\n遍历matrix3:");
        // 方法3: 使用forEach + lambda
        matrix3.forEach(row -> {
            row.forEach(item -> System.out.print(item + " "));
            System.out.println();
        });

        // ======================
        // 7. 其他常用操作
        // ======================
        
        // 检查是否为空
        boolean isEmpty = matrix2.isEmpty();
        
        // 检查是否包含元素
        boolean containsPython = matrix2.get(0).contains("Python");
        
        // 查找元素位置
        int rowIndex = -1, colIndex = -1;
        for (int i = 0; i < matrix1.size(); i++) {
            int index = matrix1.get(i).indexOf(5);
            if (index != -1) {
                rowIndex = i;
                colIndex = index;
                break;
            }
        }
        
        // 转换为二维数组
        String[][] array2D = new String[matrix2.size()][];
        for (int i = 0; i < matrix2.size(); i++) {
            List<String> row = matrix2.get(i);
            array2D[i] = row.toArray(new String[0]);
        }

        ////翻转行
        //方法1 使用工具类
        List<List<Integer>> matrix = new ArrayList<>();
        // 假设 matrix 已经填充数据
        // 翻转行（首行变末行，次行变次末行，依此类推）
        Collections.reverse(matrix);

        //方法2
        List<List<Integer>> matrix = new ArrayList<>();
        // 假设 matrix 已经填充数据
        int left = 0;
        int right = matrix.size() - 1;
        while (left < right) {
            // 使用临时行 temp 交换左右两行
            List<Integer> temp = matrix.get(left);
            matrix.set(left, matrix.get(right));
            matrix.set(right, temp);
            left++;
            right--;
        }
        //方法3 Stream
        List<List<Integer>> matrix = new ArrayList<>();
        // 假设 matrix 已经填充数据
        // 翻转行顺序
        List<List<Integer>> reversed = IntStream.range(0, matrix.size())
            .mapToObj(i -> matrix.get(matrix.size() - 1 - i))
            .collect(Collectors.toList());

        matrix = reversed; // 如果需要原地翻转，需重新赋值

        // 打印结果
        System.out.println("\nmatrix1: " + matrix1);
        System.out.println("matrix2: " + matrix2);
        System.out.println("matrix3: " + matrix3);
        System.out.println("找到数字5的位置: [" + rowIndex + "][" + colIndex + "]");
    }
}

// =================== HashSet 基础操作 ===================
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

// 创建对象
Set<String> set = new HashSet<>();       // 空集合（默认初始容量16，负载因子0.75）
Set<Integer> initSet = new HashSet<>(32); // 指定初始容量
Set<String> prefilled = new HashSet<>(Arrays.asList("A", "B", "C")); // 通过集合初始化

// 元素操作
boolean added = set.add("Apple");        // 添加元素 → true（首次添加）
boolean dupAdd = set.add("Apple");       // 添加重复元素 → false
boolean hasBanana = set.contains("Apple"); // 检查存在 → true
boolean removed = set.remove("Apple");   // 删除元素 → true（存在时）
set.clear();                             // 清空集合

// 批量操作
Set<String> fruits = new HashSet<>(Arrays.asList("Orange", "Mango"));
boolean addedAll = set.addAll(fruits);   // 合并集合 → true（集合改变时）
boolean retainAll = set.retainAll(Arrays.asList("Mango")); // 保留交集 → true（集合改变时）
boolean removeAll = set.removeAll(fruits); // 删除所有匹配元素 → true（集合改变时）

// 遍历操作
set.add("Apple");
set.add("Banana");
for (String item : set) {                // 增强for循环（无序）
    System.out.print(item + " ");        // 输出顺序不确定（如 "Banana Apple"）
}

Iterator<String> it = set.iterator();    // 迭代器遍历
while (it.hasNext()) {
    System.out.print(it.next() + " ");
}

set.forEach(item -> System.out.print(item)); // Java8+ Lambda遍历

// 集合信息
int size = set.size();                   // 元素数量（如 2）
boolean isEmpty = set.isEmpty();          // 是否空集合 → false
Object[] array = set.toArray();          // 转Object数组
String[] strArray = set.toArray(new String[0]); // 转指定类型数组

// 特殊操作
Set<String> cloneSet = (HashSet<String>) ((HashSet<String>) set).clone(); // 浅拷贝
Set<String> syncSet = Collections.synchronizedSet(set); // 线程安全包装

// 集合运算示例
Set<String> set1 = new HashSet<>(Arrays.asList("A", "B"));
Set<String> set2 = new HashSet<>(Arrays.asList("B", "C"));

Set<String> union = new HashSet<>(set1);  // 并集 → [A, B, C]
union.addAll(set2);

Set<String> intersection = new HashSet<>(set1); // 交集 → [B]
intersection.retainAll(set2);

Set<String> difference = new HashSet<>(set1);   // 差集 → [A]
difference.removeAll(set2);

/* 核心特性：
1. 唯一性：基于 hashCode() 和 equals() 判断重复
2. 无序性：遍历顺序不保证与插入顺序一致
3. 允许 null 元素（但只能有一个 null）
4. 基础操作时间复杂度：add/remove/contains → 平均 O(1)
5. 非线程安全：需通过 Collections.synchronizedSet 包装实现线程安全
*/

// =================== HashMap 基础操作 ===================
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

// 创建对象
Map<String, Integer> map = new HashMap<>();         // 默认容量16，负载因子0.75
Map<String, String> initMap = new HashMap<>(32);    // 指定初始容量
Map<String, Integer> prefilled = new HashMap<>(Map.of("A", 1, "B", 2)); // Java9+快速初始化

// 增删改操作
map.put("Apple", 10);              // 添加键值对 → {Apple=10}
map.put("Banana", 20);             // → {Apple=10, Banana=20}
map.putIfAbsent("Apple", 50);      // 仅当键不存在时添加 → 原值10保持不变
map.replace("Apple", 15);          // 替换已有键的值 → {Apple=15, Banana=20}
map.remove("Banana");              // 删除键 → {Apple=15}
map.replace("Apple", 15, 20);      // 键值匹配时替换 → {Apple=20}
map.clear();                       // 清空映射

// 查询操作
int count = map.get("Apple");       // 获取值（需确保键存在）
Integer countSafe = map.get("Orange"); // 键不存在时返回null
boolean existsKey = map.containsKey("Apple"); // 检查键是否存在 → true
boolean existsValue = map.containsValue(20); // 检查值是否存在 → true
int size = map.size();             // 键值对数量
boolean isEmpty = map.isEmpty();   // 是否为空映射

// 遍历操作（4种方式）
// 1. Entry遍历（推荐）
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 2. Key遍历
for (String key : map.keySet()) {
    System.out.println(key + " -> " + map.get(key));
}

// 3. Value遍历
for (Integer value : map.values()) {
    System.out.println("Value: " + value);
}

// 4. Java8+ Lambda遍历
map.forEach((k, v) -> System.out.println(k + "=" + v));

// 批量操作
Map<String, Integer> newItems = Map.of("Cherry", 5, "Durian", 8);
map.putAll(newItems);              // 合并映射 → {Apple=20, Cherry=5, Durian=8}

// 特殊值处理
map.put(null, 0);                  // 允许null键 → {null=0}
map.put("Mango", null);            // 允许null值 → {null=0, Mango=null}

// 高级操作（Java8+）
map.computeIfAbsent("Orange", k -> 3);    // 不存在时计算 → 添加 Orange=3
map.computeIfPresent("Apple", (k, v) -> v + 5); // 存在时更新 → Apple=25
map.merge("Apple", 10, (oldVal, newVal) -> oldVal + newVal); // 合并值 → Apple=35

// 线程安全包装
Map<String, Integer> syncMap = Collections.synchronizedMap(map);

// 不可变映射（Java9+）
Map<String, Integer> immutableMap = Map.ofEntries(
    Map.entry("A", 1),
    Map.entry("B", 2)
);

/* 核心特性：
1. 键唯一性：基于 hashCode() 和 equals() 判断重复
2. 无序存储：迭代顺序不保证与插入顺序一致
3. 允许一个null键和多个null值
4. 基础操作时间复杂度：get/put → 平均 O(1)
5. 扩容机制：当元素数量超过（容量*负载因子）时自动翻倍扩容
6. 树化优化：当链表长度超过8时转红黑树（Java8+）
*/

HashMap<Character, Integer> hm_s = new HashMap<>();
//遍历字符串的所有字符（更清晰的逻辑）
for (char c : s.toCharArray()) {
    hm_s.merge(c, 1, Integer::sum);
}
// 使用getOrDefault避免NullPointerException
int countS = hm_s.getOrDefault(c, 0);

//初始化
HashMap<String, List<Integer>> multiValueMap = new HashMap<>();

/////添加元素
if (!multiValueMap.containsKey("scores")) {
    multiValueMap.put("scores", new ArrayList<>());
}
multiValueMap.get("scores").add(90);
// 若键不存在，自动创建空列表
multiValueMap.computeIfAbsent("scores", k -> new ArrayList<>()).add(90);
multiValueMap.computeIfAbsent("scores", k -> new ArrayList<>()).add(85);

////访问元素
//获取某个键的所有值
List<Integer> scores = multiValueMap.get("scores");
if (scores != null) {
    for (int num : scores) {
        System.out.println(num); //输出 90, 85
    }
}
//避免 NullPointerException的情况
List<Integer> scores = multiValueMap.getOrDefault("scores", new ArrayList<>());
for (int num : scores) {
    System.out.println(num);
}

////删除元素
//删除整个键值对
multiValueMap.remove("scores");
// 删除某个键的特定值
List<Integer> scores = multiValueMap.get("scores");
if (scores != null) {
    scores.remove(Integer.valueOf(90)); // 删除值为 90 的元素
    // 如果列表为空，可选删除键
    if (scores.isEmpty()) {
        multiValueMap.remove("scores");
    }
}

////遍历哈希表
// 遍历所有键值对
for (Map.Entry<String, List<Integer>> entry : multiValueMap.entrySet()) {
    String key = entry.getKey();
    List<Integer> values = entry.getValue();
    System.out.println(key + ": " + values);
}
//遍历所有键
for (String key : multiValueMap.keySet()) {
    System.out.println("Key: " + key);
}
//遍历所有值
for (List<Integer> values : multiValueMap.values()) {
    System.out.println("Values: " + values);
}

// =================== String 常用操作 ===================
// 创建对象
String str1 = "Hello";                   // 直接量创建（字符串常量池）
String str2 = new String("World");       // 堆内存新对象
char[] chars = {'J','a','v','a'};
String str3 = new String(chars);          // 通过字符数组创建 → "Java"

// 基本操作
int len = str1.length();                  // 获取长度 → 5
char c = str1.charAt(1);                  // 获取索引1字符 → 'e'
String substr1 = str1.substring(2);      // 从索引2截取 → "llo"
String substr2 = str1.substring(1,4);    // 截取1-3索引 → "ell"
String concatStr = str1.concat(" World");// 拼接 → "Hello World"
String upper = str1.toUpperCase();       // 转大写 → "HELLO"
String lower = "HELLO".toLowerCase();    // 转小写 → "hello"
String trimStr = "  text  ".trim();      // 去首尾空格 → "text"
String replaced = str1.replace('l', 'L');// 替换字符 → "HeLLo"
String replacedAll = "a1b2c3".replaceAll("\\d", "#"); // 正则替换 → "a#b#c#"

// 转换与比较
char[] arr = str1.toCharArray();         // 转字符数组 → ['H','e','l','l','o']
byte[] bytes = str1.getBytes();          // 按默认编码转字节数组
boolean eq1 = str1.equals("Hello");      // 值比较 → true
boolean eq2 = str1.equalsIgnoreCase("hElLo"); // 忽略大小写 → true
int cmp = str1.compareTo("Hella");       // 字典序比较 → 正数（'o' > 'a'）

// 正则处理
boolean matches = "123".matches("\\d+");      // 正则匹配 → true
String[] parts = "a,b,c".split(",");          // 分割
//Arrays.adList()
// 字符串 → ["a","b","c"]
String[] regexParts = "a1b2c3".split("\\d");  // 按数字分割 → ["a","b","c"]

// 格式化处理
String format1 = String.format("%s-%d", "ID", 100);  // → "ID-100"
String format2 = String.join("|", "A", "B", "C");    // → "A|B|C"

// 特殊判断
boolean isEmpty = "".isEmpty();          // 空字符串 → true
boolean isBlank = "   ".isBlank();       // 全空白字符（Java 11+） → true
boolean starts = str1.startsWith("He");  // 开头判断 → true
boolean ends = str1.endsWith("lo");      // 结尾判断 → true

/* 核心特性：
1. 不可变性：所有操作返回新字符串，原对象不变
2. 字符串常量池复用机制：直接量赋值优先使用常量池
3. 支持正则表达式操作（split/matches/replaceAll等）
4. 包含丰富的格式化方法（format/join等）
*/

// =================== StringBuilder ===================
// 创建对象
StringBuilder sb = new StringBuilder();      // 默认容量16
StringBuilder sb2 = new StringBuilder("Hello"); // 指定初始内容

// 基本操作
sb.append(" World");       // 追加内容 → "Hello World"
sb.insert(5, " Java");     // 指定位置插入 → "Hello Java World"
sb.delete(5, 10);          // 删除5-9位置 → "Hello World"
sb.replace(6, 11, "Earth"); // 替换指定区间 → "Hello Earth"
sb.reverse();              // 反转 → "htraE olleH" 
sb.setLength(5);           // 截断保留前5字符 → "htraE"
char c = sb.charAt(2);     // 获取索引2的字符 → 'r'
sb.setCharAt(0, 'H');      // 修改索引0字符 → "HtraE"
int len = sb.length();     // 获取当前长度 → 5
String s = sb.toString();  // 转换为String
res = new StringBuilder(p.s).repeat(res,p.k); //重复res k次 重复操作

// 正向遍历
for (int i = 0; i < sb.length(); i++) {
    char c = sb.charAt(i);
    System.out.println(c);
}
// 链式调用
StringBuilder sb3 = new StringBuilder()
    .append(123)           // 支持多类型
    .append(3.14)
    .append(true);

sb.setLength(prevLen); // 直接回退到添加前的长度

// =================== StringBuffer ===================
// 创建对象（操作方法与StringBuilder完全一致）
StringBuffer sbf = new StringBuffer(); 
sbf.append(100);           // 追加数值
sbf.insert(3, new char[]{'A','B'}); // 插入字符数组
sbf.deleteCharAt(4);       // 删除单个字符
sbf.setLength(0);          // 清空缓冲区（复用对象）

// 线程安全示例
sbf.append("ThreadSafe");  // 所有方法都有synchronized修饰符

/* 共性特征：
1. 初始容量16，自动扩容（每次扩容2n+2）
2. append() 支持所有基础类型/Object类型
3. 修改后对象地址不变（与String的不可变性对比）
4. 主要方法：append/insert/delete/replace/reverse
*/
String s1 = buffer.toString();  // StringBuffer → String
String s2 = builder.toString(); // StringBuilder → String

record Node(double gain , int a , int b){}
PriorityQueue<Node> pq = new PriorityQueue<>((a, b) -> Double.compare(b.gain, a.gain));
pq.offer(new Node(1.0, 1, 2));
pq.offer(new Node(2.0, 2, 3));
pq.offer(new Node(3.0, 3, 4));  
System.out.println(pq.poll().gain);
System.out.println(pq.poll().gain);
System.out.println(pq.poll().gain); 

// 创建小顶堆（默认）
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
// 添加元素
minHeap.offer(5);
minHeap.add(3); // offer和add功能相同
// 查看堆顶元素（不删除）
int min = minHeap.peek();
// 取出堆顶元素（删除）
int removedMin = minHeap.poll();
// 获取堆大小
int size = minHeap.size();
// 检查是否为空
boolean isEmpty = minHeap.isEmpty();
// 删除指定元素（非堆顶）
minHeap.remove(2);
// 清空堆
minHeap.clear();

// 创建大顶堆（使用自定义比较器）
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
// 或 PriorityQueue<>(Comparator.reverseOrder());
// 添加元素
maxHeap.offer(8);
maxHeap.add(4);
// 查看堆顶元素（不删除）
int max = maxHeap.peek();
// 取出堆顶元素（删除）
int removedMax = maxHeap.poll();
// 检查元素是否存在
boolean contains = maxHeap.contains(5);
// 遍历并输出元素
for (Integer num : minHeap) {
    System.out.println(num);
}
// 构造按照字典序排列的优先队列
PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> {
    // 将 int 转换为 String 后比较字典序
    String strA = String.valueOf(a);
    String strB = String.valueOf(b);
    return strA.compareTo(strB);
});

//小根堆，如果当前元素大于堆顶，则加入堆中，堆中的元素还要保存其下标
public int[] maxSubsequence(int[] nums, int k) {
    PriorityQueue<int[]> heap = new PriorityQueue<>((o1,o2)->o1[0]-o2[0]);
    int n = nums.length;
    for(int i = 0; i < n; i++) {
        if(heap.size() < k) heap.offer(new int[]{nums[i], i});
        else if(nums[i] > heap.peek()[0]) {
            heap.poll();
            heap.offer(new int[]{nums[i], i});
        }
    }
    int[] idx = new int[k];
    for(int i = 0; i < k; i++) {
        idx[i] = heap.poll()[1];
    }
    Arrays.sort(idx);
    for(int i = 0; i < k; i++) {
        idx[i] = nums[idx[i]];
    }
    return idx;
}

// 自定义类
class Student {
    String name;
    int score;
    // 构造方法等...
}
// 按分数的小顶堆
PriorityQueue<Student> studentMinHeap = new PriorityQueue<>(
    (s1, s2) -> s1.score - s2.score
);
// 按分数的大顶堆  
PriorityQueue<Student> studentMaxHeap = new PriorityQueue<>(
    (s1, s2) -> s2.score - s1.score
);
// 添加自定义对象
studentMinHeap.offer(new Student("Alice", 85));

class Solution {
    public int maxEvents(int[][] events) {
        int mx = 0;
        for (int[] e : events) {
            mx = Math.max(mx, e[1]);
        }
        // 按照开始时间分组
        List<Integer>[] groups = new ArrayList[mx + 1];
        Arrays.setAll(groups, i -> new ArrayList<>());
        for (int[] e : events) {
            groups[e[0]].add(e[1]);
        }
        int ans = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int i = 0; i <= mx; i++) {
            // 删除过期会议
            while (!pq.isEmpty() && pq.peek() < i) {
                pq.poll();
            }
            // 新增可以参加的会议
            for (int endDay : groups[i]) {
                pq.offer(endDay);
            }
            // 参加一个结束时间最早的会议
            if (!pq.isEmpty()) {
                ans++;
                pq.poll();
            }
        }
        return ans;
    }
}

import java.util.Deque;
import java.util.ArrayDeque;
import java.util.Iterator;

// 初始化 Deque（以 ArrayDeque 为例）
Deque<String> deque = new ArrayDeque<>(); //不能插入null元素
Deque<String> deque = new LinkedList<>();

// 队头插入
deque.addFirst("A");      // 插入元素到队头（容量满时抛出 IllegalStateException）
deque.offerFirst("B");    // 插入元素到队头（容量满时返回 false）
// 队尾插入
deque.addLast("C");       // 插入元素到队尾（容量满时抛出 IllegalStateException）
deque.offerLast("D");     // 插入元素到队尾（容量满时返回 false）
// 批量插入（从 Collection 继承）
deque.addAll(List.of("E", "F"));  // 依次插入队尾

// 队头删除
String first1 = deque.removeFirst();  // 删除并返回队头元素（空队列抛 NoSuchElementException）
String first2 = deque.pollFirst();     // 删除并返回队头元素（空队列返回 null）
// 队尾删除
String last1 = deque.removeLast();    // 删除并返回队尾元素（空队列抛异常）
String last2 = deque.pollLast();      // 删除并返回队尾元素（空队列返回 null）
// 删除指定元素（从队头开始搜索）
boolean removed1 = deque.remove("E");           // 删除第一个出现的 "E"
boolean removed2 = deque.removeFirstOccurrence("F"); // 删除队头方向第一个 "F"
boolean removed3 = deque.removeLastOccurrence("G");   // 删除队尾方向第一个 "G"

// 查看队头
String head1 = deque.getFirst();    // 返回队头元素（空队列抛异常）
String head2 = deque.peekFirst();   // 返回队头元素（空队列返回 null）

// 查看队尾
String tail1 = deque.getLast();     // 返回队尾元素（空队列抛异常）
String tail2 = deque.peekLast();    // 返回队尾元素（空队列返回 null）

boolean isEmpty = deque.isEmpty();  // 判断队列是否为空
int size = deque.size();            // 返回元素数量
boolean exists = deque.contains("A"); // 判断是否包含元素 "A"

// 迭代器（正向：队头 → 队尾）
Iterator<String> iterator = deque.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
}

// 反向迭代器（队尾 → 队头）
Iterator<String> descendingIterator = deque.descendingIterator();
while (descendingIterator.hasNext()) {
    String element = descendingIterator.next();
}

// 清空队列
deque.clear();
// 转换为数组
Object[] array1 = deque.toArray();                   // 返回 Object[]
String[] array2 = deque.toArray(new String[0]);      // 指定类型数组

// ================== 栈操作（Deque 兼容的额外方法）==================
deque.push("X");      // 等效于 addFirst()
String popped = deque.pop();  // 等效于 removeFirst()


// ================== 容量限制队列（如 LinkedBlockingDeque）==================
// 阻塞操作示例（需使用线程安全 Deque，此处仅展示方法）
/*
deque.offerFirst("W", 1, TimeUnit.SECONDS);  // 等待1秒尝试插入队头
deque.offerLast("Z", 1, TimeUnit.SECONDS);   // 等待1秒尝试插入队尾
String item = deque.pollFirst(1, TimeUnit.SECONDS); // 等待1秒尝试取出队头
*/

// 默认按key升序排列
TreeMap<Integer, String> map = new TreeMap<>();
// 按key降序排列
TreeMap<String, Integer> map = new TreeMap<>(Collections.reverseOrder());
// 自定义比较器，按key升序排列
TreeMap<String, Integer> map = new TreeMap<>((a, b) -> a.compareTo(b));

// 添加键值对，如果key已存在则更新value
map.put(1, "A");
map.put(2, "B");
map.put(3, "C");

// 删除指定key的键值对，返回被删除的value
String removed = map.remove(1);
// 删除并返回第一个（最小的）键值对
Map.Entry<Integer, String> first = map.pollFirstEntry();
// 删除并返回最后一个（最大的）键值对
Map.Entry<Integer, String> last = map.pollLastEntry();
// 清空所有键值对
map.clear();

// 遍历键值对
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}
// 遍历key（按升序）
for (Integer key : map.keySet()) {
    System.out.println(key);
}
// 遍历value（按对应key的升序）
for (String value : map.values()) {
    System.out.println(value);
}

// 获取第一个（最小的）键值对，不删除
Map.Entry<Integer, String> first = map.firstEntry();
// 获取最后一个（最大的）键值对，不删除
Map.Entry<Integer, String> last = map.lastEntry();
// 获取第一个（最小的）key
Integer firstKey = map.firstKey();
// 获取最后一个（最大的）key
Integer lastKey = map.lastKey();
// 获取小于指定key的最大键值对
Map.Entry<Integer, String> lower = map.lowerEntry(5);
// 获取大于指定key的最小键值对
Map.Entry<Integer, String> higher = map.higherEntry(5);
// 获取小于等于指定key的最大键值对
Map.Entry<Integer, String> floor = map.floorEntry(5);
// 获取大于等于指定key的最小键值对
Map.Entry<Integer, String> ceiling = map.ceilingEntry(5);

// 获取键值对数量
int size = map.size();
// 判断是否为空
boolean isEmpty = map.isEmpty();
// 获取降序排列的视图
NavigableMap<Integer, String> descMap = map.descendingMap();

// 1. 自定义一个类，继承 java.lang.Thread 类
class MyThread extends Thread {
    private String name;
    
    public MyThread(String name) {
        this.name = name;
    }
    
    // 2. 重写 run() 方法：此方法是线程的入口点，包含了要并发执行的代码逻辑
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + " 运行： " + i);
            try {
                // 睡眠一段时间，模拟任务执行时间，使线程交替效果更明显
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 测试
public class ThreadDemo {
    public static void main(String[] args) {
        // 3. 创建线程对象
        MyThread t1 = new MyThread("线程A");
        MyThread t2 = new MyThread("线程B");
        
        // 4. 启动线程：调用 start() 方法，注意不是直接调用 run()！
        t1.start(); // JVM 会创建一个新线程来执行 run() 方法
        t2.start(); 
        
        // 如果调用 t1.run()，则只是普通方法调用，仍在 main 线程中顺序执行。
    }
}

// 1. 自定义一个类，实现 java.lang.Runnable 接口
class MyRunnable implements Runnable {
    private String name;
    
    public MyRunnable(String name) {
        this.name = name;
    }
    
    // 2. 实现 run() 方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + " 运行： " + i);
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 测试
public class RunnableDemo {
    public static void main(String[] args) {
        // 3. 创建任务对象（线程体）
        Runnable task1 = new MyRunnable("线程-1");
        Runnable task2 = new MyRunnable("线程-2");
        
        // 4. 创建线程对象，并将任务对象作为参数传入
        Thread t1 = new Thread(task1);
        Thread t2 = new Thread(task2);
        
        // 5. 启动线程
        t1.start();
        t2.start();
        
        // 简洁写法：使用匿名内部类 + Lambda 表达式
        new Thread(() -> {
            System.out.println("Lambda线程运行中");
        }).start();
    }
}

// 锁对象可以是任意 Object，但所有竞争线程必须使用同一个锁对象
private final Object lock = new Object(); 
private int count = 0;

public void add() {
    synchronized (lock) { // 获取 lock 对象的锁
        count++; // 临界区
    } // 释放锁
}

public synchronized void add() {
    count++;
}
// 等价于
public void add() {
    synchronized (this) {
        count++;
    }
}

public static synchronized void staticAdd() {
    // ...
}
// 等价于
public static void staticAdd() {
    synchronized (MyClass.class) {
        // ...
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
    private final Lock lock = new ReentrantLock(); // 创建可重入锁
    private int count = 0;
    
    public void add() {
        lock.lock(); // 获取锁，如果锁被占用，则等待
        try {
            count++; // 临界区
            // 其他可能抛出异常的代码...
        } finally {
            lock.unlock(); // 必须在 finally 块中释放锁，确保锁一定被释放！
        }
    }
    
    // 尝试获取锁，避免死等
    public void tryAdd() {
        if (lock.tryLock()) { // 尝试获取锁，立即返回 true/false
            try {
                count++;
            } finally {
                lock.unlock();
            }
        } else {
            // 没拿到锁，做其他事情
            System.out.println("获取锁失败，执行备用逻辑");
        }
    }
}

//synchronized+ wait()/notify()

public class AlternatePrintBasic {
    private static final Object lock = new Object();
    private static boolean numTurn = true; // 控制该谁执行：true-数字线程，false-字母线程
    
    public static void main(String[] args) {
        Thread numThread = new Thread(() -> {
            synchronized (lock) {
                for (int i = 1; i <= 5; i++) {
                    // 如果不该数字线程执行，就等待
                    while (!numTurn) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    
                    System.out.print(i); // 输出数字
                    numTurn = false;     // 切换权限给字母线程
                    lock.notify();       // 唤醒字母线程
                }
            }
        });
        
        Thread letterThread = new Thread(() -> {
            synchronized (lock) {
                for (char c = 'A'; c <= 'E'; c++) {
                    // 如果不该字母线程执行，就等待
                    while (numTurn) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    
                    System.out.print(c); // 输出字母
                    numTurn = true;      // 切换权限给数字线程
                    lock.notify();       // 唤醒数字线程
                }
            }
        });
        
        numThread.start();
        letterThread.start();
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class AlternatePrintWithLock {
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition numCondition = lock.newCondition();  // 数字线程的条件队列
    private static Condition letterCondition = lock.newCondition(); // 字母线程的条件队列
    private static boolean numTurn = true;
    
    public static void main(String[] args) {
        Thread numThread = new Thread(() -> {
            lock.lock();
            try {
                for (int i = 1; i <= 5; i++) {
                    while (!numTurn) {
                        numCondition.await(); // 数字线程等待
                    }
                    
                    System.out.print(i);
                    numTurn = false;
                    letterCondition.signal(); // 精确唤醒字母线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });
        
        Thread letterThread = new Thread(() -> {
            lock.lock();
            try {
                for (char c = 'A'; c <= 'E'; c++) {
                    while (numTurn) {
                        letterCondition.await(); // 字母线程等待
                    }
                    
                    System.out.print(c);
                    numTurn = true;
                    numCondition.signal(); // 精确唤醒数字线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });
        
        numThread.start();
        letterThread.start();
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 简单线程池实现
 */
public class SimpleThreadPool {

    // 工作线程队列
    private final List<WorkerThread> workers;
    // 任务队列
    private final BlockingQueue<Runnable> taskQueue;
    // 线程池状态
    private final AtomicBoolean isShutdown;
    // 线程池大小
    private final int poolSize;

    public SimpleThreadPool(int poolSize) {
        this.poolSize = poolSize;
        this.taskQueue = new LinkedBlockingQueue<>();
        this.workers = new ArrayList<>(poolSize);
        this.isShutdown = new AtomicBoolean(false);

        // 初始化工作线程
        initializeWorkers();
    }
    public boolean isShutdown() {
        return isShutdown.get();
    }
    /**
     * 初始化工作线程
     */
    private void initializeWorkers() {
        for (int i = 0; i < poolSize; i++) {
            WorkerThread worker = new WorkerThread("Pool-Thread-" + i);
            worker.start();
            workers.add(worker);
        }
    }

    /**
     * 提交任务到线程池
     */
    public void execute(Runnable task) {
        if (isShutdown.get()) {
            throw new IllegalStateException("线程池已关闭，无法提交新任务");
        }
        if (task == null) {
            throw new NullPointerException("任务不能为null");
        }

        try {
            taskQueue.put(task);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    /**
     * 关闭线程池（等待所有任务完成）
     */
    public void shutdown() {
        isShutdown.set(true);
        System.out.println("线程池开始关闭...");
    }

    /**
     * 立即关闭线程池（不等待任务完成）
     */
    public void shutdownNow() {
        isShutdown.set(true);
        // 中断所有工作线程
        for (WorkerThread worker : workers) {
            worker.interrupt();
        }
        // 清空任务队列
        taskQueue.clear();
    }

    /**
     * 等待所有任务完成
     */
    public void awaitTermination() throws InterruptedException {
        for (WorkerThread worker : workers) {
            worker.join();
        }
    }

    /**
     * 获取等待执行的任务数量
     */
    public int getPendingTaskCount() {
        return taskQueue.size();
    }

    /**
     * 工作线程内部类
     */
    private class WorkerThread extends Thread {
        public WorkerThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 开始工作");

            while (!isShutdown.get() || !taskQueue.isEmpty()) {
                try {
                    // 从任务队列获取任务（阻塞式）
                    Runnable task = taskQueue.take();
                    System.out.println(Thread.currentThread().getName() + " 执行任务");

                    // 执行任务
                    task.run();

                } catch (InterruptedException e) {
                    // 响应中断，退出循环
                    if (isShutdown.get()) {
                        System.out.println(Thread.currentThread().getName() + " 被中断，准备退出");
                        break;
                    }
                } catch (Exception e) {
                    // 捕获任务执行中的异常，避免工作线程退出
                    System.err.println("任务执行异常: " + e.getMessage());
                    e.printStackTrace();
                }
            }

            System.out.println(Thread.currentThread().getName() + " 结束工作");
        }
    }
}