概要

算法第一步：先学API

实在是太多了，我刷了一百道左右，整理出来了里边用到的java中的API如下，有点乱，但是用的时候可以control+f进行搜索，当然这也是我的一个简化版本的API

String类型操作：

1. 字符串转换为char[]数组：

char[] chars = str.toCharArray();

2. 字符串忽略大小写

-转换为小写
String  mm = "ASSXsdfsdfds";
String s = mm.toLowerCase(); // assxsdfsdfds
- 转换为大写
String s1 = mm.toUpperCase();// ASSXSDFSDFDS

3. char类型比较

用：==

        char a = 'a';
        char b = 'a';
        if (a==b){
    
            System.out.println("true");
        }else {
    
            System.out.println("false");
        }
结果：true

char类型排序

        // sort并不区分大小写，而是单单按照ABCD进行排序
        // 存储所有英文字母
        List<Character> letters = new ArrayList<>();
        letters.add('A');
        letters.add('a');
        letters.add('f');
        letters.add('F');
        letters.add('B');
        System.out.println(letters);
        // 结果：[A, a, f, F, B]
        // 不区分大小写排序
        letters.sort(Comparator.comparingInt(a -> Character.toLowerCase(a)));
        System.out.println(letters);
        // 结果：[A, a, B, f, F]
        // 区分大小写排序
        letters.sort(Character::compare);
        System.out.println(letters);
        // 结果：[A, B, F, a, f]

char和ASCII码

java中关于ASCII码：
其实就是将
char aChar = chars[i];
int b = aChar;

因为char中仅仅存储一个字符，97或者两位数的数字他就会做一个特殊处理,会把数字映射成一个特殊的符号
同样也会把符号映射为一个数字。


char char4 =66;
输出char4为B
同样 int cha = char4
输出cha为66


int 和char是可以相互对等的，这里仅仅是涉及到一个符号转换

4. 字符串分割

方式1：
String str = "one,two,three";
String[] parts = str.split(","); // 使用逗号作为分隔符
System.out.println(Arrays.toString(parts));  // 输出 [one, two, three]
方式2：
String str = "one   two three";
String[] parts = str.split("\\s+"); // \s是正则表达式中表示空白字符的元字符，+表示一个或多个
System.out.println(Arrays.toString(parts));  // 输出 [one, two, three]

5. String 类型去重字符：两种方式-结果不同

public static void main(String[] args) {
    
        String input = "banana";

        Set<Character> chars = new LinkedHashSet<>();
        for (char c : input.toCharArray()) {
    
            chars.add(c);
        }
        // 使用StringBuilder重新构建没有重复字符的字符串
        StringBuilder sb = new StringBuilder(chars.size());
        for (char c : chars) {
    
            sb.append(c);
        }

        String result = sb.toString();;
        // 打印去重后的结果  保留顺序 "ban"
        System.out.println(result);

        //----------------方式2-----------------------------

        // 将字符串转换为字符数组
        Character[] chars2 = input.chars().mapToObj(c -> (char) c).toArray(Character[]::new);

        // 使用 TreeSet 去重并保持顺序
        Set<Character> charSet = new TreeSet<>(Arrays.asList(chars2));

        // 再次使用 StringBuilder 将字符集合构建回字符串
        StringBuilder sb2 = new StringBuilder();
        for (char ch : charSet) {
    
            sb2.append(ch);
        }
        // 打印结果   // 结果将是不保留顺序 "abn"
        System.out.println(sb2.toString());

    }

6、排序

1. 单个字符串内字符排序

String originalString = "banana";
char[] chars = originalString.toCharArray();
Arrays.sort(chars);
String sortedString = new String(chars);
System.out.println(sortedString); // 输出 "aaabnn"

2. 字符串数组排序

对字符串数组进行排序，我们直接调用Arrays.sort()方法进行排序：

String[] strings = {
    "Banana", "Apple", "Cherry", "Date"};
Arrays.sort(strings);
System.out.println(Arrays.toString(strings)); // 输出 [Apple, Banana, Cherry, Date]

字符串数组排序是区分大小写的。若想忽略大小写，可以提供一个自定义的Comparator：
Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER);
System.out.println(Arrays.toString(strings)); // 输出 [Apple, Banana, Cherry, Date]

