LeetCode之常用函数

 网络了 LeetCode 口试经典150 & LeetCode 热题100中常用的函数与本领
   LeetCode之数组/字符串

所在链接

1.     public static void main(String[] args) {
2.         // 1. 数组排序
3.         int[] array = new int[]{3, 7, 5, 2};
4.         Arrays.sort(array);
5.         // 结果: [2, 3, 5, 7]
6.         System.out.println(Arrays.toString(array));
8.         // 2. 数组拷贝
9.         int[] arrayOld = new int[]{1, 2, 3, 4, 5};
10.         int[] arrayNew = new int[5];
11.         System.arraycopy(arrayOld, 0, arrayNew, 0, arrayOld.length - 1);
12.         // 结果: [1, 2, 3, 4, 5]
13.         System.out.println(Arrays.toString(arrayOld));
14.         // 结果: [1, 2, 3, 4, 0]
15.         System.out.println(Arrays.toString(arrayNew));
17.         // 3. 最大值最小值
18.         int max = Math.max(2, 3);
19.         int min = Math.min(2, 3);
20.         // 结果 3-2
21.         System.out.println(max + "-" + min);
23.         // 4. 随机数生成
24.         Random random = new Random();
25.         int randomInt = random.nextInt(10);
26.         // 结果: 8
27.         System.out.println(randomInt);
29.         // 5. HashMap
30.         Map<String, String> hashMap = Maps.newHashMap();
31.         hashMap.put("1", "1");
32.         hashMap.put("2", "2");
33.         hashMap.put("3", "3");
34.         // 结果: true
35.         System.out.println(hashMap.containsKey("1"));
37.         // 6. ArrayList
38.         List<String> arrayList = Lists.newArrayList("1", "2", "3");
39.         arrayList.set(2, "4");
40.         arrayList.remove(1);
41.         // 结果: [1, 4]
42.         System.out.println(arrayList);
44.         // 7. 数组创建
45.         int[] arr1 = new int[3];
46.         arr1[0] = 1;
47.         int[] arr2 = {1, 2, 3};
48.         int[] arr3 = new int[]{1,2,3};
49.         // 结果: [1, 0, 0]
50.         System.out.println(Arrays.toString(arr1));
51.         // 结果: [1, 2, 3]
52.         System.out.println(Arrays.toString(arr2));
53.         // 结果: [1, 2, 3]
54.         System.out.println(Arrays.toString(arr3));
56.         // 8. 字符串
57.         String str = "hello world";
58.         char[] charArray = str.toCharArray();
59.         // 结果: l
60.         System.out.println(str.charAt(3));
61.         // 结果: [h, e, l, l, o,  , w, o, r, l, d]
62.         System.out.println(Arrays.toString(charArray));
64.         // 9. switch语句
65.         String condition = "a";
66.         // 结果: a
67.         switch (condition) {
68.             case "a":
69.                 System.out.println("a");
70.                 break;
71.             case "b":
72.                 System.out.println("b");
73.                 break;
74.             default:
75.                 System.out.println("c");
76.         }
78.         // 10. 可变字符串
79.         StringBuilder sb = new StringBuilder();
80.         sb.append("1");
81.         sb.append("2");
82.         sb.append("3");
83.         // 结果: 123
84.         System.out.println(sb.toString());
86.         // 11. 字符串去空格
87.         String strTrim = " tes t ";
88.         String trim = strTrim.trim();
89.         // 结果: tes t
90.         System.out.println(trim);
91.         // 结果: 5
92.         System.out.println(strTrim.lastIndexOf("t"));
94.         // 12. 字符串截取
95.         String strSub = "test subString";
96.         String substring = strSub.substring(5, 8);
97.         System.out.println(substring);
99.         // 13. 正则&字符串拼接
100.         String string = " hello world ";
101.         String trim1 = string.trim();
102.         // 结果: hello world
103.         System.out.println(trim1);
104.         String[] split = trim1.split("\\s+");
105.         List<String> strings = Arrays.asList(split);
106.         // 结果: [hello, world]
107.         System.out.println(strings);
108.         Collections.reverse(strings);
109.         // 结果: [world, hello]
110.         System.out.println(strings);
111.         // 结果: world,hello
112.         String join = String.join(",", strings);
113.         System.out.println(join);
114.     }

复制代码

LeetCode之双指针

所在链接

1.     public static void main(String[] args) {
2.         // 1. Char操作
3.         char a = '1';
4.         char b = 'b';
5.         // 判断是否字符或数组
6.         // 结果: true
7.         System.out.println(Character.isLetter(b));
8.         // 结果: true
9.         System.out.println(Character.isDigit(a));
10.         // 结果: true
11.         System.out.println(Character.isLetterOrDigit(a));
12.         char c = 'C';
13.         // 结果: true
14.         System.out.println(Character.toLowerCase(c));
16.         // 2. 可变字符串反转
17.         StringBuilder sb = new StringBuilder();
18.         sb.append("1");
19.         sb.append("2");
20.         sb.append("3");
21.         // 结果: 321
22.         System.out.println(sb.reverse());
23.     }

