Java刷题常用技巧-长期更新

最新推荐文章于 2025-05-01 13:02:16 发布

Valerius_zhu

最新推荐文章于 2025-05-01 13:02:16 发布

阅读量939

点赞数

文章标签： java 正则表达式

本文链接：https://blog.youkuaiyun.com/weixin_43271235/article/details/107517614

版权

编程随笔专栏收录该内容

41 篇文章

订阅专栏

前言：一些有用的小技巧或者简便方法，大大缩短运行时间。暂时没写出例子，后面再整理。

Java刷题常用技巧-长期更新

复制或交换
字符或字符串
排序
遍历
- HashMap 的常见遍历
常见集合使用问题
- 数组和链表转换问题

复制或交换

复制：
Arrays.copyOf( ) 复制一个数组从起始位置开始的部分长度
Arrays.copyOfRange() 复制一个数组的部分区间
System.arraycopy() 复制源数组指定位置到目的数组的指定位置，复制长度

交换：
Collections.swap(List, i, j) 交换链表的两个位置

字符或字符串

1、判断字母或数字

注：利用JAVA静态工具类Character中的方法，可以节约时间。自己定义set判断或其它的较为麻烦。

        boolean a = Character.isLetter('A');
        boolean a3 = Character.isDigit('a');
        System.out.println(a);
        System.out.println(a3);

2、判断数组是否有交集或快速查找出交集

注：利用Arrays.binarySearch静态方法二分查找
快速的判断两个字符串型数组是否有交集

    // 通过二分查找
    public static boolean hasIntersectionBySortBS(int[] array1, int[] array2) {
        Arrays.sort(array2);
        for (int str : array1) {
            if (Arrays.binarySearch(array2, str) > -1) {
                return true;
            }
        }
        return false;
    }

3、匹配或替换

注：
1、replace参数直接传入字符串即可
2、replaceAll是正则表达式匹配，用好了特别方便

public String replace(@NotNull CharSequence target,
                      @NotNull CharSequence replacement)
// 底层代码，仍然要将CharSequence 转化为String，所以可以直接传入string
public String replace(CharSequence target, CharSequence replacement) {
        return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
                this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
    }

注：不需要掌握太复杂的匹配，但常见匹配方式需掌握，常用匹配会逐步总结在下面。
在这里插入图片描述
eg1：通过正则表达式匹配${xxx}

// java中转义需要两个//。括号表示子表达式，仅仅匹配替换的话不需要
String s = tmp.replaceAll("\\$\\{([^}]*)\\}", "");

排序

-1、Arrays.sort() 和sort(nums, from, to)

注：需要导入import static java.util.Arrays.sort

LeetCode 31. 下一个排列

import static java.util.Arrays.sort;
class Solution {
    public void nextPermutation(int[] nums) {
        if(nums == null || nums.length <= 1)
            return;
        int i = nums.length-1;
        while(i > 0){
            if(nums[i] > nums[i-1]){
                break;
            }
            i--;
        }
        if(i == 0){
            sort(nums);
        }else {
            // 倒着找一个比i-1恰好大的交换
            int flag = nums[i-1];
            int j = nums.length-1;
            while(j >= i){
                if(nums[j] > flag){
                    break;
                }
                j--;
            }
            nums[i-1] = nums[j];
            nums[j] = flag;
            sort(nums, i, nums.length);
        }
    }
}

1、hashMap按key排序和按value排序的两种简便方法

注：按照值排序需先转变为list后调用Collections.sort()或者list.sort()

按key排序

        Object[] keyArray = map.keySet().toArray();
        Arrays.sort(keyArray);
        // 遍历即可

按value排序

这样就可以将键值对捆绑在一起，按照值降序

List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(map.entrySet()); //转换为list
// 使用list.sort()排序
        list.sort(new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                //return 0;
                return o2.getValue() - o1.getValue(); // 按降序排列
                //return o2.getValue().compareTo(o1.getValue());
            }
        });
// 使用Collections.sort()排序
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return 0;
            }
        });