3. 字符串List排序

对于List，使用Collections.sort()方法：

List<String> listOfStrings = Arrays.asList("Banana", "Apple", "Cherry", "Date");
Collections.sort(listOfStrings);
System.out.println(listOfStrings); // 输出 [Apple, Banana, Cherry, Date]

忽略大小写进行字符串List排序：

Collections.sort(listOfStrings, String.CASE_INSENSITIVE_ORDER);
System.out.println(listOfStrings); // 输出 [Apple, Banana, Cherry, Date]

4. Java 8 Stream API

使用Java 8及以上版本时，可以使用Stream API来执行排序操作：

List<String> listOfStrings = Arrays.asList("Banana", "Apple", "Cherry", "Date");
listOfStrings.stream().sorted().forEach(System.out::println); // 输出排序后的字符串
忽略大小写的Stream排序：
listOfStrings.stream().sorted(String.CASE_INSENSITIVE_ORDER).forEach(System.out::println);
收集排序后的结果：
List<String> sortedList = listOfStrings.stream()
    .sorted()
    .collect(Collectors.toList());

以上是对字符串进行排序的常用方法。排序可以根据具体的业务规则和需求灵活选择大小写敏感或不敏感，自然排序或定制排序规则。

7、字符串翻转：

方式1：
String original = "hello";
String reversed = new StringBuilder(original).reverse().toString();
System.out.println(reversed);
// 结果：olleh

方式2：
List<Character> list = original.chars().mapToObj(c -> (char) c).collect(Collectors.toList());
Collections.reverse(list);
String reversed2 = list.stream().map(String::valueOf).collect(Collectors.joining());
System.out.println(reversed2);

当然还有很多种方式：但是
StringBuilder的reverse()方法效率是最高的

scanner的使用：

Scanner in = new Scanner(System.in);
String str = in.nextLine();
char c = in.nextLine().charAt(0);

// 获取下一个key  指定int类型忽略空格
final int key = in.nextInt();

Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
float num = in.nextFloat();


确认步骤数：    
int N = in.nextInt();
执行步骤数：
for (int i = 0; i < N; i++) {
    
    int num = in.nextInt();
    set.add(num);
}

容器排序

1、数组 (Array)

• 数组创建方式

1. 使用初始化器语法创建数组
int[] numbers = {
    1, 2, 3, 4, 5}; // 初始化一个具有特定值的整型数组

2. 使用关键字new创建数组
int[] numbers = new int[5]; // 创建一个长度为5的整型数组，元素默认初始化为0

3. 使用关键字new和初始化器语法结合
int[] numbers = new int[]{
    1, 2, 3, 4, 5}; // 使用new关键字，同时指定数组值

4. 使用Java 8的Arrays类填充默认值
String[] strings = new String[5];
Arrays.fill(strings, "Default"); // 创建一个字符串数组，然后用"Default"填充每个元素

5. 多维数组的创建
int[][] matrix = new int[3][3]; // 创建一个3x3的二维整型数组（矩阵），元素默认初始化为0

int[][] jaggedArray = new int[3][]; // 创建一个又叫"锯齿数组"的二维数组，其子数组长度可以不同
jaggedArray[0] = new int[2];
jaggedArray[1] = new int[3];
jaggedArray[2] = new int[1];


6. 使用java.util.ArrayList （或其他List）转换为数组

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Integer[] numbers = list.toArray(new Integer[0]); // 从ArrayList创建一个Integer数组

7. 使用Stream API
int[] numbers = IntStream.range(0, 5).toArray(); // 创建一个元素从0到4的整型数组

String[] strings = Stream.of("apple", "banana", "cherry").toArray(String[]::new); // 创建一个包含特定值的字符串数组

• 实现方式: 可以使用 Arrays.sort() 方法进行排序，它适用于基本数据类型以及对象数组。对于基本数据类型数组，使用快速排序的变体（Dual-Pivot Quicksort）。对于对象数组，使用改进的归并排序（Timsort）。
• 代码示例:

int[] numbers = {
    3, 5, 1, 4, 2};
Arrays.sort(numbers);

String[] names = {
    "Bob", "Alice", "Charlie"};