复制代码

LeetCode之滑动窗口

所在链接

1.     public static void main(String[] args) {
2.         // 1. Integer最大最小值
3.         int min = Integer.MIN_VALUE;
4.         int max = Integer.MAX_VALUE;
5.         // 结果: -2147483648
6.         System.out.println(min);
7.         // 结果: 2147483648
8.         System.out.println(max);
10.         // 2. Set操作
11.         Set<String> set = Sets.newHashSet("1", "2", "2", "3");
12.         // 结果: [1, 2, 3]
13.         System.out.println(set);
14.         // 结果: true
15.         System.out.println(set.contains("2"));
16.         // 结果: true
17.         System.out.println(set.remove("3"));
18.         // 结果: [1, 2]
19.         System.out.println(set);
20.     }

复制代码

LeetCode之矩阵

所在链接

1.     public static void main(String[] args) {
2.         // 1. 字母索引
3.         char a = 'a';
4.         char b = 'b';
5.         // 结果: 49
6.         System.out.println(a - '0');
7.         // 结果: 50
8.         System.out.println(b - '0');
10.         // 2. 深拷贝
11.         int[] aArr = new int[]{1, 2, 3};
12.         int[] clone = aArr.clone();
13.         clone[0] = 11;
14.         // 结果: [1, 2, 3]
15.         System.out.println(Arrays.toString(aArr));
16.         // 结果: [11, 2, 3]
17.         System.out.println(Arrays.toString(clone));
18.     }

复制代码

LeetCode之哈希表

所在链接

1.     public static void main(String[] args) {
2.         // 1. Map操作
3.         Map<Integer, String> map = new HashMap<>();
4.         map.put(1, "1");
5.         map.put(2, "2");
6.         // 结果: 3
7.         System.out.println(map.getOrDefault(3, "3"));
8.         // 结果: true
9.         System.out.println(map.containsKey(1));
10.         Collection<String> values = map.values();
11.         // 结果: [1, 2]
12.         System.out.println(values);
13.         List<String> list = new ArrayList<>(values);
14.         // 结果: [1, 2]
15.         System.out.println(list);
17.         // 2. Set操作
18.         Set<Integer> set = new HashSet<>();
19.         set.add(1);
20.         set.add(2);
21.         // 结果: true
22.         System.out.println(set.contains(1));
24.         // 3. 字符串char操作
25.         String str = "hello";
26.         char[] chars = str.toCharArray();
27.         // 结果: [h, e, l, l, o]
28.         System.out.println(Arrays.toString(chars));
29.         // 结果: e
30.         System.out.println(str.charAt(1));
32.         // 4. 字符串分割
33.         String s = "dog cat cat dog";
34.         String[] s1 = s.split(" ");
35.         // 结果: [dog, cat, cat, dog]
36.         System.out.println(Arrays.toString(s1));
38.         // 5. 最大最小值
39.         int max = Math.max(2, 3);
40.         int min = Math.min(1, 2);
41.         // 结果: 3
42.         System.out.println(max);
43.         // 结果: 1
44.         System.out.println(min);
46.         // 6. 除法操作
47.         // 结果: 3
48.         System.out.println(6 / 2);
49.         // 结果: 0
50.         System.out.println(6 % 2);
51.         // 结果: 2
52.         System.out.println(5 / 2);
53.         // 结果: 1
54.         System.out.println(5 % 2);
55.     }

复制代码

LeetCode之区间

所在链接

1.     public static void main(String[] args) {
2.         // 1. StringBuilder
3.         StringBuilder sb = new StringBuilder(Integer.toString(1));
4.         sb.append("2");
5.         // 结果: 12
6.         System.out.println(sb.toString());
8.         // 2. Arrays
9.         int[] arr = new int[]{3, 1, 2, 4};
10.         Arrays.sort(arr);
11.         // 结果: [1, 2, 3, 4]
12.         System.out.println(Arrays.toString(arr));
13.         int[][] arr1 = new int[][]{{2, 1}, {1, 2}, {3, 0}};
14.         // 结果: [[3, 0], [2, 1], [1, 2]]
15.         Arrays.sort(arr1, (a, b) -> b[0] - a[0]);
16.         System.out.println(Arrays.deepToString(arr1));
17.         // 结果: [[1, 2], [2, 1], [3, 0]]
18.         Arrays.sort(arr1, (a, b) -> a[0] - b[0]);
19.         System.out.println(Arrays.deepToString(arr1));
21.         // 3. List
22.         List<int[]> list = new ArrayList<>();
23.         list.add(new int[]{1, 2});
24.         list.add(new int[]{3, 4});
25.         int[][] arr2 = list.toArray(new int[1][1]);
26.         // 结果: [[1, 2], [3, 4]]
27.         System.out.println(Arrays.deepToString(arr2));
28.     }

