java算法常用API

字符串

String 存放最终结果，StringBuilder用来拼接

String

声明

• String s = "abcdef";
• String s1 = new String(s);
• char[] chars = s.toCharArray();
  • String s2 = new String(chars);
  • String s3 = new String(chars, offset, count) 截取[offset, offset + count)
  • String s4 = String.valueOf(chars);

常用API

• charAt(i) 返回i位置的字符char
• length() 返回字符串长度
• subString(beg, end) 返回 [beg, end)的子串
• subString(beg) 返回 [beg, s.length()) 的子串
• indexOf(str) 返回str出现的第一个位置；没找到返回-1
• lastIndexOf(str) 返回str最后出现的位置；没找到返回-1
• startsWith(prefix) 判断字符串是否以prefix为前缀开始; 返回true 或 false
• endsWith(suffix) 判断字符串是否以suffix为后缀结束；返回true或false
• replace(oldStr, newStr) 返回新字符串，oldStr全部被替换为newStr
• toCharArray() 返回一个char[]
• trim() 返回新字符串，取出字符串的首位空格。==说法不准确==
• split(regex) 返回一个String[]，根据[[正则表达式]]regex来处理
• toLowerCase() 将字符串的所有字母转换为小写
• toUpperCase() 将字符串的所有字母转换为大写
• String.valueOf(data) 将其他类型的数据转变为字符串

StringBuilder

声明 StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder(str);

常用API

• charAt(i)
• length()
• append(str) 将str拼接到sb后边
• delete(start, end) 删除索引为[start, end)的字符串
• deleteCharAt(i) 删除索引为i的字符
• reverse() 反转sb
• toString()

集合框架

List

ArrayList底层是一个动态扩容的数组，适合查找元素。扩容的时间复杂度为O(N) LinkedList底层是一个双向链表，可作为双向队列和栈来使用。适合增删元素

List<Integer> arrayList = new ArrayList<>(); List<Integer> arraylist = new ArrayList<>(initialCapacity); List<Integer> linkedList = new LinkedList<>();

• size()
• isEmpty()
• clear()
• add(e) 链表末尾添加元素e；成功返回true
• add(i, e) 链表i位置添加元素e；void
• remove(e) 删除元素e；成功返回true
• remove(i) 删除i位置的元素；并返回该元素the element previously at the specified position
• get(i) 返回链表i位置的元素e
• set(i, e) 将i位置的元素更改为元素e；返回the element previously at the specified position
• indexOf(e) 返回第一次出现e的索引；不存在返回-1
• lastIndexOf(e) 返回最后一次出现e的索引；不存在返回-1
• toArray() 返回数组
• toString()

ArrayList

LinkedList

Stack

使用Deque来代替Stack，因为Stack继承自<vector>，不推荐使用。

Deque<Integer> stack = new LinkedList<>();

• size() 返回栈中元素个数
• isEmpty() 栈空返回true；栈非空返回false
• clear() 清空
• push(e) 栈顶插入元素；空间不足throws IllegalStateException
• pop() 删除栈顶元素并返回该元素; throws NoSuchElementException
• peek() 查看栈顶元素，并返回该元素；栈空返回null

Queue

构造 Queue<Integer> queue = new LinkedList<>();

• size() 返回队列中元素个数
• isEmpty() 队空返回true；队非空返回false
• clear() 清空
• offer(e) 队尾插入元素e，成功返回true；失败返回false
• poll() 删除队尾元素并返回该元素； 队空返回null
• peek() 查看队头元素，并返回该元素；队空返回null

Deque

构造 Deque<Integer> deque = new LinkedList<>(); 清爽版

• size() 返回队列中元素个数
• isEmpty() 队空返回true；队非空返回false
• clear() 清空
• offFirst(e) 队头插入元素e；空间不足返回false
• offLast(e) 队尾插入元素e；空间不足返回false
• pollFirst() 队头删除元素，并返回该元素； 队空返回null
• pollLast() 队尾删除元素，并返回该元素； 队空返回null
• peekFirst() 查看队头元素，并返回该元素；队空返回null
• peekLast() 查看队尾元素，并返回该元素；队空返回null

当栈用

• push(e) 空间不足throws IllegalStateException
• pop() 栈空throws NoSuchElementException
• peek() 栈空返回null 当队列用
• offer() 空间不足返回false
• poll() 队空返回null
• peek() 队空返回null

PriorityQueue

大根堆/小根堆 默认小根堆 Queue<Integer> pq = new PriorityQueue<>(); 大根堆 Queue<Integer> pq = new PriorityQueue<>((a,b) -> b - a);