Arrays.sort(names);

2. 列表 (List)

• 实现方式: 对于列表（尤其是ArrayList和LinkedList），可以使用 Collections.sort() 方法。它采用稳定的归并排序算法，并在排序对象时要求对象实现Comparable接口，或者需要指定一个Comparator。
• 代码示例：

List<Integer> list = Arrays.asList(3, 5, 1, 4, 2);
Collections.sort(list);

List<String> namesList = Arrays.asList("Bob", "Alice", "Charlie");
Collections.sort(namesList);

3. 优先队列 (PriorityQueue)

• 实现方式: PriorityQueue 在内部使用堆数据结构，它可以保证元素在被处理时的顺序性，但它本身的迭代是无序的。它允许插入元素时指定Comparator来定义优先级。
• 代码示例

PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.add(3);
priorityQueue.add(5);
priorityQueue.add(1);
while (!priorityQueue.isEmpty()) {
    
    System.out.print(priorityQueue.poll() + " "); // 输出为有序：1 3 5
}

4. 有序集 (SortedSet) 和 有序映射 (SortedMap)

• 实现方式: SortedSet（比如TreeSet）和SortedMap（比如TreeMap）都保持了它们的元素/键的有序状态。它们内部使用红黑树。
• 代码示例:

SortedSet<String> sortedSet = new TreeSet<>();
sortedSet.add("Bob");
sortedSet.add("Alice");
sortedSet.add("Charlie");
for (String name : sortedSet) {
    
    System.out.print(name + " "); // 输出为有序：Alice Bob Charlie
}

SortedMap<Integer, String> sortedMap = new TreeMap<>();
sortedMap.put(3, "Three");
sortedMap.put(1, "One");
sortedMap.put(2, "Two");
for (Map.Entry<Integer, String> entry : sortedMap.entrySet()) {
    
    System.out.print(entry.getValue() + " "); // 输出为有序：One Two Three
}

5. 流 (Stream)

实现方式: Java 8 引入了流(Stream) API，可以对集合、数组的流进行操作。流可以使用 sorted() 方法来排序，它能接受一个Comparator来自定义排序，如果没有指定Comparator，则会使用元素的自然排序。
代码示例:

List<Integer> numbersList = Arrays.asList(3, 5, 1, 4, 2);
numbersList.stream().sorted().forEach(System.out::print); // 输出为有序：12345

这些排序方法适用于不同的数据结构和场景。在实现自定义对象的排序时，通常需要对象实现Comparable接口或提供Comparator来定义对象间的排序规则。当需要为自定义对象排序时，你有两种主要的方式：

6.实现 Comparable 接口

当你的类有一个自然的排序顺序时，可以实现 Comparable 接口并覆盖 compareTo 方法。例如，一个简单的 Person 类可能按姓名排序：

public class Person implements Comparable<Person> {
    
    private String name;
    
    public Person(String name) {
    
        this.name = name;
    }

    public String getName() {
    
        return name;
    }

    @Override
    public int compareTo(Person other) {
    
        return this.name.compareTo(other.name);
    }
}


排序 Person 对象的列表：

List<Person> people = Arrays.asList(new Person("Bob"), new Person("Alice"), new Person("Charlie"));
Collections.sort(people);

for (Person person : people) {
    
    System.out.println(person.getName());
}
// 输出将会是：
// Alice
// Bob
// Charlie

7、提供 Comparator 接口实现

如果排序不是类的固有属性，或者你要对同一类的对象有不同的排序方式，那么可以提供 Comparator 接口的实现。以下是一个没有实现 Comparable 接口的 Person 类，但我们通过定义 Comparator 来排序：

public class Person {
    
    private String name;
    
    // 构造器、getter、setter省略

    // 根据姓名排序的 Comparator
    public static final Comparator<Person> BY_NAME = new Comparator<Person>() {
    
        @Override
        public int compare(Person p1, Person p2) {
    
            return p1.getName().compareTo(p2.getName());
        }
    };

    // 根据姓名长度排序的 Comparator
    public static final Comparator<Person> BY_NAME_LENGTH = new Comparator<Person>() {
    
        @Override
        public int compare(Person p1, Person p2) {
    
            return Integer.compare(p1.getName().length(), p2.getName().length());
        }
    };
}