复制代码

LeetCode之栈

所在链接

1. public static void main(String[] args) {
2.         // 双端队列
3.         Deque<Character> stack = new ArrayDeque<>();
4.         stack.push('1');
5.         stack.push('2');
6.         // 结果: 2
7.         System.out.println(stack.peek());
8.         // 结果: 2
9.         System.out.println(stack.pop());
10.         // 结果: false
11.         System.out.println(stack.isEmpty());
12.         // 结果: 1
13.         System.out.println(stack.pop());
14.         // 结果: true
15.         System.out.println(stack.isEmpty());
17.         // Character
18.         String str = "test";
19.         char[] chars = str.toCharArray();
20.         // 结果: t
21.         System.out.println(str.charAt(0));
22.         // 结果: [t, e, s, t]
23.         System.out.println(Arrays.toString(chars));
25.         // 双端队列
26.         Deque<Character> deque = new LinkedList<>();
27.         // 从左右往右offer
28.         deque.offerFirst('1');
29.         deque.offerFirst('2');
30.         deque.offerFirst('3');
31.         deque.push('4');
32.         deque.offerLast('5');
33.         // 结果: [4, 3, 2, 1, 5]
34.         System.out.println(deque);
35.         deque.pollFirst();
36.         // 结果: [3, 2, 1, 5]
37.         System.out.println(deque);
38.         deque.pollLast();
39.         // 结果: [3, 2, 1]
40.         System.out.println(deque);
41.         
42.         // Integer
43.         String str1 = Integer.toString(1);
44.         // 结果: 1
45.         System.out.println(str1);
46.         int i = Integer.parseInt("2");
47.         // 结果: 2
48.         System.out.println(i);
49.     }

复制代码

LeetCode之链表

所在链接

1.     static class ListNode {
2.         // 节点的值
3.         int val;
4.         // 指向下一个节点的指针
5.         ListNode next;
6.         // 默认构造函数
7.         ListNode() {}
8.         // 带值的构造函数
9.         ListNode(int x) {
10.             this.val = x;
11.         }
12.         // 带值和下一个节点的构造函数
13.         ListNode(int val, ListNode next) {
14.             this.val = val;
15.             this.next = next;
16.         }
17.     }
19.     public static void main(String[] args) {
20.         // Set
21.         Set<ListNode> set = new HashSet<>();
22.         ListNode node1 = new ListNode(1);
23.         ListNode node2 = new ListNode(2);
24.         node1.next = node2;
25.         set.add(node1);
26.         set.add(node2);
27.         // 结果: true
28.         System.out.println(set.contains(node1));
30.         // dummyNode
31.         ListNode dummyNode = new ListNode(-1);
32.         ListNode node3 = new ListNode(3);
33.         dummyNode.next = node3;
34.         // 当前节点初始化为哨兵节点
35.         ListNode cur = dummyNode;
36.         // 结果: -1
37.         System.out.println(cur.val);
38.         // 结果: 3
39.         System.out.println(cur.next.val);
40.     }

复制代码

LeetCode之二叉树

所在链接

1.     static class TreeNode {
2.         int val;
3.         TreeNode left;
4.         TreeNode right;
5.         TreeNode() {}
6.         TreeNode(int val) {
7.             this.val = val;
8.         }
9.         TreeNode(int val, TreeNode left, TreeNode right) {
10.             this.val = val;
11.             this.left = left;
12.             this.right = right;
13.         }
14.     }
16.     public static void main(String[] args) {
17.         TreeNode root = new TreeNode(0);
18.         TreeNode treeNode1 = new TreeNode(1);
19.         TreeNode treeNode2 = new TreeNode(2);
20.         root.left = treeNode1;
21.         root.right = treeNode2;
22.     }

复制代码

LeetCode之二叉树条理遍历

所在链接

1.     public static void main(String[] args) {
2.         // 队列
3.         Queue<Integer> queue = new ArrayDeque<>();
4.         queue.offer(1);
5.         queue.offer(2);
6.         queue.offer(3);
8.         // 结果: [1, 2, 3]
9.         System.out.println(queue);
10.         // 结果: 1 左头右尾
11.         System.out.println(queue.peek());
12.         // 结果: 1
13.         System.out.println(queue.poll());
14.         // 结果: [2, 3]
15.         System.out.println(queue);
17.         // 双端队列
18.         Deque<Integer> deque = new ArrayDeque<>();
19.         deque.offer(1);
20.         // 左头右尾
21.         deque.offerLast(2);
22.         // 结果: [1, 2]
23.         System.out.println(deque);
24.         deque.offerFirst(3);
25.         // 结果: [3, 1, 2]
26.         System.out.println(deque);
27.         deque.pollLast();
28.         // 结果: [3, 1]
29.         System.out.println(deque);
30.         deque.pollFirst();
31.         // 结果: [1]
32.         System.out.println(deque);
33.     }