• size()

• isEmpty()

• clear()

• offer(e) 将元素e插入优先队列；空间不足返回flase

• poll() 删除优先队列头元素，并返回该元素； 队空返回null

• peek() 查看优先队列头元素，并返回该元素；队空返回null

• contains(e)

---

Set

Set<Integer> set = new HashSet<>();

• size()
• isEmpty()
• clear()
• add(e) 集合添加元素e
• contains(e) 存在e返回true；不存在返回false
• remove(e) 集合删除元素e，返回true；集合中不存在e返回false

扩展TreeSet，比HashSet多了排序

Map

Map<Integer, Integer> map = new HashMap<>();

• size()
• isEmpty()
• put(k,v) Map中加入键值对<k,v>
• get(k) 返回k对应的v；不存在返回null
• remove(k) 删除k对应的v
• gerOrDefault(k, 0) 返回k对应的v，若不存在该k，则返回0
• containsKey(k) Map中存在k返回true；不存在返回false
• containsValue(v) Map中存在v返回true；不存在返回false
• keySet() 返会一个包含Map中所有Key的Set
• entrySet() 返回一个包含所有<k,v>映射的Set

遍历 for (Map.Entry<Integer, Integer> entry : map.entrySet()) {}

工具类

Collections

java.util.Collections

• Collections.sort(list); 从小到大排序
• Collections.sort(list, (a, b) -> b - a); 从大到小排序
• Collections.reverse(list); 反转list中的元素
• Colletcions.swap(list, i, j); 交换swap中i和j处的元素
• Collections.copy(list1, list2); 将list2中的元素拷贝到list1，注意确保list1的空间足够
• Collections.replaceAll(list, oldV, newVal); 将list中的oldVal都替换为newVal
• Collections.max(list); 返回list中最大元素
• Collections.frequency(list, e); 返回list中e出现的次数

Arrays

现有一数组int[] arr = new int[10];

• Arrays.sort(); 比较器
• int[] newA = Arrays.copyOf(arr, 10); 拷贝
• Arrays.binarySearch(arr, x); 二分查找x，并返回x对应的索引index
• Arrays.fill(arr, e); 用e来填充数组arr
• Arrays.toString(arr); 将arr变为字符串
• Arrays.equals(arr1, arr2); 比较arr1和arr2的元素是否对应相等；返回true 或 false
• Arrays.asList(arr) 数组转List
  • List<Integer> list = new ArrayList(Arrays.asList(arr)); 这样可以增删元素

比较器

数组排序

Integer[] arr = new Integer[10];  

//  典型比较器写法
Arrays.sort(arr, new Comparator<Integer>() {  
    @Override  
    public int compare(Integer a, Integer b) {  
        return a - b; // 升序  
        // if: return正数， a - b > 0时， swap(a,b).        
        // else if: return负数 a - b < 0时，位置不变
        // else：return 0，位置不变
        
        //return b - a; // 降序    
    }  
});

// 等价Lambda方式
Arrays.sort(arr, (a, b) -> a - b);  // 升序
Arrays.sort(arr, (a, b) -> b - a);  // 降序

==当a < b，若想要升序，我期待返回负数。== ==当a < b，若想降序，我期待返回正数。==

字符串比较

• compareTo(String anotherString) 按字典顺序比较两个字符串；返回两字符的差值(s > anotherSting 返回正数，相等返回0，小于返回负数)
• compareToIgnoreCase(String anotherString) 按字典顺序且不区分大小写比较两个字符串
• equals(String anotherString) 判断两个字符串是否相等，返回true或false
• equalsIgnoreCase(String str) 不区分大小写。

集合排序 TreeSet<Integer> treeSet = new TreeSet<>((a, b) -> a - b);

Math

java.lang.Math

• Math.min(a, b); 取a，b的最小值
• Math.max(a, b); 取a， b的最大值
• Math.sqrt(double d); 求 d 的算术平方根（正平方根）
• Math.abs(a); 求a 的绝对值
• Math.pow(double a, double b); 求a^b
• Math.ceil(double x); 向上取整
• Math.floor(double x); 向下取整
• Math.round(double x); 四舍五入取整
• Math.random(); 生成[0, 1)的随机数(double类型)
  • int x = (int)Math.random() * b + 1 生成[1, b]的随机数
  • int x = (int)Math.random() * (b - a + 1) + a) 生成[a, b]的随机数

Integer

• Integer.parseInt(s); 将字符串s解析为十进制数
• Integer.parseInt(s, radix); 将字符串s解析为radix进制数