如何使用：


List<Person> people = Arrays.asList(new Person("Bob"), new Person("Alice"), new Person("Charlie"));
Collections.sort(people, Person.BY_NAME);

for (Person person : people) {
    
    System.out.println(person.getName()); // 输出按姓名排序的结果
}

Collections.sort(people, Person.BY_NAME_LENGTH);

for (Person person : people) {
    
    System.out.println(person.getName()); // 输出按姓名长度排序的结果
}

8、Java 8 及以上版本

List<Person> people = Arrays.asList(new Person("Bob"), new Person("Alice"), new Person("Charlie"));

// 使用Lambda表达式按姓名排序
people.sort((p1, p2) -> p1.getName().compareTo(p2.getName()));

// 使用Lambda和Comparator.comparing按姓名顺序排序
people.sort(Comparator.comparing(Person::getName));

// 使用Lambda和Comparator.comparing按姓名长度排序
people.sort(Comparator.comparingInt(p -> p.getName().length()));

使用流API：
people.stream()
      .sorted(Comparator.comparing(Person::getName))
      .forEach(p -> System.out.println(p.getName())); //　输出按姓名排序的结果

利用这些功能，你可以非常灵活地为Java中的数据结构实现排序逻辑，并根据具体应用场景选择最合适的方法。

9、使用 Java 8 Stream API

• 在 Java 8 及以上版本中，你可以使用 Stream 的 sorted() 方法，配合 Comparator 来进行排序。
• 示例：

List<String> names = Arrays.asList("Bob", "Alice", "Charlie");
names.stream()
     .sorted()
     .forEach(System.out::println);

// 自定义排序
names.stream()
     .sorted((a, b) -> b.compareTo(a)) // 逆序
     .forEach(System.out::println);

// 使用 Comparator.comparing 来指定排序规则
names.stream()
     .sorted(Comparator.comparing(String::length).thenComparing(Comparator.naturalOrder()))
     .forEach(System.out::println);

10、使用 Java 8 Comparator 接口的默认方法

• Java 8 还为 Comparator 接口引入了一系列的默认方法，如 thenComparing、reversed，使得定义复杂的排序规则变得更简单。
• 示例：

List<Person> people = Arrays.asList(new Person("Bob"), new Person("Alice"), new Person("Charlie"));
// 优先按姓名长度排序，然后按字母顺序排序
people.sort(Comparator.comparingInt((Person p) -> p.getName().length())
                      .thenComparing(Person::getName));

11、Java 8 方法引用

• 方法引用也是Java 8引入的一种简化Lambda表达式写法的方法，非常适合用于排序操作中。
• 示例：

people.sort(Comparator.comparing(Person::getName)); // 使用方法引用按名字排序

12、Collections 工具类

• 除了 Collections.sort 方法，Collections 工具类还提供了 reverseOrder() 和 sort(List list, Comparator<? super T> c) 方法用于排序。

并行排序

• Java 8 也引入了并行排序，可以使用parallelStream进行并行处理，然后再排序。
• 示例：

List<String> names = Arrays.asList("Bob", "Alice", "Charlie");
names.parallelStream()
     .sorted()
     .collect(Collectors.toList()) // 收集排序后的结果到列表
     .forEach(System.out::println);
结果：
Alice
Bob
Charlie

解释：
names.parallelStream()
parallelStream(): 这是Collection接口的一个方法，
用于创建一个可以并行处理元素的流(Stream)。
在并行流中，数据会被分割成多个段，每个段由不同的线程处理，
从而可以充分利用多核处理器的优势。

sorted(): 是Stream接口的一个方法，它会返回一个新的流，
其中包含按自然顺序排序的流中的所有元素。

collect: 是Stream接口的一个终结方法，它将流的内容转换成另一种形式，
这里用来将流转换为一个新的列表。
Collectors: 是一个工具类，里面提供了很多静态方法，用于生成常见的集合操作的收集器
toList(): 是Collectors类的一个静态方法，用于生成一个收集器，
将流中的元素累积到新的List中。
forEach: 又是Stream接口的一个终结方法，它接受一个Consumer接口的实现，
用来对流中的每个元素执行指定的操作。
System.out: 表示标准输出流（通常是控制台）。
println: 是PrintStream类的一个方法，用于输出信息到控制台。
System.out::println: 是一个方法引用，它是Consumer接口的实现，
表示对每个元素执行println方法。