复制代码

LeetCode之二叉搜刮树

所在链接

1.     public static void main(String[] args) {
2.         // 最大最小值
3.         // 结果: -2147483648
4.         System.out.println(Integer.MIN_VALUE);
5.         // 结果: 2147483647
6.         System.out.println(Integer.MAX_VALUE);
7.         // 结果: -9223372036854775808
8.         System.out.println(Long.MIN_VALUE);
9.         // 结果: 9223372036854775807
10.         System.out.println(Long.MAX_VALUE);
11.         // 结果: 1
12.         System.out.println(Math.min(1, 2));
13.         // 结果: 2
14.         System.out.println(Math.max(1, 2));
15.     }

复制代码

LeetCode之图

所在链接

1.    public static void main(String[] args) {
2.         // 图
3.         int[][] grid = new int[][]{{1, 2, 3}, {4, 5, 6}};
4.         // 结果: [[1, 2, 3], [4, 5, 6]]
5.         System.out.println(Arrays.deepToString(grid));
6.         // 结果: 2
7.         System.out.println(grid.length);
8.         // 结果: 3
9.         System.out.println(grid[0].length);
11.         // HashMap
12.         Map<Integer, String> map = new HashMap<>();
13.         map.put(1, "1");
14.         map.put(2, "2");
15.         map.put(3, "3");
16.         // 结果: true
17.         System.out.println(map.containsKey(1));
18.         // 结果: false
19.         System.out.println(map.containsValue(4));
20.         // 结果: null;
21.         System.out.println(map.putIfAbsent(4, "4"));
22.         for (Map.Entry<Integer, String> item : map.entrySet()) {
23.             System.out.println(item.getKey());
24.             System.out.println(item.getValue());
25.         }
26.     }

复制代码

LeetCode之图的广度优先搜刮

所在链接

1.     public static void main(String[] args) {
2.         // 1. Set
3.         String[] str = new String[]{"1", "2", "2", "3"};
4.         List<String> list = Arrays.asList(str);
5.         // 结果: [1, 2, 2, 3]
6.         System.out.println(list);
7.         Set<String> set = new HashSet<>(list);
8.         // 结果: [1, 2, 3]
9.         System.out.println(set);
10.         // 结果: true
11.         System.out.println(set.contains("1"));
12.         set.remove("1");
13.         // 结果: false
14.         System.out.println(set.contains("1"));
16.         // 2. 队列,先进先出
17.         Queue<Integer> queue = new LinkedList<>();
18.         queue.offer(1);
19.         queue.offer(2);
20.         queue.offer(3);
21.         // 结果: [1, 2, 3]
22.         System.out.println(queue);
23.         queue.poll();
24.         // 结果: [2, 3]
25.         System.out.println(queue);
26.         // 结果: 2
27.         System.out.println(queue.size());
28.         // 结果: false
29.         System.out.println(queue.isEmpty());
31.         // 3. String
32.         String str1 = "hello";
33.         StringBuilder sb = new StringBuilder(str1);
34.         // 结果: hello
35.         System.out.println(sb);
36.         sb.setCharAt(1, 'w');
37.         // 结果: hwllo
38.         System.out.println(sb.toString());
39.     }

复制代码

LeetCode之字典树

所在链接

1.     public static void main(String[] args) {
2.         // 1. Character
3.         String str = "abcde";
4.         char[] charArr = str.toCharArray();
5.         List<Integer> list = new ArrayList<>();
6.         for (char item : charArr) {
7.             int i = item - 'a';
8.             list.add(i);
9.         }
10.         // 结果: [0, 1, 2, 3, 4]
11.         System.out.println(list);
12.         // 结果: a
13.         System.out.println(str.charAt(0));
14.     }

复制代码

LeetCode之回溯

所在链接

