【算法学习】Java算法常见库函数

字符串

String

1、substring()

语法：
①string.substring(start, end)
②string.substring(start)
参数：
start —— 起始索引，从0开始，包含当前索引
end —— 结束索引，不包含当前索引

回溯中使用到字符串的分割，从start开始枚举子串结束位置需要+1，s.substring(i,j+1);

2、查找

语法：
string.charAt(int index)

获取字符串中某个索引的字符：
char c = s.charAt(i)

3、字母大小写

ASCII码：
大写字母 A - Z 的 ASCII 码范围为 [65,90]：
小写字母 a - z 的 ASCII 码范围为 [97,122]。
语法：
string.toLowerCase()
string.toUpperCase()

4、比较

compareTo(String anotherString)

返回值：

• 负数：当前字符串在字典顺序中位于参数字符串之前。
• 0：两字符串内容完全相同（字典顺序相等）。
• 正数：当前字符串在字典顺序中位于参数字符串之后。

使用 Collections.sort(String s)使用的就是默认的compareTo方法来比较字符串长度和Unicode值

compareToIgnoreCase
忽略大小写的字典顺序比较

equalsIgnoreCase
忽略大小写检查内容是否相同

所以我们可以用如下代码来实现获取最小的字符串的实现：

public class FindMinString {
    public static void main(String[] args) {
        String[] strings = {"banana", "apple", "cherry", "date"};
        
        String minString = "~";  // 使用最大值初始化
        
        for (String s : strings) {
            if (s.compareTo(minString) < 0) {
                minString = s;
            }
        }

        System.out.println("最小的字符串是：" + minString);
    }
}

5、split() 、 join()、去除空格、替换字符

切割字符串

String str = "Hello,world";
String[] s = str.split(",");

连接字符串

String[] s = {"Hello", "World"};
String str = String.join(",", s);

去除字符串首尾的空格

String str = " Hello,world ";
String s = str.trim();

去除字符串的所有空格

String str = " Hello world ";
String s = str.replace(" ","");

字符串的所有数字字符\空白字符替换

String str = " 1Hello2 world3 ";
str = str.replaceAll("\\d", "");
str = str.replaceAll("\\s*", "");

StringBuilder

1、常用操作

增：
append(char c)：在末尾追加
insert(int offset, data)：在指定位置插入数据

删：
deleteCharAt(int index)：删除指定位置的元素
delete(int start, int end)：删除区间 [start, end) 的字符

替换：
replace(int start, int end, String str)：替换区间 [start, end) 为指定字符串

反转：
reverse()：直接反转整个字符串

修改：
setCharAt(int index, char ch)：修改指定位置的字符

转换字符串：
toString()

回溯中涉及到字符串的变更时会使用，sb.append(),在撤销变更时使用sb.deleteCharAt(sb.length()-1)

4、比较

转换为字符串再进行比较

数组

Arrays

主要是针对数组进行的操作，可以类比为针对Collection集合的Collections
详细可见：https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html

1、排序

Arrays.sort()，可见传入的参数有数组、起始索引、结束索引（左闭右开）还有就是 Comparator

其中最重要的就是Comparator的用法，我也是每次写了就忘然后去现查，在此希望做出一个总结：
我们首先要认识的就是 Comparator 的 compare方法，这也是我们去自定义排序的核心方法
如果 o1 < o2 则返回负数，o1 == o2 则返回0， o1 > o2 则返回正数

int compare(T o1,T o2)

这时候我就很迷惑了，返回正数和负数凭什么会影响到升序还是降序呢？
事实上，sort底层源码中解释了：
swap只会在compare返回 > 0 的时候才会执行，也就是说我们只要控制compare的return即可，让我们希望在前面的权重变大。
比如序列是 2 1 我们希望变成 1 2，那我们返回 int1 - int2 就可以了，反之 返回 int2 - int。
对于多维数组和对象依旧如此：

 Arrays.sort(intervals, new Comparator<>(){
            public int compare(int[] intervals1, int[] intervals2){
                return intervals1[0] - intervals2[0];
            }
        });

2、集合数组转换

有时候需要将返回值的类型进行一个转变，就会用到这个方法

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

同理，也有 toArray 这样的方法

list.toArray() //返回Object数组，不能转换为其他类型，不推荐
list.toArray(new int[n][]) //带参并指定数组大小，推荐