总结：
这段代码展示的操作是将一个字符串列表并行地排序，并将排序后的结果收集到一个新的列表中
最后遍历这个列表，将每个字符串打印到控制台。由于采用了并行流，
各个元素的排序操作可以在不同的线程中同时进行，这可能在处理大数据集时提高性能。
不过，并行流并不总是提升性能，特别是在列表非常小或者操作本身非常快速时，
实际上可能会由于线程管理的开销而降低性能。

13、不可变集合

• 由于Java中的不可变集合是无法修改的，当你需要对这些集合进行排序时，通常需要创建其可变副本，先在副本上排序，然后可以根据需要再转换回不可变集合。

总的来说，Java拥有丰富的API和数据结构来支持排序操作。选择哪一个取决于具体的使用场景、性能要求和个人偏好。Java 8 引入的 Stream API 和 Lambda表达式进一步简化了排序操作，为开发者提供了更加优雅和现代的编码方式。

14、set:添加时排序-(去重+排序)

  // 去重：set：
        //  升序
TreeSet<Integer> set1 = new TreeSet<>();
        // 降序
TreeSet<Integer> set2 = new TreeSet<>.  (Comparator.reverseOrder());
        //添加：
        set1.add(2);
        set1.add(1);
        set1.add(6);
        set1.add(4);
        set1.add(4);
        set1.add(4);
        set2.add(2);
        set2.add(1);
        set2.add(6);
        set2.add(6);
        set2.add(6);
        set2.add(4);
        //遍历：
        set1.stream().forEach(num -> {
    System.out.println(num);});
        set2.stream().forEach(num -> {
    System.out.println(num);});

int类型操作：

1、取整取余

