算法题中常用的工具类的方法（Java）

在算法题中，经常要用到一些工具类的帮助，在此把常用的工具类方法作以总结。

String 类

• 创建

String s1 = "Runoob";              // String 直接创建
String s2 = new String("Runoob");   // String 对象创建

• String 类是不可改变的。如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。
• 字符串长度：int len = str.length();
• 连接字符串
  • concat() 方法：string1.concat(string2);
  • 使用’+'操作符："Hello," + " java" + "!"

方法	描述
char charAt(int index)	返回索引处的 char 值
int compareTo(Object o)	把这个字符串和另一个对象比较
int compareTo(String anotherString)	按字典顺序比较两个字符串
String concat(String str)	字符串连接到此字符串的结尾
static String copyValueOf(char[] data, int offset, int count)	复制char[] data，开始下标，复制的个数
boolean equals(Object anObject)	字符串比较
int hashCode()	字符串的哈希码
int indexOf(int ch)	字符在字符串中第一次出现的索引
int indexOf(String str)	子字符串在字符串中第一次出现的索引
String replace(char oldChar, char newChar)	返回一个新的字符串，把所有的 oldChar 替换为 newChar
String[] split(String regex)	根据给定正则表达式的匹配拆分此字符串。
String substring(int beginIndex, int endIndex)	返回一个新字符串，[beginIndex, endIndex)，半闭半开
char[] toCharArray()	字符串转换为字符数组
String trim()	返回字符串的副本，忽略前导空白和尾部空白
contains(CharSequence chars)	判断是否包含指定的字符
isEmpty()	判断字符串是否为空

• String字符串 转化 数字 （“123” --> 123）

String s = "123";
int num = Integer.parseInt(str);  123
int num = Integer.valueOf(str);   123
float num =  Float.parseFloat(s); 123.0

StringBuffer 和 StringBuilder 类

• StringBuffer 类，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
• StringBuilder 类在 Java 5 中被提出， StringBuilder 的方法不是线程安全的（不能同步访问）。
• 由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

StringBuffer sb = new StringBuffer(10); // 长度为10
sb.append("java"); // 追加
sb.insert(2,"abc!"); // 插入
sb.delete(2,5); // 指定下标删除
sb.reverse(); // 字符串反转

方法	描述
char charAt(int index)	返回序列索引处的 char 值
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)	将字符从此序列复制到目标字符数组 dst
int indexOf(String str)	str 第一次出现在该字符串中的索引
int indexOf(String str, int fromIndex)	从指定的索引处开始，str 第一次出现在该字符串中的索引
int length()	返回长度（字符数)
void setCharAt(int index, char ch)	将索引处的字符设置为 ch
String substring(int start)	新的 String，从 start 下标到结尾
String substring(int start, int end)	新的 String，[start, end)，半闭半开

Arrays 类

• java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

描述	方法
给数组赋值	fill(int[] a, int val)
对数组排序	sort(Object[] a)，按升序
比较数组	equals(long[] a, long[] a2)，比较数组中元素值是否相等
查找数组元素	binarySearch(Object[] a, Object key)，能对排序好的数组进行二分查找，返回索引
数组转换为字符串	toString(Object[] arr);

int array[] = new int[6];
Arrays.fill(array, 100); // 把 array[] 中的元素都赋值为 100


Object ob[] = {7, 11, 4, 36, 6};
Arrays.sort(ob); // 排序后为：4, 6, 7, 11, 36
Arrays.binarySearch(ob, 6), // 返回 6 的索引：1

long[] arr1 = new long[] { 150, 123, 12, 45, 54, 67, 78 };
long[] arr2 = new long[] { 150, 123, 12, 45, 54, 67, 78 };
boolean res = Arrays.equals(arr1, arr2); // 比较是否相等

int[] arr ={1,2,3,4,5};
System.out.println(arr.toString()); //输出[I@5e507d25]

String arrString = Arrays.toString(arr); // 转为字符串
System.out.println(arrString); //输出[1, 2, 3, 4, 5]

Collections 类

• 排序操作

void reverse(List list)//反转
void shuffle(List list)//随机排序
void sort(List list)//按自然排序的升序排序
void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
void swap(List list, int i , int j)//交换两个索引位置的元素
//旋转。当distance为正数时，将list后distance个元素整体移到前面。
//当distance为负数时，将 list的前distance个元素整体移到后面
void rotate(List list, int distance)

• 查找，替换操作

int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的
int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素
int frequency(Collection c, Object o)//统计元素出现次数
int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target)
boolean replaceAll(List list, Object oldVal, Object newVal)//用新元素替换旧元素

集合的相关操作

• 集合转 Map ---- Collectors.toMap()

// 1. 原始方法：把User集合转成key ->id ,value->User对象的map
List<User> list = new ArrayList<>();
list.add(new User(1,"a"));
list.add(new User(2,"b"));
HashMap<Integer, User> map = new HashMap<>();
for (User u:list) {
    map.put(u.getId(),u);
}
// 2. stream流式操作
HashMap<Integer, User> map1 = list.stream().
collect(HashMap::new, (m, v) -> m.put(v.getId(), v), HashMap::putAll);
// 3. stream流简化操作（推荐）
Map<Integer, User> map2 = list.stream().
collect(Collectors.toMap(User::getId, Function.identity()));

• 集合转数组 ---- .toArray()

List<String>  stringList = new ArrayList<>();
stringList2.add("A");
stringList2.add("B");
stringList2.add("C");

如果参数 T[] arr 传入到方法，则返回 T 类型的数组。
String[] arr = stringList.toArray(new String[stringList.size()]);  #常用#
如果未传入参数，则返回 Object 类型的数组。
Object[] objectArray  = stringList.toArray();

• 数组转集合 ---- Arrays.asList()

int arrs[] = {1, 2};
// 1. 遍历，最常用的方法，但是过程会繁琐一点
List<Integer> list = new ArrayList<>();
for (int ele : arrs) {
    list.add(ele);
}
// 2. 使用数组工具类的 asList()方法
String[] myArray = {"Apple", "Banana", "Orange"};
List<String> myList = Arrays.asList(myArray);
//上面两个语句等价于下面一条语句
List<String> myList = Arrays.asList("Apple","Banana", "Orange");

• List 转 String： String.join()方法

List<String> list = new ArrayList<>();
list.add("abc");//String类型
list.add("bbb");
list.add("def");

String s = String.join("", list);   abcbbbdef
String s = String.join(".", list);  abc.bbb.def

参考：Java菜鸟教程，JavaGuide