【LeetCode刷题】常用小技巧

一、字符串类

分割

String str = "I am     fine,  thank you"
String[] strArray = s.split(" "); // 这里匹配的是1个空格
String[] strArray = s.split("\\s"); // 正则匹配，这里匹配的也是1个空格
String[] strArray = s.split("\\s+"); // 这样才能匹配到多个空格


String[] strArray = s.split(""); // 将字符串分割成一个一个字符的数组

插入&删除字符

只有 StringBuilder 才有 insert 和 deleteChartAt 的方法，String 没有

String str = "1234";

// 删掉下标位0的字符
System.out.println(new StringBuilder(str).deleteCharAt(0)); // "234"

// 在下标为4的位置插入5，insert的第一个参数是插入字符后，该字符在字符串中的位置
// 所以这个参数最大只能是插入之前str的长度)
System.out.println(new StringBuilder(str).insert(str.length(), "5")); // "12345"

去掉前面所有的零

String str = "00001234";

// 正则匹配，replaceFirst的第一个参数是正则表达式
System.out.println(str.replaceFirst("^0*", ""));
// replace的第一个参数是字符串，是精确匹配，所以这么写达不到我们的目的
System.out.println(str.replace("^0*", ""));

从IDEA的提示也能看出，replace方法的第1个参数填"^0*"时，是一个普通字符串的样式，而不是正则表达式的样式

二、数组和List

2-1 数组转list

String[] 转list

String[] strArray = {"I", "am", "file"};
// 方法1：Arrays.asList 缺点：转换后的数组不可变，不能增删改
List<String> strList = Arrays.asList(strArray);

// 方法2：Collections.addAll
List<String> strList2 = new ArrayList<>();
Collections.addAll(strList2, strArray);

// 方法3：Lambda表达式
List<String> strList3 = Arrays.stream(strArray).toList();

int[] 转list

int[] numArray = {1, 2, 3, 4};
// 1. 这么写是不行的，这里int不会自动装箱
List<Integer> numList = Arrays.asList(numArray);

// 2. Collections.addAll 也不会自动装箱
List<Integer> numList2 = new ArrayList<>();
Collections.addAll(numList2, numArray);

// 3. Lambda表达式可以，一定要记得装箱 boxed()
List<Integer> numList3 = Arrays.stream(numArray).boxed().toList();

2-2 list转数组

// Lambda表达式
list.stream().mapToInt(Integer::intValue).toArray();

2-3 数组初始化

// 动和静的区别是，初始化时是否指定了元素

// 静态初始化
int[] numArray = {1, 2, 3};

// 动态初始化
int[] numArray2 = new int[3];
numArray[1] = 1;
numArray2[2] = 2;

2-4 List 初始化

不可变

修改了之后会报 Immutable Collections的错误

// 1. Arrays.asList 不可变
List<Integer> numList = Arrays.asList(1, 2, 3);

// 2. List.of 不可变
List<Integer> numList3 = List.of(1, 2, 3);

// 3. Stream.of不可变
List<Integer> numList4 = Stream.of(1, 2, 3).toList();

// 4. Arrays.stream
List<Integer> numList5 = Arrays.stream(new int[]{1, 2, 3}).boxed().toList();

可变

// 5. Collections.addAll 可变（万能方法，初始化set也食适用）
List<Integer> numList1 = new ArrayList<>();
Collections.addAll(numList1, 1, 2, 3);

// 6. 匿名内部类（注意：初始化时不需要<>；后面的{}里面还要再包一层{}）
List<Integer> numList2 = new ArrayList(){{
    add(1);
    add(2);
}
};

2-5 打印数组内容

本地调试打印数组内容会比较方便，但直接打印数组的话，控制台显示的是数组对应内存地址的哈希值，所以需要把数组转成list了之后再打印才能看到数组的内容

int[] array = {1, 2, 3};
// 数组对应内存数组的哈希值：[I@7ef20235
System.out.println(array);
// toString了之后才会打印数组内容：[1, 2, 3]
System.out.println(Arrays.toString(array));

List<Integer> list = Arrays.stream(array).boxed().toList();
// 打印List直接就是数组内容：[1, 2, 3]
System.out.println(list);

2-6 数组拷贝

System.arraycopy

int[] source = {0, 1, 2, 3, 4, 5};
int[] target = new int[3];

int srcStart = 1; // 从被拷贝数组的哪个下标开始拷贝
int tgtStart = 0; // 从目标数组的哪个下标开始粘贴
int copyLength = 3; // 一共复制多少个元素（该值小于 target的长度减初始粘贴的位置）

// 复制
System.arraycopy(source, srcStart, target, tgtStart, copyLength);
// 打印数组内容
System.out.println(Arrays.toString(target)); // [1, 2, 3]

三、Map

map初始化

// of一般都是不可变的，其他集合类也是一样；如果想要可变，那最好用构造器
// 1. Map.of 不可变（Java9）
Map<String, Integer> map = Map.of("key", 1, "key2", 2);

// 2. Map.ofEntries 不可变（Java9）
Map<String, Integer> map2 = Map.ofEntries(
Map.entry("key", 1),
Map.entry("key2", 2));

// 3. 双括号初始化 可变
Map<String, Integer> map3 = new HashMap<String, Integer>(){{
    put("key", 1);
    put("key2", 2);
}};

map遍历

// 1. for-each & Map.Entry
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + entry.getValue());
}

// 2. Lambda表达式
map.forEach((key, value) -> System.out.println(key + value));

// 3. 遍历key（可以通过key获取value）
for (String key : map.keySet()) {
    System.out.println(key);
    System.out.println(map.get(key));
}

// 4. 只关心value
for (int value : map.values()) {
    System.out.println(value);
}

四、其他

Java为什么向下取整

之前总是记不住Java做除法时，是向上还是向下取整，答案是向下。
看到一个说法是，在分配资源的时候肯定是以一个单位来分配的，不够一个单位时无法分配资源，所以为了分配资源方便，所以都是向下取整