1、Scanner 输入：

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);// 读取整数int num = scanner.nextInt();// 读取一行字符串String line = scanner.nextLine();scanner.close();}
}

2、二进制、八进制、十进制、十六进制

以十进制数42为例十进制：
int decimalNumber = 42;‌二进制：
int binaryNumber = 0b101010; // 以0b或0B作为前缀八进制：
int octalNumber = 052; // 以0作为前缀十六进制：
int hexNumber = 0x2a; // 以0x或0X作为前缀

3、Integer 等包装类

int intValue() 返回Integer对象的int类型值。static int MAX_VALUE int的最大值static int MIN_VALUE int的最小值static int parseInt(String s) 将字符串以十进制解析为int。static int parseInt(String s, int radix) 将字符串以指定进制解析为int。static String toString(int i) 返回int的十进制字符串对象。static String toString(int i, int radix) 返回int的指定进制字符串对象。static Integer valueOf(String s) 将字符串以十进制解析为Integer对象。static Integer valueOf(String s, int radix) 将字符串以指定进制解析为Integer对象。

4、移位运算符

<<：右边用0填充。>>>：左边用0填充。>>：左边用最高位相同的值填充。

5、按位运算符

按位与 &      按位或 |      按位异或 ^      按位非 ~

位值	位值	&	|	^
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0

6、String

