力扣刷题笔记

类 StringBuilder

类 String 表示字符串， 比如“ abc ”。 类 StringBuilder 表示可改变大小的字符序列（ sequence of characters ），多个字符组成字符序列，字符序列和字符串是同一个意思。二者的区别在于， String 类型的字符串是常量，字符串创建出来后不允许修改。而 StringBuilder 类型的字符串是可修改的。

类 StringBuilder 有两个核心的 API ，分别是 append 和 insert 。前者的功能是在原来的字符串的尾部追加指定的字符串，后者的功能是在原来的字符串的指定位置插入指定的字符串。

比如，现在有个 StringBuilder 类型的字符串[ start ]，声明为
StringBuilder z = new StringBuilder(“start”);

那么，

z.append(“le”) 等于 startle
表示在原来字符串[ start ]的尾部追加字符串[ le ]。

z.insert(4, “le”) 等于 starlet
表示在原来字符串[ start ]的偏移量为 4 的位置，插入指定的字符串[ le ]，原先处于偏移量为 4 以及之后的所有字符，全部向后移动，腾出空间插入指定的字符串[ le]。

toCharArray

将字符串转换为字符数组

Split和ToCharArray的区别：
（1）split是根据你需要按照的分隔符来分割的，比如：String a = “avc,d,e,s,f”; String []b = a.split(’,’);这个就是根据逗号将数据分开,遍历输出得到的b的对象为"avc",“d”,“e”,“s”,“f”。
（2）toCharArray是将String对象的每一个下标位的对象保存在char[]中，比如：String a = “abcd”; char[] b = a.toCharArray(); 这个b保存的信息就是[‘a’,‘b’,‘c’,‘d’]。

toString()

toString 方法会返回一个“以文本方式表示”此对象的字符串

注意：toString() 只适用于对象的调用，普通的数据类型不可以调用，这也就是使用包装类的原因

stack

用LinkedList实现栈得到操作：

LinkedList同时实现了List接口和Deque对口，也就是收它既可以看作一个顺序容器，又可以看作一个队列（Queue），同时又可以看作一个栈（stack），这样看来，linkedList简直就是无敌的，当你需要使用栈或者队列时，可以考虑用LinkedList。

stack.addLast(head.val);//压栈
res[i] = stack.removeLast();//出栈

有限状态自动机

字符类型：

空格 「 」、数字「 0—90—90—9 」 、正负号 「 +++, −-− 」 、小数点 「 … 」 、幂符号 「 eee, EEE 」 。

状态定义：

按照字符串从左到右的顺序，定义以下 9 种状态。

开始的空格
幂符号前的正负号
小数点前的数字
小数点、小数点后的数字
当小数点前为空格时，小数点、小数点后的数字
幂符号
幂符号后的正负号
幂符号后的数字
结尾的空格

结束状态：

合法的结束状态有 2, 3, 7, 8 。

算法流程：

初始化：
    状态转移表 states ： 设 states[i] ，其中 i 为所处状态， states[i] 使用哈希表存储可转移至的状态。键值对 (key, value) 含义：输入字符 key ，则从状态 i 转移至状态 value 。
    当前状态 p ： 起始状态初始化为 p = 0 。

状态转移循环： 遍历字符串 s 的每个字符 c 。
    记录字符类型 t ： 分为四种情况。
        当 c 为正负号时，执行 t = 's' ;
        当 c 为数字时，执行 t = 'd' ;
        当 c 为 e 或 E 时，执行 t = 'e' ;
        当 c 为 . 或 空格 时，执行 t = c （即用字符本身表示字符类型）;
        否则，执行 t = '?' ，代表为不属于判断范围的非法字符，后续直接返回 falsefalsefalse 。
    终止条件： 若字符类型 t 不在哈希表 states[p] 中，说明无法转移至下一状态，因此直接返回 falsefalsefalse 。
    状态转移： 状态 p 转移至 states[p][t] 。

返回值： 跳出循环后，若状态 p ∈2,3,7,8\in {2, 3, 7, 8}∈2,3,7,8 ，说明结尾合法，返回 truetruetrue ，否则返回 falsefalsefalse 。

复杂度分析：

时间复杂度 O(N)O(N)O(N) ： 其中 NNN 为字符串 s 的长度，判断需遍历字符串，每轮状态转移的使用 O(1)O(1)O(1) 时间。
空间复杂度 O(1)O(1)O(1) ： states 和 p 使用常数大小的额外空间。

java8使用 Comparator.comparing 进行排序

List<类> list; 代表某集合

//返回 对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));

//返回 对象集合以类属性一降序排序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序

//返回 对象集合以类属性一升序 属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));

//返回 对象集合以类属性一降序 属性二升序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序

//返回 对象集合以类属性一降序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序

//返回 对象集合以类属性一升序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序

//空/Null数据排序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(item -> item.属性二, Comparator.nullsLast(Date::compareTo))).collect(Collectors.toList());

//空/Null数据分组
Map<String, List<类>> map = list.stream().collect(Collectors.groupingBy(item -> {
if (item.属性一 == null || item.属性一.equals("")) {
　　return “”;
}
return DateFormat.getDateInstance().format(item.属性一);
}))