基本输入输出

一般数据量$<10^5$,不会超时

import java.util.Scanner;

Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
    ...
}
int i = sc.nextInt();
float f = sc.nextFloat();
double d = sc.nextDouble();
String s = sc.next();
String s = " " + sc.next(); // 下标从1开始的字符串 
String s = sc.nextLine();

System.out.println()

注意nextLine()时的位置，读入下一行时可能需要额外调用一次

一直读入到文件末尾可以采用while(sc.hasNext()){... sc.next() ...}或者while(sc.hasNextLine()){... sc.nextLine() ...}注意不能混用

快速输入输出

import java.io.*;

public static void main(Stirng[] args) throws IOException {
    BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(System.out));
    Stirng[] strs = re.readLine().trim("\\s+");
    ...
    wr.write(a + ""); // 保证写入数据必须为字符串

    wr.flush()
}

注意当外部函数使用输入输出时，需要定义BufferedReader BufferedWriter为static，并对函数添加throws IOException

数据转换

字符串与基本数据类型

int i = Integer.parseInt();
double d = Double.parseDouble();

String s = "" + i;

字符串与字符数组

char[] s = str.toCharArray();
String str = new String(s);

大小

// 数组
int a[] = {1, 2, 3};
int size = a.length;
// 字符串
String str = "123";
int size  = str.length();
// 集合
List<Integer> list = new ArrayList<Integer>();
list.add(1);
int size = list.size();

复制

int[] t = Arrays.copyOf(a, size);
List<Integer> t = new ArrayList<>(a);

工具函数

// 排序
Collections.sort(list, comparator);
Arrays.sort(list, fromIndex, toIndex); // [fromIndex, toIndex)
// 翻转
Collections.reverse(list);

String

String str = new String(s);
str.length();
str.charAt(index);
str.equals(str2);
str.indexOf(cha); // 查找字符
str.indexOf(str2); // 查找子串
str.substring(start, end); // 返回子串[start, end)

StringBuilder

StringBuilder str = new StringBuilder(s);
str.length();
str.toString();
str.charAt(index);
str.append(char | char[] | String | int ...);
str.insert(offset, char | char[] | String ...) // 在offset之前插入，[0, length()]
str.replace(start, end, str) // [start, end)
str.delete(start, end) // [start, end)
str.deleteCharAt(index)
str.reverse();
str.substring(start, end); // [start, end)

List

ArrayList<Integer>[] edges = new ArrayList[N]; // 链表的数组
List<T> list = new ArrayList<>(); // 变长数组，倍增大小
List<T> list = new LinkedList<>(); // 链表
list.size();
list.isEmpty();
list.add(e);
list.get(e);
list.remove(e);
list.indexOf(e) // 查找第一次元素e出现的下标，未找到返回-1
list.toArray();

Stack

Stack<T> stack = new Stack<>();
stack.size();
stack.isEmpty();
stack.clear();
stack.peek(); // 返回栈顶
stack.pop();  // 删除并返回栈顶
stack.push(e); // 入栈

Queue

注意：
删除队列中的任意元素时，通常使用标记删除的方法
直接修改有限队列的元素，无法触发队列进行调整，必须删除后重新插入

Queue<T> queue = new ArrayDeque<>(); // 变长数组，倍增
Queue<T> queue = new PriorityQueue<>(); // 优先队列,默认小根堆
Queue<T> queue = new PriorityQueue<>((o1, o2) -> o2 - o1); // 定义compartor, 大根堆
queue.size();
queue.isEmpty();
queue.peek(); // 返回队头
queue.poll(); // 删除并返回队头
queue.offer(e); // 插入元素

Deque

Deque<T> deque = new ArrayDeque<>();
Deque<T> deque = new LinkedList<>();
deque.size();
deque.isEmpty();
deque.offerFirst();
deque.offerLast();
deque.peekFirst();
deque.peekLast();
deque.pollFirst();
deque.pollLast();

Set

Set<T> set = new HashSet<>(); // unordered
Set<T> set = new TreeSet<>(); // ordered
set.size();
set.isEmpty();
set.add(e);
set.remove(e)
set.contains(e);
// TreeSet 特有
set.first();
set.last();
set.pollFirst();
set.pollLast();
v = set.floor(x); // <=
v = set.ceiling(x); // >=
v = set.floor(x); // <
v = set.higher(x); // >

Map

Map<T> map = new HashMap<>(); // unordered
Map<T> map = new TreeMap<>(); // ordered
map.size();
map.isEmpty();
map.put(key, value);
map.putIfAbsent(key, value);
map.get(key);
map.getOrDefault(key, value) // 当key不存在时，返回value
map.containsKey(key);
for (Map.Entry<Integer, Long> e : map.entrySet()) { ... }
for (Integer key : map.KeySet()) { ... }
for (Integer value : map.values())

BitSet

BitSet bitSet = new BitSet<>();
bitSet.set(index, value); // value默认为1
bitSet.valueOf(index);
bitSet.cardinality();// 返回有多少个1 
bitSet.isEmpty(); // 返回是否有1
bitSet.flip(index); // 取反
bitSet.and(set);
bitSet.or(set);
bitSet.xor(set);
bitSet.clear(); // 全部取0
bitSet.intersects(set);  // 返回是否相同