1.     public static void main(String[] args) {
2.         // 1. Character
3.         String str = "hello";
4.         StringBuilder sb = new StringBuilder(str);
5.         // 结果: h
6.         System.out.println(str.charAt(0));
7.         sb.deleteCharAt(1);
8.         // 结果: hllo
9.         System.out.println(sb);
11.         // 2. List
12.         List<Integer> list = new ArrayList<>();
13.         list.add(1);
14.         list.add(2);
15.         list.add(3);
16.         // 结果: [1, 2, 3]
17.         System.out.println(list);
18.         list.remove(list.size() - 1);
19.         // 结果: [1, 2]
20.         System.out.println(list);
22.         // 3. Deque
23.         Deque<Integer> deque = new LinkedList<>();
24.         deque.addLast(1);
25.         deque.addLast(2);
26.         deque.addFirst(0);
27.         deque.addLast(3);
28.         // 结果: [0, 1, 2, 3]
29.         System.out.println(deque);
30.         deque.removeLast();
31.         List<Integer> list1 = new ArrayList<>(deque);
32.         // 结果: [0, 1, 2]
33.         System.out.println(list1);
34.         list1.remove(1);
35.         // 结果: [0, 2]
36.         System.out.println(list1);
38.         // 4. StringBuilder
39.         StringBuilder sb1 = new StringBuilder("hello");
40.         // 结果: hello
41.         System.out.println(sb1);
42.         sb1.deleteCharAt(sb1.length() - 1);
43.         // 结果: hell
44.         System.out.println(sb1);
45.     }

复制代码

LeetCode之分治

所在链接

1.    static class TreeNode {
2.         int val;
3.         TreeNode left;
4.         TreeNode right;
6.         public TreeNode() {
7.         }
9.         public TreeNode(int val) {
10.             this.val = val;
11.         }
13.         public TreeNode(int val, TreeNode left, TreeNode right) {
14.             this.val = val;
15.             this.left = left;
16.             this.right = right;
17.         }
18.     }
20.     static class ListNode {
21.         int val;
22.         ListNode next;
23.         public ListNode() {}
24.         public ListNode(int val) {
25.             this.val = val;
26.         }
27.         public ListNode(int val, ListNode next) {
28.             this.val = val;
29.             this.next = next;
30.         }
31.     }
33.     public static void main(String[] args) {
34.         // 1. 中间值计算
35.         int left = 1;
36.         int right = 5;
37.         // 结果: 3 此方式可能会数组越界
38.         System.out.println((left + right) / 2);
39.         // 结果: 3 右移1位相当于除以2
40.         System.out.println((left + right) >> 1);
41.         // 结果: 3
42.         System.out.println((right - left) / 2 + left);
44.         // 2. 排序
45.         List<String> list = Lists.newArrayList("1", "5", "3", "0");
46.         // 结果: [1, 5, 3, 0]
47.         System.out.println(list);
48.         Collections.sort(list);
49.         // 结果: [0, 1, 3, 5]
50.         System.out.println(list);
51.     }

复制代码

LeetCode之二分查找

所在链接

1.     public static void main(String[] args) {
2.         // 1. 中间值计算
3.         int left = 1;
4.         int right = 5;
5.         // 结果: 3 此方式可能会数组越界
6.         System.out.println((left + right) / 2);
7.         // 结果: 3 右移1位相当于除以2
8.         System.out.println((left + right) >> 1);
9.         // 结果: 3
10.         System.out.println((right - left) / 2 + left);
12.         // 2. 二分查找
13.         int[] nums = new int[]{1, 2, 3, 4};
14.         int target = 2;
15.         while (left <= right) {
16.             int mid = (left + right) / 2;
17.             if (target <= nums[mid]) {
18.                 right = mid - 1;
19.             } else {
20.                 left = mid + 1;
21.             }
22.         }
24.         // 3. 最大最小值
25.         int min = Math.min(1, 2);
26.         int max = Math.max(1, 2);
27.         // 结果: 1
28.         System.out.println(min);
29.         // 结果: 2
30.         System.out.println(max);
31.     }

复制代码

LeetCode之堆

所在链接

1.     public static void main(String[] args) {
2.         // 1. 优先级队列，会给队列自动排序，头部最小
3.         PriorityQueue<Integer> queue = new PriorityQueue<>(1);
4.         queue.offer(5);
5.         queue.offer(1);
6.         queue.offer(3);
7.         queue.offer(2);
8.         queue.offer(4);
9.         // 结果: [1, 2, 3, 5, 4]
10.         System.out.println(queue);
11.         // 结果: 1
12.         System.out.println(queue.peek());
13.         queue.poll();
14.         // 结果: [2, 4, 3, 5]
15.         System.out.println(queue);
17.         // 2. 优先级队列，会给队列自动排序，(降序)头部最大
18.         PriorityQueue<Integer> queue1 = new PriorityQueue<>(Comparator.reverseOrder());
19.         queue1.offer(5);
20.         queue1.offer(1);
21.         queue1.offer(3);
22.         queue1.offer(2);
23.         queue1.offer(4);
24.         // 结果: [5, 4, 3, 1, 2]
25.         System.out.println(queue1);
26.         // 结果: 5
27.         System.out.println(queue1.peek());
28.         queue1.poll();
29.         // 结果: [4, 2, 3, 1]
30.         System.out.println(queue1);
32.         // 3. 数组
33.         PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] + a[1] - b[0] - b[1]);
34.         pq.offer(new int[]{1, 2});
35.         pq.offer(new int[]{0, 1});
36.         pq.offer(new int[]{2, 3});
37.         List<String> list = new ArrayList<>();
38.         for (int[] ints : pq) {
39.             list.add(Arrays.toString(ints));
40.         }
41.         // 结果: [[0, 1], [1, 2], [2, 3]]
42.         System.out.println(list);
44.         // 4. List
45.         // 结果: [1, 2, 3]
46.         System.out.println(Lists.newArrayList("1", "2", "3"));
47.     }