注意⭐：不能将List转换为基本类型数组，必须得是引用类型（包装类、int[]等），但是可以使用如下方法：

arr=list.stream().mapToInt(Integer::value0f).toArray();

Arrays和Collections

Arrays

常见操作

public static boolean equals(int[] a, int[] a2)  判断两个数组是否相等
public static String toString(int[] a)                 输出数组信息
public static void fill(int[] a, int val)                 将指定值填充到数组之中
public static void sort(int[] a)                          将数组进行排序
public static int binarySearch(int[] a, int key)  对排序后的数组进行二分法检索指定的值

Collections

排序操作

public static void reverse(List<?> list)                                            反转list中元素的顺序
public static void shuffle(List<?> list)                                              对list集合元素进行随机排序
public static <T extends Comparable<? super T>> void sort(List<T> list)   根据元素的自然排序对指定list集合元素按升序排序
public static <T> void sort(List<T> list, Comparator<? super T> c)  根据指定的comparator产生的顺序对list集合元素进行排序
public static void swap(List<?> list, int i, int j)                                    将指定list集合中的i处元素和j处元素进行交互

查找，替换

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)  根据元素的自然排序，返回给定集合中的最大元素
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)   根据comparator指定的顺序，返回给定集合中的最大元素
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
public static int frequency(Collection<?> c, Object o)                                                         返回指定集合中指定元素的出现次数
public static <T> void copy(List<? super T> dest, List<? extends T> src)
public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)                                 使用新值替换list对象的所有旧值

数组和集合之间相互转换⭐

ArrayList转int数组(stream)

list.stream().mapToInt(Integer::intValue).toArray();

ArrayList转Integer数组(库函数)

list.toArray(new Integer[list.size()]);

list.toArray(Integer[]::new);

HashSet转int数组

set.stream().mapToInt(x -> x).toArray();

数组转ArrayList

// int数组
(ArrayList<Integer>) Arrays.stream(arr).boxed().collect(Collectors.toList());
// Integer数组
(ArrayList<Integer>) Arrays.stream(integers).collect(Collectors.toList());

int数组和Integer数组转换

Arrays.stream(arr).boxed().toArray(Integer[]::new);
Arrays.stream(integers).mapToInt(Integer::intValue).toArray(); 

数组转HashSet

(HashSet<Integer>) Arrays.stream(arr).boxed().collect(Collectors.toSet());
(ArrayList<Integer>) Arrays.stream(integers).collect(Collectors.toSet());

集合和集合之间相互转换⭐

ArrayList转HashSet（stream）

(HashMap<Integer>)list.stream().collect(Collectors.toSet());

HashSet转ArrayList

(ArrayList<Integer>)set.stream().collect(Collectors.toList());

数据结构

栈

1、构造

Deque双向队列

关于为什么实现采用 ArrayDeque，可见【八股学习】Java集合

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

2、方法

	从队头操作	从队尾操作
插入元素（报错）	addFirst(E e)	addLast(E e)
插入元素（返回布尔值）	offerFirst(E e)	offerLast(E e)
删除元素（报错）	removeFirst()	removeLast()
删除元素（空队列返回null）	pollFirst()	pollLast()
获取元素（报错）	getFirst()	getLast()
获取元素（空队列返回null）	peekFirst()	peekLast()

队列

1、构造

Queue与Deque

Queue和Deque，前者时单端队列，遵循FIFO；后者是双端队列，队列两段都可以插入删除元素。

Deque<Integer> queue = new ArrayDeque<>();

PriorityQueue

其默认构造方法为小顶堆，也就是从小到大排序，但是可以接收 Comparator 作为构造参数，来自定义元素优先级。
优先级高的元素先出队

PriorityQueue<Element E> pq = new PriorityQueue<>();

HashMap

merge()

很多时候，我们在计数的时候，需要将hashmap中的value getOrDefault(key, 0)取出来 +1，然后再put回去，十分繁琐，使用merge方法配合 lambda 表达式等可以简化代码。

返回值是经过操作后的value值。

count.merge(c, 1, Integer::sum);

数学算法

最大公约数

private int gcd(int a, int b){
        while(a != 0){
            int tmp = a;
            a = b % a;
            b = tmp;
        }
        return b;
    }