Java刷題常用API
阿新 • • 發佈：2020-08-13
目錄
快速檢視
最大最小值
fmax = Float.MAX_VALUE;
fmin = Float.MIN_VALUE;
dmax = Double.MAX_VALUE;
dmin = Double.MIN_VALUE;
bmax = Byte.MAX_VALUE;
bmin = Byte.MIN_VALUE;
cmax = Character.MAX_VALUE;
cmin = Character.MIN_VALUE;
shmax = Short.MAX_VALUE;
shmin = Short.MIN_VALUE;
imax = Integer.MAX_VALUE;
imin = Integer.MIN_VALUE;
lmax = Long.MAX_VALUE;
lmin = Long.MIN_VALUE;
string
不可變數, 每個位置元素是個char
初始化
String s = "abc"; s = "abc" String s2 = new String(s); s = "abc"; char[] c = s.toCharArray(); String s3 = new String(c); String s4 = new String(c, 1, 3); // [offset, offset + count) [)
String.valueOf( 一個引數Object/基本資料型別 ) 返回傳入引數obj的toString(),若為空返回字串"null"。 若為基本型別呼叫其 包裝類的toString方法（Integer.toString(i)）
char[] ch = {'a', 'b', 'c'};
String s5 = String.valueOf(ch);//char陣列轉換成string
方法: charAt, length, substring, equals, indexOf, lastIndexOf, replace, toCharArray, trim, split, toLowerCase, toUpperCase
.substring(int beginIndex, int endIndex); // 返回字元片段[beginIndex, endIndex) --- O(n)
.substring(int beginIndex); // 返回字元片段[beginIndex, end_of_String) 就是從beginIndex開始後面的 ---- O(n)
//indexOf 是（暴力查詢字串，不是KMP）
.indexOf(String str) // 返回str第一個出現的位置(int)，沒找到則返回-1。 --- O(m * n) m為原串長度， n為str長度
s.indexOf(String str, int fromIndex); // 同上，但從fromIndex開始找 --- O(m * n)
.lastIndexOf(String str); // 返回str最後出現的位置(int)，沒找到則返回-1。 --- O(m * n) m為原串長度， n為str長度
// (假如要找一個字元char c，str可以表示成String.valueOf(c),然後作為引數傳進去.
.lastIndexOf(String str, int fromIndex); //從fromIndex開始從後往前找 [0 <- fromIndex] --- O(m * n)
.replace(char oldChar, char newChar); // 返回一個新字串String，其oldChar全部變成newChar --- O(n)
replaceAll(String s1,String s2);//用s2替換目標字串中出現的所有s1
replaceFirst(String s1,String s2);//用s2替換目標字串中出現的第一個s1
.toCharArray(); // 返回char[] 陣列。 把String轉換成字元陣列 --- O(n)
.trim(); // 返回去除前後空格的新字串 --- O(n)
.split(String regex); // 返回 String[]，以regex(正則表示式)拆分 ---- O(n)
// 從非"/"算起 若"/a/c" -> 會變成"" "a" "c"
String[] date = str.split("/"); // date[0]:1995 date[1]:12 date[2]:18 --- O(n)
//轉換大小寫
s = s.toLowerCase(); // 返回一個新的字串全部轉成小寫 --- O(n)
s = s.toUpperCase(); // 返回一個新的字串全部轉成大寫 --- O(n)
string的比較
compareTo(String anotherString)//按字典順序比較兩個字串
compareToIgnoreCase(String anotherString)//按字典順序且不區分大小寫比較兩個字串
equals(String anotherString)//判斷兩個字串是否相等，相等返回true否則返回false
equalsIgnoreCase(String str)//同上，不區分大小寫。
如果a > b 返回大於0的整數， 如果a == b 返回0， 如果a < b 返回小於0的整數
其實是返回a和b第一個不同字元的差值。
搜尋子串
indexOf(String str);//返回子串在此字串中第一次出現的索引
indexOf(String str, int fromindex);//同上，從指定索引開始搜尋
lastIndexOf(int ch);//返回指定字元在此字串最後一次出現的索引
lastIndexOf(int ch, int fromindex);//同上， 從指定索引開始搜尋
lastIndexOf(String str);//返回子串在此字串最後一次出現的索引
lastIndexOf(String str, int fromindex);//同上， 從指定索引開始搜尋
startsWith(String prefix);// 檢查是否以某一字首開始
其他型別轉換為string
String.valueOf(char[] data);//返回 char陣列的字串表示形式
String.valueOf(char[] data,int offset, int count)//返回 char 陣列引數的特定子陣列的字串表示形式
String.valueOf(int i);//返回 int 引數的字串表示形式
string轉換為其他型別
String sInt = "123";
int s = Integer.parseInt(sInt);
long ls = Long.parseLong(sInt);
stringbuilder
非執行緒安全
方法: append, charAt, length, setCharAt, insert, deleteCharAt, delete, reverse, toString
StringBuilder sb = new StringBuilder();
StringBuilder sb = StringBuilder(String str);//構建一個值為str的可變字串。
.setCharAt(int index, char ch); // 設定index位置的char為ch --- O(1)
.insert(int offset, String str); // 在offer位置的插入字串str--- O(m + n)
.deleteCharAt(int index); // 刪除index位置的char --- O(n)
.deleteCharAt(sb.length() - 1); // 刪除最後一個char --- O(1)
.delete(int start, int end); // 刪除[start, end)位置的char --- O(n)
.delete(int start, int end);//移除此序列從start到end-1的字串
.reverse(); // 反轉快取字串 --- O(n)
.toString(); // 返回一個與構建起或緩衝器內容相同的字串 --- O(n)
append(String str);//在此字串追加str。
append(StringBuilder str);//在此字串追加str。
append(char[] str, int offset, int len);//將char的子陣列追加到此字串
查詢
indexOf(String str);//返回子字串第一次出現的索引
indexOf(String str, int fromIndex);//同上，從指定位置查詢
lastIndexOf(String str);//返回子字串最後一次出現的索引
lastIndexOf(String str, int fromIndex);//同上，從指定位置查詢
集合遍歷
map
方法：put, get, getOrDefault, containsKey, containsValue, keySet, values, isEmpty, size
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class TestMap {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "a");
map.put("2", "b");
map.put("3", "c");
//最簡潔、最通用的遍歷方式
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + " = " + entry.getValue());
}
//.keySet(); // 返回一個Set,這個Set中包含Map中所有的Key --- O(1)
for (Character key : map.keySet()) {
// Operate with each key
}
//.values(); // 返回一個Collection<v>,裡面全是對應的每一個value --- O(1)
for (Integer value : map.values()) {
// Operate with each values
}
}
}
queue
方法：offer, poll, peek, isEmpty, size
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
public class TestQueue {
public static void main(String[] args) {
Queue<Integer> q = new LinkedBlockingQueue<Integer>(); //初始化
//把把集合如Stack、Set、List等Collection作為引數
Set<Integer> s = new HashSet<>();
Queue<Integer> q = new LinkedList<>(s);
//初始化佇列
for (int i = 0; i < 5; i++) {
q.offer(i); //入隊
}
System.out.println("-------1-----");
//集合方式遍歷，元素不會被移除
for (Integer x : q) {
System.out.println(x);
}
System.out.println("-------2-----");
//佇列方式遍歷，元素逐個被移除
while (q.peek() != null) {
System.out.println(q.poll()); //出隊
}
}
}
stack
方法：push, pop, peek, isEmpty, size
import java.util.Stack;
public class TestStack {
public static void main(String[] args) {
Stack<Integer> s = new Stack<Integer>();//初始化
for (int i = 0; i < 10; i++) {
s.push(i); //入棧
}
//集合遍歷方式
for (Integer x : s) {
System.out.println(x);
}
System.out.println("------1-----");
//棧彈出遍歷方式
// while (s.peek()!=null) { //不健壯的判斷方式，容易拋異常，正確寫法是下面的
while (!s.isEmpty()) {
System.out.println(s.pop()); //出棧
}
System.out.println("------2-----");
//錯誤的遍歷方式
// for (Integer x : s) {
// System.out.println(s.pop());
// }
}
}
set
初始化
Set<Integer> set = new HashSet<>();
//把集合如Stack、Queue、List等Collection作為引數
List<Integer> list = new ArrayList<>....;
Set<Integer> set = new HashSet<>(list);
方法：add, remove, contains, isEmpty, size
優先佇列 PriorityQueue (Heap)
底層是一顆數， 以小根堆為例。
初始化
//小根堆
Queue<Integer> minH = new PriorityQueue<>(); // 小根堆，預設大小為11 相當於 new PriorityQueue<>(11)
Queue<Integer> minH = new PriorityQueue<>(100); // 定義一個預設容量有100的小根堆。在當中增加元素會擴容，只是開始指定大小。不是size，是capacity
//大根堆
Queue<Integer> maxH = new PriorityQueue<>((i1, i2) -> i2 - i1); // 大根堆，預設大小為11 相當於 new PriorityQueue<>(11, (i1, i2) -> i2 - i1)
Queue<Integer> maxH = new PriorityQueue<>(100, (i1, i2) -> i2 - i1); // 定義一個預設容量有100的大根堆。在當中增加元素會擴容，只是開始指定大小
方法：offer, poll, peek, isEmpty, size
陣列
靜態陣列
//一維
String[] s = new String[3];
char[] b = new char[]{'a', 'b'};
//二維
// 二維
int[][] c = new int[10][10];
.length 記得是屬性而不是方法 arr.length 沒有()
Arrays.sort從小到大排序
Arrays.sort(int[] arr) //從小到大排序
Arrays.sort(int[] arr, int fromIndex, int toIndex) // [)
Arrays.sort(int[] arr, int fromIndex, int toIndex, 比較器); //一定是需要泛型
Arrays.sort(arr, (o1, o2) -> o2 - o1); //陣列全部 從大到小排序 跟Collections.sort()一樣
Arrays.sort(arr, 0, 3, (o1, o2) -> o2 - o1); //從大到小排序，只排序[0, 3)
Arrays.fill填滿一個數組
int[] a = new int[5];
Arrays.fill(a, ``1``);
Arrays.copyOf / arr.clone()複製一個數組(二維陣列也可以)
int``[] a = ``new` `int``[``5``];
int``[] newA = Array.copyOf(a, ``5``);
// or
int``[][] a = {{``1``}, {``1``,``2``}, {``1``,``2``,``3``}, {``1``,``2``,``3``,``4``}, {``1``,``2``,``3``,``4``,``5``}}; ``// 不是5*5，第一維1 2 3 4 5
int``[][] newa = a.clone(); ``// 不是5*5矩陣
相等比較
System.out.println(Arrays.equals(arr1,arr2))
arr1.equals(arr2)比較的是兩個物件的地址，不是裡面的數，而Arrays.equals重寫了equals，所以，這裡能比較元素是否相等。
二分查詢法找指定元素的索引值（下標）
int []arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 20));//找不到的話返回-x
擷取陣列：copeOf和copeOfRange
int []arr = {10,20,30,40,50};
int []arr1 = Arrays.copyOf(arr, 3);//擷取arr陣列的3個元素賦值給姓陣列arr1 10 20 30
int []arr = {10,20,30,40,50};
int []arr1 = Arrays.copyOfRange(arr,1,3);// [) 10 20
動態陣列
List<Integer> array = new ArrayList<>(); // 陣列
List<Integer> list = new LinkedList<>(); // 連結串列
List介面方法:get, size, add, remove, subList
.get(int index)
.size()
.add(E e) // 在尾部新增一個元素e --- O(1)
.add(int index, E e) // 在index位置插一個元素e --- O(n)
.remove(int index) // 刪除位於index的元素，並返回刪除元素e
list.remove(list.size() - 1);
.subList(int from, int to) // 相當於返回原陣列的一個片段,但不要對其進行改動，改動會影響原陣列
Collections.sort(list); 從小到大排序
Collections.sort(list, (o1, o2) -> o2 - o1); 從大到小排序， 第二個引數為一個比較器
Math
Math.max(long a, long b)
Math.sqrt(double a)
Math.abs(double a) //返回一個型別和引數型別一致的絕對值
Math.pow(double a, double b)
取整
Math.ceil(double x);//向上取整
Math.floor(double x);//向下取整
Math.round(double x);//四捨五入
隨機數，生成一個[0,1)之間的double型別的偽隨機數
Math.random()
int a = (int)(Math.random()*b + 1); // [1, b]
int a = (int)(Math.random()*(b - a + 1) + a); //[a, b]