2、treeMap和treeSet按照键key排序，那么键若是引用对象，则必须实现Comparable接口，重写抽象方法

import java.util.*;
class Solution 
    public static void main(String[] args) {
        TreeMap<Person, String> personTreeMap = new TreeMap<();
        TreeSet<Person> people = new TreeSet<>();
    }
}

/*class Person{
}*/

class Person implements Comparable{
    @Override
    public int compareTo(Object o) {
        return 0;
    }
}

3、优先队列排序

有点类似与treeSet, 但treeSet缺点是键不允许重复，同时是严格有序，而优先队列只是控制队头元素最大或最小。
注：
1、优先队列类似于堆，可以同堆类别，默认队头最小，升序。若队头最大，降序。
2、new PriorityQueue<>构造时，可选参数传入容量或比较方式，适合从大量数据中选出最小的或最大的少数几个

leetcode 23. 合并K个升序链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists == null || lists.length == 0)
            return null;

        PriorityQueue<ListNode> queue = new PriorityQueue<>(lists.length, (o1, o2)->o1.val - o2.val);
        ListNode dummy = new ListNode(0);
        ListNode p = dummy;
        for (ListNode node : lists) {
            if (node != null) queue.add(node);
        }
        while (!queue.isEmpty()) {
            p.next = queue.poll();
            p = p.next;
            if (p.next != null) queue.add(p.next);
        }
        return dummy.next;
    
        // ListNode head = new ListNode(-1);
        // Map<Integer, ListNode> map = new TreeMap<Integer, ListNode>();
        // ListNode p, next, v;
        // for(int i = 0; i <lists.length; i++){
        //     p = lists[i];
        //     next = null; // 保存下一个结点
        //     v = null;
        //     while(p != null){
        //         int key = p.val;
        //         next = p.next;
        //         if(map.containsKey(key)){
        //             v = map.get(key);
        //             p.next = v; // 采用前插法
        //             map.put(key, p);
        //         }else{
        //             p.next = null; // 隔断尾结点的联系
        //             map.put(key, p);
        //         }
        //         p = next; // 后移
        //     }
        // }
        // ListNode node = head;
        // for(Map.Entry<Integer, ListNode> entry : map.entrySet()){
        //     ListNode value = entry.getValue();
        //     node.next = value;
        //     while(node.next != null){
        //         node = node.next; // node移到对应键的末尾结点
        //     }
        // }
        // return head.next;
    }

}

遍历

HashMap 的常见遍历

HashMap 的 7 种遍历方式与性能分析！(强烈推荐)

注：以后优先选用lambda, 其次entrySet

// ForEach EntrySet , 这种有利用理解hashMap底层结构
public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // 遍历
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.print(entry.getKey());
            System.out.print(entry.getValue());
        }
    }
}

// Lambda , 这种方式更为简洁
public class HashMapTest {
    public static void main(String[] args) {
        // 创建并赋值 HashMap
        Map<Integer, String> map = new HashMap();
        map.put(1, "Java");
        map.put(2, "JDK");
        map.put(3, "Spring Framework");
        map.put(4, "MyBatis framework");
        map.put(5, "Java中文社群");
        // 遍历
        map.forEach((key, value) -> {
            System.out.print(key);
            System.out.print(value);
        });
    }
}

常见集合使用问题

数组和链表转换问题

注：平时是避免使用的
Arrays.asList()是泛型方法
1、传入的对象必须是对象数组，而不能是基本类型数组
2、使用集合的修改方法:add()、remove()、clear()会抛出异常

Collection.toArray()将链表转化为数组或list.toArray()，关键在于toArray()形参，如new 对象类型[0]
1、new String[0]就是起一个模板的作用，指定了返回数组的类型，0是为了节省空间，因为它只是为了说明返回的类型

String [] s= new String[]{
    "dog", "lazy", "a", "over", "jumps", "fox", "brown", "quick", "A"
};
List<String> list = Arrays.asList(s);
Collections.reverse(list);
s=list.toArray(new String[0]);//没有指定类型的话会报错