复制代码

LeetCode之位运算

所在链接

1.     public static void main(String[] args) {
2.         // 1、StringBuilder
3.         StringBuilder sb = new StringBuilder("abc");
4.         // 结果: cba
5.         System.out.println(sb.reverse());
6.         // 结果: 49
7.         System.out.println('a' - '0');
8.         // 结果: 50
9.         System.out.println('b' - '0');
10.         // 结果: 51
11.         System.out.println('c' - '0');
12.         // 结果: 2
13.         System.out.println('c' - 'a');
15.         // 2、位操作 取出 3 的最低位
16.         // 结果: 1
17.         System.out.println(3 & 1);
19.         // 3、异或
20.         // 异或运算的特性是：相同的数字相互抵消
21.         // 0 与 任何数字异或都等于该数字
22.         // 结果: 0
23.         System.out.println( 5 ^ 5);
24.         // 结果: 5
25.         System.out.println(0 ^ 5);
26.     }

复制代码

LeetCode之数学

所在链接

1.     public static void main(String[] args) {
2.         // 1、String
3.         String str = String.valueOf(123);
4.         StringBuilder sb = new StringBuilder(str);
5.         System.out.println(sb.reverse().toString());
7.         // 2、double
8.         System.out.println(2 / 1.0);
9.         System.out.println(2 % 1.0);
10.     }

复制代码

LeetCode之一维动态规划

所在链接

1.     public static void main(String[] args) {
2.         // 1、最大最小值
3.         int min = Math.min(1, 2);
4.         int max = Math.max(1, 2);
5.         // 结果: 1
6.         System.out.println(min);
7.         // 结果: 2
8.         System.out.println(max);
10.         // 2、Set
11.         Set<String> set = new HashSet<>();
12.         set.add("1");
13.         set.add("2");
14.         // 结果: true
15.         System.out.println(set.contains("1"));
17.         // 3、Array
18.         int[] arr = new int[5];
19.         // 结果: [0, 0, 0, 0, 0]
20.         System.out.println(Arrays.toString(arr));
21.         Arrays.fill(arr, 1);
22.         // 结果: [1, 1, 1, 1, 1]
23.         System.out.println(Arrays.toString(arr));
24.     }

复制代码

LeetCode之多维动态规划

所在链接

1.     public static void main(String[] args) {
2.         // 1、CharArray
3.         String str = "abcde";
4.         char[] chars = str.toCharArray();
5.         // 结果: [a, b, c, d, e]
6.         System.out.println(Arrays.toString(chars));
7.         // 结果: a
8.         System.out.println(str.charAt(0));
9.         // 结果: bcd
10.         System.out.println(str.substring(1, str.length() - 1));
12.         // 2、最大最小值
13.         // 结果: 1
14.         System.out.println(Math.min(1, 2));
15.         // 结果: 4
16.         System.out.println(Math.max(2, 4));
17.     }

复制代码

LeetCode之多线程

所在链接