%表示取余数
\表示取整数
int padding = len % 8 == 0 ? 0 : 8 - len % 8;
len对8取余数，若是为0那么返回0，反之返回8-余数```

数组相关操作：

去重：

去重：set：
 TreeSet<Integer> set = new TreeSet<>();   升序
 TreeSet<Integer> set = new TreeSet<>(Comparator.reverseOrder());  降序
添加：
set.add(num);
遍历：
set.stream().forEach(num -> {
    System.out.println(num);});

去重：
String[] strings = {
    "1","2","6","5","4","2","5"};
// 使用ArrayList进行转换
List<String> list = new ArrayList<>(Arrays.asList(strings)); 
List<String> distinctList = list.stream().distinct().collect(Collectors.toList());
System.out.println(distinctList);
// 结果：[1, 2, 6, 5, 4]

转换为集合：

String[] strings = {
    "1","2","6","5","4","2","5"};
 // 使用ArrayList进行转换 :将数组转换为集合
List<String> list = new ArrayList<>(Arrays.asList(strings)); 
System.out.println(list);
// 结果：[1, 2, 6, 5, 4, 2, 5]

转换为set（去重）

String[] strings = {
    "1","2","6","5","4","2","5"};
Set<String> set = new LinkedHashSet<>(Arrays.asList(strings));
System.out.println(set);
// 结果：[1, 2, 6, 5, 4]

排序

 String[] strings = {
    "1","2","6","5","4","2","5"};
 // 使用ArrayList进行转换
List<String> list = new ArrayList<>(Arrays.asList(strings)); 
// 排序
Collections.sort(list);
// 结果：[1, 2, 2, 4, 5, 5, 6]

反转

基本类型和String类型反转

String[] strings = {
    "1","2","6","5","4","2","5"};
List<String> list = new ArrayList<>(Arrays.asList(strings)); // 使用ArrayList进行转换
Collections.reverse(list);
System.out.println(list);
// 结果：[5, 2, 4, 5, 6, 2, 1]

泛型为对象反转-按照某一个字段排序

        List<User> list = new ArrayList<>();
        list.add(new User(1, "1"));
        list.add(new User(5, "5"));
        list.add(new User(2, "2"));
        list.add(new User(6, "6"));
        // 输出函数[User(age=1, name=1), User(age=5, name=5), User(age=2, name=2), User(age=6, name=6)]
        System.out.println(list);
        // 正序：[User(age=1, name=1), User(age=2, name=2), User(age=5, name=5), User(age=6, name=6)]
        list.sort(Comparator.comparing(User::getAge));
        System.out.println(list);
        // 倒序：[User(age=6, name=6), User(age=5, name=5), User(age=2, name=2), User(age=1, name=1)]
        list.sort(Comparator.comparing(User::getAge).reversed());
        System.out.println(list);

泛型为对象反转-按照某两个字段（及以上）排序

 List<User> users = Arrays.asList(
                new User(25, "Alice"),
                new User(30, "Bob"),
                new User(25, "David"),
                new User(25, "Charlie")
        );
        // 情况1: age相同按照名字正序排序
        Comparator<User> ageThenNameAscending = Comparator
                .comparing(User::getAge)
                .thenComparing(User::getName);

        users.sort(ageThenNameAscending);
        System.out.println("Age then Name (Ascending):");
        users.forEach(System.out::println);
        // 结果：Age then Name (Ascending):
        //User(age=25, name=Alice)
        //User(age=25, name=Charlie)
        //User(age=25, name=David)
        //User(age=30, name=Bob)

        // 情况2: age相同按照名字倒序排序
        Comparator<User> ageThenNameDescending = Comparator
                .comparing(User::getAge)
                .thenComparing(User::getName, Comparator.reverseOrder());

        users.sort(ageThenNameDescending);
        System.out.println("\nAge then Name (Descending):");
        users.forEach(System.out::println);
        // 结果：Age then Name (Descending):
        //User(age=25, name=David)
        //User(age=25, name=Charlie)
        //User(age=25, name=Alice)

集合相关操作

1、创建集合

List list = Arrays.asList("数值1", "数值2");

移除全部数据
alist.removeAll(list);

2、集合排序

// 排序
Arrays.sort(a1);
// 创建数据
List<String[]> mergedArrays = new ArrayList<>();

3、对象集合排序

// 创建一个Integer类型的ArrayList
List<Integer> list = new ArrayList<>();
// 向列表中添加整数元素
list.add(1);
list.add(3);
list.add(6);
list.add(12);
list.add(1);

// 使用Comparator对列表进行排序。由于这里排序的是Integer类型，因此可以简写为list.sort(null)，因为Integer已经具有自然排序

list.sort(Comparator.comparing(Integer::valueOf));

// 遍历列表，使用方法引用打印出排序后的所有整数
list.forEach(System.out::println);

// 创建一个 User 类型的 ArrayList
List<User> list2 = new ArrayList<>();
// 创建User对象实例
User user = new User(1, "111");
User user2 = new User(2, "11111");
User user3 = new User(3, "1111111");
User user4 = new User(4, "111111111");
User user5 = new User(5, "11111111111");
User user6 = new User(6, "1111111111111");

// 向列表中添加User对象
list2.add(user);
list2.add(user4);
list2.add(user3);
list2.add(user2);
list2.add(user6);
list2.add(user5);

// 遍历列表，打印出添加顺序的User对象的字符串表示
list2.forEach(a -> System.out.println(a.toString()));

// 使用Comparator对User列表按年龄属性进行排序
list2.sort(Comparator.comparing(User::getAge));

// 再次遍历排序后的列表，打印出排序后的User对象的字符串表示
list2.forEach(a -> System.out.println(a.toString()));

4、集合去重

// 例如，初始化 mergedArrays，这里只是一个例子
mergedArrays.add(new String[]{
    "apple", "banana", "apple"});
mergedArrays.add(new String[]{
    "pear", "banana", "pear", "kiwi"});

// 创建一个LinkedHashSet，保留元素顺序的同时去重
Set<String> distinctSet = new LinkedHashSet<>(Arrays.asList(strings));
// 使用TreeSet进行排序和去重
Set<String> sortedDistinctSet = new TreeSet<>(Arrays.asList(strings));
// 将去重后的结果转化回List，供进一步操作(比如排序)
List<String> distinctList = new ArrayList<>(distinctSet);
// 根据需要对去重后的列表排序
Collections.sort(distinctList);
// 更新mergedArrays中的数组
String[] distinctArray = distinctList.toArray(new String[0]);

5、集合翻转：

同上：泛型为对象反转-按照某两个字段（及以上）排序

Map操作：

排序：-方式1：

Map<String,String> map = new HashMap<>();
        map.put("1","1");
        map.put("5","5");
        map.put("3","3");
        map.put("4","4");
        map.put("2","2");

       // 使用TreeMap按键(key)排序
        Map<String, String> sortedByKey = new TreeMap<>(map);
        sortedByKey.forEach((k, v) -> System.out.println("Key: " + k + ", Value: " + v));

        Map<String,String> map2 = new HashMap<>();
        map2.put("1","11");
        map2.put("5","53");
        map2.put("3","13");
        map2.put("4","12");
        map2.put("2","12");
        // 将Map的entrySet转换为List，并在List中使用自定义比较器按值(value)排序
        List<Map.Entry<String, String>> entries = new ArrayList<>(map2.entrySet());
        entries.sort(Map.Entry.comparingByValue());
        entries.forEach(entiey->{
    
            System.out.println("Key: " + entiey.getKey() + ", Value: " + entiey.getValue());
        });
        // 结果：
        // Key: 1, Value: 1
        //Key: 2, Value: 2
        //Key: 3, Value: 3
        //Key: 4, Value: 4
        //Key: 5, Value: 5


        Set<Map.Entry<String, String>> entries2 = map.entrySet();
        List<Map.Entry<Character, Integer>> list222 = new ArrayList(entries2);
        //按照value排序
        list222.sort(Comparator.comparing(Map.Entry::getValue));
        System.out.println(list222);
        //按照key排序
        list222.sort(Comparator.comparing(Map.Entry::getKey));
        System.out.println(list222);
        // 结果
        //Key: 1, Value: 11
        //Key: 2, Value: 12
        //Key: 4, Value: 12
        //Key: 3, Value: 13
        //Key: 5, Value: 53

排序：-方式2：

 Map<String,String> map3 = new HashMap<>();
        map3.put("1","1");
        map3.put("5","5");
        map3.put("3","3");
        map3.put("4","4");
        map3.put("2","2");
        Set<Map.Entry<String, String>> entries2 = map3.entrySet();
        List<Map.Entry<Character, Integer>> list111 = new ArrayList(entries2);
        //按照value排序
        list111.sort(Comparator.comparing(Map.Entry::getValue));
        System.out.println(list111);
        // 结果 [1=1, 2=2, 3=3, 4=4, 5=5]


        Map<String,String> map4 = new HashMap<>();
        map4.put("1","11");
        map4.put("5","53");
        map4.put("3","13");
        map4.put("4","12");
        map4.put("2","12");
        //按照key排序
        Set<Map.Entry<String, String>> entries22 = map4.entrySet();
        List<Map.Entry<Character, Integer>> list222 = new ArrayList(entries22);
        list222.sort(Comparator.comparing(Map.Entry::getKey));
        System.out.println(list222);
        //结果：[1=11, 2=12, 3=13, 4=12, 5=53]

关于哪种方法更好，这取决于具体需求：

• 如果你需要一个始终保持排序状态的Map，并且对value的排序没有要求，那么使用TreeMap是比较好的选择。
• 如果你需要更复杂的排序逻辑，或者需要按照value排序，那么将Map.Entry转换到List并使用sort方法是更灵活的选择。

从通用性和灵活性方面来看，将Map.Entry转换到List并排序通常是更好的选择，因为它允许你自定义排序逻辑，并且适用于按照value排序的场景。
然而，这种方法可能会略有性能损失，并且需要创建额外列表来保存排序结果。如果需要对Map进行大量排序操作，还要考虑性能和空间消耗因素。

跳过前边几个元素

Map<String, String> linkHashMap = new LinkedHashMap<>();

linkHashMap.put("1","1");
linkHashMap.put("5","5");
linkHashMap.put("3","3");
linkHashMap.put("4","4");
linkHashMap.put("2","2");

// 跳过前边几个元素
int skip = 3;
linkHashMap.entrySet().stream()
    .skip(skip)
    .forEach(entry -> {
    
        // 在这里执行对键值对的操作
        System.out.println(entry.getKey() + " " + entry.getValue());
    });
// 结果：4 4
//2 2

Map遍历

遍历方式1：使用entrySet()遍历:

for (Map.Entry<String, String> entry : linkHashMap.entrySet()) {
    
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}

遍历方式2：使用keySet()遍历（如果只需要键）:

for (String key : linkHashMap.keySet()) {
    
    System.out.println("Key = " + key);
}

遍历方式3：使用values()遍历（如果只需要值）:

for (String value : linkHashMap.values()) {
    
    System.out.println("Value = " + value);
}

遍历方式4：通过迭代器Iterator遍历entrySet():

Iterator<Map.Entry<String, String>> iterator = linkHashMap.entrySet().iterator();
while (iterator.hasNext()) {
    
    Map.Entry<String, String> entry = iterator.next();
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}

遍历方式5：使用forEach（Java 8+）:

linkHashMap.forEach((key, value) -> System.out.println("Key = " + key + ", Value = " + value));

遍历方式6：使用Stream API（Java 8+）:

linkHashMap.entrySet().stream()
           .forEach(entry -> System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()));

在选择遍历方式时，以下因素可能影响你的决定：

• 简洁性：forEach 和Stream API提供的函数式编程风格可让代码更简洁。
• 性能：对于简单的遍历操作，传统的for循环通常比Stream API性能更好，尤其是在小型集合上。
• 控制需求：如果你需要在迭代时删除元素，或者你需要更复杂的控制逻辑（例如，break或continue），Iterator可能更适合。
• 并发处理：如果需要并行处理，Stream API能够提供更简便的并行流处理方式。

我推荐使用forEach或者传统的entrySet()迭代，原因如下：

• 代码简洁性：forEach方法使代码更简洁而且清晰易读。
• 功能性：entrySet()提供了键和值的同时访问，而且对于删除操作时，使用迭代器更安全。
• 性能：forEach和传统的for-each loop在性能上通常相当，足以处理大多数情况。

对于大多数非并行处理的场景，forEach或者for循环均可满足要求，而且代码清晰直观。如果程序的性能是关键问题，并且确定传统的for循环有明显的性能优势，那么可能会选择

进制操作

注意点：
1≤n≤2×10的9次方

java中表示10的8次方：int number = 1e8;

// 将十六进制字符串解析为十进制整数
String hex = "FF";
int decimal = Integer.parseInt(hex, 16);
System.out.println("Hex to Decimal: " + decimal);

// 将整数转换为二进制字符串
int number = 10;
String binary = Integer.toBinaryString(number);
System.out.println("Decimal to Binary: " + binary);

// 将整数转换为八进制字符串
int octalNumber = 15;
String octal = Integer.toOctalString(octalNumber);
System.out.println("Decimal to Octal: " + octal);

// 将整数转换为十六进制字符串
int hexNumber = 255;
String hexString = Integer.toHexString(hexNumber);
System.out.println("Decimal to Hex: " + hexString);

浮点数范围：

32位浮点数：范围

if (num < -3.4e38 || num > 3.4e38) {
    
            System.out.println("输入的数字超出范围");
            return;
            }

正则表达式.matches()

关于代码中的：正则表达式相关的操作：

        int count = 0;
        String password = "123wefcsdvefr@#$dfvdfsgfgew123ADFCfwef";
        
        if (password.matches(".*[a-z].*")) {
    
            count++;
        }
        // 判断密码中是否包含至少一个大写字母
        if (password.matches(".*[A-Z].*")) {
    
            count++;
        }
        // 判断密码中是否包含至少一个数字
        if (password.matches(".*\\d.*")) {
    
            count++;
        }
        // 判断密码中是否包含至少一个非字母数字字符 这里使用了 ^ 表示取反，[^a-zA-Z0-9] 表示除了字母和数字之外的任意字符。如果密码中包含至少一个非字母数字字符，其实这个也能理解，若字符串中没有数字、字母那么必然是符号
        if (password.matches(".*[^a-zA-Z0-9].*")) {
    
            count++;
        }

        System.out.println("满足的数量：" + count);

小结

建议自己也整理一份，因为千人千面，很难做到满足所有人，所以自己刷题，一定要整理