常用构造方法:
new String() 创建一个空字符串对象。new String(byte[] bytes, String charsetName) 创建一个由指定字符集解码的字符串对象。new String(char[] value) 创建一个包含字符序列的字符串对象。new String(StringBuilder builder) 创建一个表示builder字符序列的字符串对象。常用API:
char charAt(int index) 返回指定索引处的char。int compareTo(String anotherString) 按字典顺序比较两个字符串。
示例：
"1".compareTo("9") // <0
"1".compareTo("1") // 0
"9".compareTo("1") // >0int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，忽略大小写。boolean	contains(CharSequence s) 当且仅当此字符串包含指定的字符序列时才返回true。boolean	startsWith(String prefix) 测试此字符串是否以指定的前缀开头。boolean	startsWith(String prefix, int toffset) 测试此字符串在指定索引开始的子字符串是否以指定的前缀开头，toffset从0开始。boolean	endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。boolean	equals(Object anObject) 将此字符串与指定对象进行比较。boolean	equalsIgnoreCase(String anotherString) 将此字符串与anotherString比较，忽略大小写。byte[] getBytes(String charsetName) 使用charsetName字符集将此字符串编码为字节序列，将结果存储到新的字节数组中。int indexOf(String str) 返回指定子字符串第一次出现在字符串内的索引。int indexOf(String str, int fromIndex) 返回指定子字符串第一次出现在字符串中的索引，从fromIndex开始搜索，fromIndex从0开始。int lastIndexOf(String str) 返回指定子字符串最后一次出现在字符串中的索引。int lastIndexOf(String str, int fromIndex) 返回指定子字符串最后一次出现在字符串中的索引，从fromIndex开始向后搜索，fromIndex从0开始。int length() 返回此字符串的长度。boolean	matches(String regex) 判定此字符串是否匹配给定的正则表达式regex。String replace(char oldChar, char newChar) 返回用newChar替换了所有oldChar后的字符串。String replaceAll(String regex, String replacement) 返回用replacement替换了所有匹配正则表达式regex子字符串后的字符串。String replaceFirst(String regex, String replacement) 返回用replacement替换了第一个匹配正则表达式regex子字符串后的字符串。String[] split(String regex) 以regex将此字符串进行分割。String substring(int beginIndex) 返回一个从beginIndex开始的子字符串，beginIndex从0开始。String substring(int beginIndex, int endIndex) 返回一个从beginIndex到endIndex的子字符串，beginIndex从0开始。char[] toCharArray() 将此字符串转换为新的字符数组。String toLowerCase() 将字符串所有字符转换为小写。String toUpperCase() 将字符串所有字符转换为大写。String trim() 返回一个删除任何前导和尾随空格的字符串。static String valueOf(int i) 返回int参数的字符串int形式。字符串排序示例：
import java.util.Arrays;public class MainTest {public static void main(String[] args) {String str = "Hello World";char[] charArray = str.toCharArray();Arrays.sort(charArray);String sortedString = new String(charArray);System.out.println(sortedString);  // 输出： HWdellloor}
}字符串统计示例：
import java.util.HashMap;
import java.util.Map;public class MainTest {public static void main(String[] args) {String str = "Hello World";Map<Character, Integer> countMap = new HashMap<>();for (char ch : str.toCharArray()) {countMap.put(ch, countMap.getOrDefault(ch, 0) + 1);}System.out.println(countMap);  // 输出：{ =1, r=1, d=1, e=1, W=1, H=1, l=3, o=2}}
}

7、StringBuilder

常用构造方法:
new StringBuilder() 创建一个初始容量为16个字符的字符串构建器。new StringBuilder(String str) 创建一个初始化为指定字符串内容的字符串构建器。常用API:
StringBuilder append(String str) 将指定的字符串添加到此字符序列末尾。StringBuilder delete(int start, int end) 删除此字符序列从start到end的字符，左闭右开，start从0开始。StringBuilder deleteCharAt(int index) 删除这个字符序列中指定位置的char。StringBuilder insert(int offset, String str) 将str插入到此字符序列指定位置。StringBuilder replace(int start, int end, String str) 将start到end用str替换。StringBuilder reverse() 反转此字符序列。

8、Collection

Collection<E> （I）集合||-- List<E> （I）有序的 Collection （与元素插入顺序一致），也称为序列。|    ||    |-- Stack<E> （C）栈，后进先出。|    ||    |-- ArrayList<E> （C）使用数组实现。|    ||    |-- LinkedList<E> （C）使用双向链表实现。||-- Set<E> （I）不含重复元素的 Collection，最多包含一个 null 元素。|    ||    |-- HashSet<E> （C）无序的，与元素插入顺序无关。|    ||    |-- LinkedHashSet<E> （C）有序的，与元素插入顺序一致。|    ||    |-- TreeSet<E> （C）使用元素的自然顺序排序，或者根据提供的 Comparator 排序。||-- Queue<E> （I）队列，先进先出；从队列尾部添加元素，从队列头部删除元素。|    ||    |-- PriorityQueue<E> （C）优先队列|    ||    |-- LinkedList<E> （C）双向队列，支持在队列两端插入和删除元素。Stack常用API：
boolean empty() 判断栈是否为空。E peek() 返回栈顶对象，而不将其从栈中删除。栈为空抛异常。E pop() 返回栈顶对象，并将其从栈中删除。栈为空抛异常。E push(E item) 将对象添加到栈顶。int search(Object o) 返回对象在此栈上的位置，栈顶为1。ArrayList常用API：
boolean	add(E e) 将指定的元素追加到此列表的末尾。void add(int index, E element) 在此列表中的指定位置插入指定的元素。boolean	addAll(Collection<? extends E> c) 按指定集合中的所有元素追加到此列表的末尾。boolean	addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到此列表中，从指定的位置开始。boolean contains(Object o) 如果此列表包含指定的元素，则返回true。boolean containsAll(Collection<?> c) 如果此集合包含指定集合中的所有元素，则返回true。boolean retainAll(Collection<?> c) 获取两个集合的交集，即只保留原集合与指定集合相同的元素。E set(int index, E element) 用指定的元素替换此列表中指定位置的元素。E remove(int index) 删除该列表中指定位置的元素。boolean remove(Object o) 从列表中删除第一个指定的元素。boolean	removeAll(Collection<?> c) 从此列表中删除指定集合中包含的所有元素。boolean	removeIf(Predicate<? super E> filter) 删除此集合中满足给定谓词的所有元素。
示例：
List<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b");
list.removeIf(x -> x.equals("a")); // [b]protected void removeRange(int fromIndex, int toIndex) 从这个列表中删除所有索引在fromIndex和toIndex之间的元素，左闭右开。public boolean equals(Object o) 比较两个列表是否相等，两个列表都具有相同的大小，并且两个列表中所有相应的元素对相等。void replaceAll(UnaryOperator<E> operator) 对列表的每个元素应用一个函数，并用函数返回的结果替换原值。
示例：
List<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b");
list.replaceAll(x -> x + "x"); // [ax, bx]E get(int index) 返回此列表中指定位置的元素。void clear() 从列表中删除所有元素。boolean	isEmpty() 如果此列表不包含元素，则返回true。int size() 返回此列表中的元素数。Iterator<E> iterator() 返回该列表的迭代器。int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。void sort(Comparator<? super E> c) 使用提供的Comparator对此列表进行排序。Stream<E> stream() 返回此集合的Stream。Object[] toArray() 以正确的顺序返回一个包含此列表中所有元素的数组。<T> T[]	toArray(T[] a) 以正确的顺序返回一个包含此列表中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
示例：
List<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b");
String[] arr = list.toArray(new String[0]); // [a, b]LinkedList常用API:
void push(E e) 将元素添加到列表头部。E peek() 返回列表头部元素，并不删除；如果没有元素返回null。E poll() 返回并删除列表头部元素；如果没有元素返回null。boolean	offer(E e) 将指定的元素添加到此列表的尾部，添加成功返回true，失败返回false。PriorityQueue:
PriorityQueue() 创建一个初始容量为11的优先队列。PriorityQueue(Comparator<? super E> comparator) 创建一个初始容量为11的优先队列，并且其元素根据指定的比较器进行排序。常用API：
boolean add(E e) 将指定的元素插入此优先级队列。void clear() 从这个优先级队列中移除所有元素。boolean contains(Object o) 如果此队列包含指定的元素，则返回true。boolean containsAll(Collection<?> c) 如果此集合包含指定集合中的所有元素，则返回true。Iterator<E> iterator() 返回此队列中元素的迭代器。E peek() 返回列表头部元素，并不删除；如果没有元素返回null。E poll() 返回并删除列表头部元素；如果没有元素返回null。boolean remove(Object o) 从队列中删除一个指定元素（如果存在）。Object[] toArray() 以正确的顺序返回一个包含此列表中所有元素的数组。<T> T[] toArray(T[] a) 以正确的顺序返回一个包含此列表中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
示例：
PriorityQueue<String> priorityQueue = new PriorityQueue();
Collections.addAll(priorityQueue, "c", "a", "b");
String[] arr = priorityQueue.toArray(new String[0]); // [a, c, b]

9、Map

Map<K,V> （I）键值对(key-value)。||-- HashMap<K,V> （C）最多只允许一条记录的 key 为 null；无序的，与元素插入顺序无关。||-- LinkedHashMap<K,V> （C）有序的，与元素插入顺序一致。  ||-- TreeMap<K,V> （C）最多只允许一条记录的 key 为 null；根据key的自然顺序排序，或者根据提供的 Comparator 排序。HashMap常用API：
void clear() 删除所有键值对。boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回true。boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回true。boolean equals(Object o) 将指定的对象与此映射进行比较。 void forEach(BiConsumer<? super K,? super V> action) 对此映射中的每个键值执行给定的操作，直到所有条目都被处理或操作引发异常。
示例：
HashMap<String, String> hashMap = new HashMap();
hashMap.put("a","aa");
hashMap.put("b","bb");
hashMap.forEach((x, y) -> System.out.println(x + "->" + y));  // a->aa  b->bbV get(Object key) 返回指定键所映射的值，如果没有则返回null。boolean	isEmpty() 如果此映射不包含键值对，则返回true。int size() 返回此映射中键值对的数量。Set<K> keySet() 返回此映射中包含的键的Set集合。Collection<V> values() 返回此映射中包含的值的Collection列表。V put(K key, V value) 新增键值对。void putAll(Map<? extends K,? extends V> m) 添加映射m，如果有相同的键值对替换原键值对。V putIfAbsent(K key, V value) 如何不存在的key才新增，避免替换原键值对。V remove(Object key) 从该映射中删除指定键的映射（如果存在）。boolean remove(Object key, Object value) 仅当与指定键值对相等时才删除。boolean	replace(K key, V oldValue, V newValue) 仅当key-oldValue存在，才能用newValue替换oldValue。void replaceAll(BiFunction<? super K,? super V,? extends V> function) 将键值对的值替换为对该键值对调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
示例：
Map<String, String> map = new HashMap<>();
map.put("a", "b");
map.replaceAll((k,v) -> v.concat("d"));
System.out.println(map); // {a=bd}V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) 如果key存在，则计算后更新value；如果key不存在，则将key-value插入。
示例：
Map<String, String> map = new HashMap<>();
map.put("a", "b");
map.compute("a", (k,v) -> v.concat("d"));
System.out.println(map); // {a=bd}Map<String, String> map = new HashMap<>();
map.compute("a", (k,v) -> "d");
System.out.println(map); // {a=d}；这里不能 v.concat("d")，会报空指针异常。V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) 如果key不存在才会执行函数，并将结果插入。V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) 如果key存在才会执行函数，并用结果替换原value。
如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。V getOrDefault(Object key, V defaultValue) 如何存在key，返回对于value；如果不存在key，返回后面的默认值。
示例：
List<String> list = new ArrayList<>();
Collections.addAll(list, "wang1", "wang3");Map<String, List<String>> map = new HashMap<>();
map.put("wang", list);list = map.getOrDefault("wang", new ArrayList<String>());
System.out.println(list); // [wang1, wang3]list = map.getOrDefault("zhang", new ArrayList<String>());
System.out.println(list); // []

10、Iterator迭代器

定义：
public interface Iterator<E> 对 collection 进行迭代的迭代器。API：
boolean hasNext() 如果仍有元素可以迭代，则返回 true。E next() 返回迭代的下一个元素。 void remove() 从集合中删除迭代器最后访问的元素（可选操作）。 

11、Comparator比较器

定义：
public interface Comparator<T> 强制对某些对象集合进行总排序的比较函数。API：
int compare(T o1, T o2) 比较用来排序的两个参数。 注：o1 - o2 是升序。boolean equals(Object obj) 指示某个其他对象是否“等于”此 Comparator。 示例：
List<Integer> list = new ArrayList<>();
Collections.addAll(list, 3, 2, 1);
Collections.sort(list, (o1, o2) -> o1 - o2);
System.out.println(list); // [1, 2, 3]

12、Collections类

boolean Collections.addAll(Collection<? super T> c, T... elements) 将多个元素添加到集合中，每个元素用逗号隔开。 boolean Collections.disjoint(Collection<?> c1, Collection<?> c2) 判定两个集合没有相同的元素，没有相同元素返回true，有相同元素返回false。void Collections.fill(List<? super T> list, T obj) 使用指定元素替换list中的所有元素，有元素才会替换。static int frequency(Collection<?> c, Object o) 返回集合中指定元素出现的次数。 void Collections.sort(List<T> list) 根据元素的自然顺序对指定列表按升序进行排序。 void Collections.sort(List<T> list, Comparator<? super T> c) 根据指定的比较器对指定列表进行排序。 T Collections.max(Collection<? extends T> coll) 根据元素的自然顺序，返回给定 coll 的最大元素。 T Collections.max(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定比较器比较，返回给定 coll 的最大元素。 T Collections.min(Collection<? extends T> coll) 根据元素的自然顺序 返回给定 coll 的最小元素。 T Collections.min(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定比较器比较，返回给定 coll 的最小元素。 boolean Collections.replaceAll(List<T> list, T oldVal, T newVal) 使用newVal值替换列表中出现的所有oldVal值。 void Collections.reverse(List<?> list) 反转指定列表中元素的顺序。 void swap(List<?> list, int i, int j) 交换指定元素在列表中的位置。

13、Arrays类

int[] Arrays.copyOf(int[] original, int newLength) 返回指定长度为newLength的数组，它的前newLength个元素为数组original的前newLength个元素，如果超出数组original的长度则用0填充。int[] Arrays.copyOfRange(int[] original, int from, int to) 返回将指定数组的指定范围复制到新数组中。boolean Arrays.equals(int[] a, int[] a2) 如果指定的两个int数组每个元素都相等，则返回true。boolean Arrays.deepEquals(Object[] a1, Object[] a2) 如果指定的两个多维数组每个元素都相等，则返回true。static void fill(int[] a, int val) 用指定int值替换数组中的每一个元素。static void fill(int[] a, int fromIndex, int toIndex, int val) 用指定int值替换数组中的从fromIndex到toIndex的元素。String Arrays.toString(int[] a) 返回指定数组内容的字符串表示形式。String Arrays.deepToString(Object[] a) 返回指定多维数组内容的字符串表示形式。void Arrays.sort(int[] a) 按照自然顺序排列数组。void Arrays.sort(int[] a, int fromIndex, int toIndex) 按自然顺序排列数组的指定范围。void Arrays.sort(T[] a, Comparator<? super T> c) 根据指定的比较器对指定的对象数组进行排序。
只能用于对象数组排序，不能用于基本数据类型。Arrays.sort(a, (x, y) -> x.compareTo(y)) 升序。void Arrays.sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) 根据指定的比较器对指定的对象数组的指定范围进行排序。
只能用于对象数组排序。Stream<T> Arrays.stream(T[] array) 返回array的Stream流。

14、Math常用API

static int abs(int a) 返回int值的绝对值。static int max(int a, int b) 返回两个值中的较大者。static int min(int a, int b) 返回两个值中的较小者。