1.     // 1. 基础Thread类
2.     static class MyThread extends Thread {
4.         @Override
5.         public void run() {
6.             System.out.println("Thread is running: " + Thread.currentThread().getName());
7.         }
9.         public static void main(String[] args) {
10.             MyThread thread1 = new MyThread();
11.             MyThread thread2 = new MyThread();
12.             // 启动线程1 结果: Thread is running: Thread-0
13.             thread1.start();
14.             // 启动线程2 结果: Thread is running: Thread-1
15.             thread2.start();
16.         }
17.     }
19.     // 2. 实现Runnable接口
20.     static class MyRunnable implements Runnable {
22.         @Override
23.         public void run() {
24.             System.out.println("Thread is running: " + Thread.currentThread().getName());
25.         }
27.         public static void main(String[] args) {
28.             Thread thread1 = new Thread(new MyRunnable());
29.             Thread thread2 = new Thread(new MyRunnable());
30.             // 使用Lambda表达式简化Runnable的实现
31.             Thread thread3 = new Thread(() -> System.out.println("Thread is running: " + Thread.currentThread().getName()));
32.             // 启动线程1 结果: Thread is running: Thread-0
33.             thread1.start();
34.             // 启动线程2 结果: Thread is running: Thread-1
35.             thread2.start();
36.             // 启动线程3 结果: Thread is running: Thread-2
37.             thread3.start();
38.         }
39.     }
41.     // 3. 实现Callable接口
42.     static class MyCallable implements Callable<String> {
44.         @Override
45.         public String call() throws Exception {
46.             System.out.println("Thread is running: " + Thread.currentThread().getName());
47.             return Thread.currentThread().getName();
48.         }
50.         public static void main(String[] args) throws ExecutionException, InterruptedException {
51.             MyCallable myCallable = new MyCallable();
52.             // FutureTask实现了RunnableFuture接口，而RunnableFuture接口同时继承了Runnable接口和Future接口
53.             FutureTask<String> futureTask = new FutureTask<>(myCallable);
54.             Thread thread = new Thread(futureTask);
55.             // 启动线程 结果: Thread is running: Thread-0
56.             thread.start();
57.             // 结果: Thread-0
58.             System.out.println(futureTask.get());
59.         }
60.     }
61.    
62.     // 4. 线程池方式
63.     public static void main(String[] args) throws ExecutionException, InterruptedException {
64.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(4,
65.                 4,
66.                 60,
67.                 TimeUnit.SECONDS,
68.                 new ArrayBlockingQueue<>(20000),
69.                 new ThreadPoolExecutor.CallerRunsPolicy());
71.         Runnable task1 = () -> System.out.println("task1 is running: " + Thread.currentThread().getName());
72.         Runnable task2 = () -> System.out.println("task2 is running: " + Thread.currentThread().getName());
73.         Callable<String> task3 = () -> {
74.             System.out.println("task3 is running: " + Thread.currentThread().getName());
75.             return Thread.currentThread().getName();
76.         };
78.         // Runnable无返回值，异常处理简单；Callable有返回值，异常处理更加灵活，使用submit()提交，返回一个Future对象，用于获取任务的结果
80.         // 提交任务1 结果: task1 is running: pool-1-thread-1
81.         threadPoolExecutor.execute(task1);
82.         // 提交任务2 结果: task2 is running: pool-1-thread-2
83.         threadPoolExecutor.submit(task2);
84.         // 提交任务3 结果: task3 is running: pool-1-thread-3
85.         Future<String> submit = threadPoolExecutor.submit(task3);
86.         // 结果: pool-1-thread-3
87.         System.out.println(submit.get());
88.     }
90.     /**
91.      * CountDownLatch 适用于需要等待其他线程完成某些操作后再继续的场景
92.      * 主线程等待3个工作线程完成后再继续执行
93.      * 结果
94.      * <p>
95.      * Thread-0 is working.
96.      * Thread-1 is working.
97.      * Thread-2 is working.
98.      * Thread-0 finished work.
99.      * Thread-1 finished work.
100.      * Thread-2 finished work.
101.      * Main thread resumes after all workers finished.
102.      */
103.     public static void main1(String[] args) throws InterruptedException {
104.         CountDownLatch countDownLatch = new CountDownLatch(3);
105.         for (int i = 0; i < 3; i++) {
106.             new Thread(() -> {
107.                 System.out.println(Thread.currentThread().getName() + " is working.");
108.                 // 工作完成，计数减一
109.                 countDownLatch.countDown();
110.                 System.out.println(Thread.currentThread().getName() + " finished work.");
111.             }).start();
112.         }
114.         // 等待计数为0
115.         countDownLatch.await();
116.         System.out.println("Main thread resumes after all workers finished.");
117.     }
119.     /**
120.      * 限制同时访问共享资源的线程数量
121.      * <p>
122.      * 结果
123.      * Thread-0 is working.
124.      * Thread-1 is working.
125.      * Thread-0 finished work.
126.      * Thread-1 finished work.
127.      * Thread-2 is working.
128.      * Thread-3 is working.
129.      * Thread-2 finished work.
130.      * Thread-3 finished work.
131.      * Thread-4 is working.
132.      * Thread-4 finished work.
133.      */
134.     public static void main2(String[] args) {
135.         // 允许
136.         Semaphore semaphore = new Semaphore(2);
137.         for (int i = 0; i < 5; i++) {
138.             new Thread(() -> {
139.                 try {
140.                     // 获取许可（如果当前可用的许可证（计数器值）大于 0，许可证计数减少 1，线程可以继续执行）
141.                     // 如果没有可用的许可证（计数器值为 0），线程将被阻塞，直到其他线程释放许可证
142.                     semaphore.acquire();
143.                     System.out.println(Thread.currentThread().getName() + " is working.");
144.                     // 模拟工作
145.                     Thread.sleep(1000);
146.                     System.out.println(Thread.currentThread().getName() + " finished work.");
147.                 } catch (Exception e) {
148.                     e.printStackTrace();
149.                 } finally {
150.                     // 释放许可
151.                     // 许可证计数器增加 1，表示有一个新的许可证可用
152.                     // 如果有任何被阻塞的线程正在等待许可证，它们会被唤醒，重新尝试获取许可证
153.                     semaphore.release();
154.                 }
155.             }).start();
156.         }
157.     }
159.     /**
160.      * 多个线程在一处同时执行，所有线程到达后再继续
161.      * 结果
162.      * <p>
163.      * Thread-0 is at the barrier.
164.      * Thread-1 is at the barrier.
165.      * Thread-2 is at the barrier.
166.      * All threads reached the barrier, continuing execution.
167.      * Thread-2 has crossed the barrier.
168.      * Thread-1 has crossed the barrier.
169.      * Thread-0 has crossed the barrier.
170.      */
171.     public static void main3(String[] args) {
172.         // 当所有线程到达时执行
173.         CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> System.out.println("All threads reached the barrier, continuing execution."));
175.         for (int i = 0; i < 3; i++) {
176.             new Thread(() -> {
177.                 System.out.println(Thread.currentThread().getName() + " is at the barrier.");
178.                 // 等待其他线程到达
179.                 try {
180.                     cyclicBarrier.await();
181.                 } catch (Exception e) {
182.                     System.out.println("cyclicBarrier catch error" + e);
183.                 }
184.                 System.out.println(Thread.currentThread().getName() + " has crossed the barrier.");
185.             }).start();
186.         }
187.     }
189.     /**
190.      * wait()和notify()
191.      * 结果
192.      * Produced: 0
193.      * Consumed: 0
194.      * Produced: 1
195.      * Consumed: 1
196.      * Produced: 2
197.      * Consumed: 2
198.      * Produced: 3
199.      * Consumed: 3
200.      * Produced: 4
201.      * Consumed: 4
202.      */
203.     private static final Object lock = new Object();
204.     private static boolean ready = false;
206.     public static void main4(String[] args) {
207.         Thread producer = new Thread(() -> {
208.             synchronized (lock) {
209.                 for (int i = 0; i < 5; i++) {
210.                     while (ready) {
211.                         try {
212.                             lock.wait();
213.                         } catch (InterruptedException e) {
214.                             e.printStackTrace();
215.                         }
216.                     }
217.                     ready = true;
218.                     System.out.println("Produced: " + i);
219.                     lock.notifyAll();
220.                 }
221.             }
222.         });
224.         Thread consumer = new Thread(() -> {
225.             synchronized (lock) {
226.                 for (int i = 0; i < 5; i++) {
227.                     while (!ready) {
228.                         try {
229.                             lock.wait();
230.                         } catch (InterruptedException e) {
231.                             e.printStackTrace();
232.                         }
233.                     }
234.                     ready = false;
235.                     System.out.println("Consumed: " + i);
236.                     lock.notifyAll();
237.                 }
238.             }
239.         });
241.         producer.start();
242.         consumer.start();
243.     }
245.     private static final Lock lock1 = new ReentrantLock();
246.     private static final Condition condition = lock1.newCondition();
248.     /**
249.      * await()和signal()
250.      * 结果
251.      * Produced: 0
252.      * Consumed: 0
253.      * Produced: 1
254.      * Consumed: 1
255.      * Produced: 2
256.      * Consumed: 2
257.      * Produced: 3
258.      * Consumed: 3
259.      * Produced: 4
260.      * Consumed: 4
261.      */
262.     public static void main(String[] args) {
263.         Thread producer = new Thread(() -> {
264.             lock1.lock();
265.             try {
266.                 for (int i = 0; i < 5; i++) {
267.                     while (ready) {
268.                         condition.await();
269.                     }
270.                     ready = true;
271.                     System.out.println("Produced: " + i);
272.                     condition.signalAll();
273.                 }
274.             } catch (InterruptedException e) {
275.                 e.printStackTrace();
276.             } finally {
277.                 lock1.unlock();
278.             }
279.         });
281.         Thread consumer = new Thread(() -> {
282.             lock1.lock();
283.             try {
284.                 for (int i = 0; i < 5; i++) {
285.                     while (!ready) {
286.                         condition.await();
287.                     }
288.                     ready = false;
289.                     System.out.println("Consumed: " + i);
290.                     condition.signalAll();
291.                 }
292.             } catch (Exception e) {
293.                 e.printStackTrace();
294.             } finally {
295.                 lock1.unlock();
296.             }
297.         });
299.         producer.start();
300.         consumer.start();
301.     }

复制代码