Java 写题常用模板

以下代码均为Java 8 下的结果：

输入输出：

Scanner sc = new Scanner(System.in);

// 多组输入：
while (sc.hasNext()) {
    // 一个或多个空格，分隔字符串，开头有空格不能处理，需特殊处理，java 8 版本,如果输入的一行只有空格的话，s为空
    // 扩展： 如果是要分隔如 . |  符号，后面的参数需要加入转义字符 \\ 即  \\.  \\|
    String[] s = sc.nextLine().split("\\s+");
    int[] n = new int[s.length];
    // 如果第一个前面有空格需要特殊处理
    for (int i = s[0].equals("") ? 1 : 0; i < s.length; i++) {
        n[i] = Integer.valueOf(s[i]);
    }
    // 取数的时候也需要注意，第一个值默认为0，  不可用
    for (int i : n) {
        System.out.println(i);
    }
    // 非nextLine() 后面跟上nextLine() 换行会被nextLine()抵消掉，自己的输入无效，需要再用一个抵消换行符
    // 也可以全用nextLine
    int m = Integer.valueOf(sc.next());
    // 抵消换行符
    sc.nextLine();
    String p = sc.nextLine();
    System.out.println(p);
}



// 输出数组
int[] a = {1, 2, 3};
List<Integer> l = new ArrayList<>();
l.add(1);
l.add(2);
l.add(3);
l.add(4);
System.out.println(Arrays.toString(l.toArray()));
System.out.println();
System.out.println(Arrays.toString(a));

Map<Integer, Integer> tp = new HashMap<>();
tp.put(1, 1);
System.out.println(p.toString());

// 数组c求和，同样还有max，min等函数
int p = Arrays.stream(c).sum();

排序：

List<Integer> p = new ArrayList<>();
p.add(4);
p.add(3);
p.add(1);
p.add(2);
// lambda 表达式 升序排序，逆序反过来就行
Collections.sort(p, (o1, o2) -> o1 - o2);
// 返回值的表达式 和 上面相似
Collections.sort(p, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2;
    }
});
System.out.println(p.toString());
// a为变长数组，不是2 * 5 第一维为 3，第二维为 5
int[][] a = {{3, 1, 2}, {2, 9, 6, 7, 8}};

// 按a的第二列逆序排序，第二列相同按第一列 升序排列
Arrays.sort(a, ((o1, o2) -> o1[1] == o2[1] ? o2[0] - o2[0] : o1[1] - o2[1]));
Arrays.sort(a, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
        if (o1[1] != o2[1]) return o1[1] - o2[1];
        return o1[0] - o2[0];
    }
});
for (int[] i : a) {
    System.out.println(Arrays.toString(i));
}

map操作

// Map 初始化
Map<Integer, Integer> p = new HashMap<Integer, Integer>() {{
    put(1, 1);
    put(-1, 2);
}};

// 排序
List<Map.Entry<Integer, Integer>> t = new ArrayList<>(p.entrySet());
Collections.sort(t, (o1, o2) -> o2.getKey() - o2.getKey());
for (Map.Entry<Integer, Integer> i : t) {
    System.out.printf("%d %d \n", i.getKey(), i.getValue());
}

二分

int[] p = {0, 1, 4, 5};
// 数组用Arrays,List 对应为Collections
// 查找元素在数组中，返回下标（从0 开始），如果查找元素不在数组中，则返回插入的位置，从-1 开始
// -1 表示比所有元素都小
// -(length + 1) 则比所有元素都大
int index = Arrays.binarySearch(p, 0);

// 以下方法皆为数组中不存在key值时进行的操作
// upper_bound: 找到第一个 大于 key 值的下标的方法为：index < 0 , -index - 1 ，如果此时-index - 1 == l.legth，则表示插入值大于数组中所有元素，此时找不到比它大的值
// 找到小于key 值：index < 0, -index - 2 , 如果 -index - 2 < 0，则表示没有小于 key 值的元素

set 集合操作

//set 初始化
Set<Integer> s = new HashSet<Integer>() {{
    add(1);
    add(2);
    add(3);
}};
Set<Integer> st = new HashSet<Integer>() {{
    add(2);
    add(10);
    add(3);
}};

// 初始化
Set<Integer> p = new HashSet<>(s);
// 求交集
p.retainAll(st);
System.out.println(p);
p.clear();

// 初始化
p.addAll(s);
// 求差集  s - st
p.removeAll(st);
System.out.println(p);

String 操作

// 将数字表示的字符转逆序
String s = new StringBuffer(String.valueOf(x)).reverse().toString();
// 将字符串转换为int
return Integer.parseInt(s);
// 字符串求子串,[a,b)
s = s.substring(a,b);
// 将string 中的元素排序
char [] sp = s.toCharArray();
Arrays.sort(sp);
s = String.copyValueOf(sp);


// 当涉及的字符串+= 操作较多时，会变的很耗时间，这个时候用StringBuilder 会比较快，不然容易T
StringBuilder ans = new StringBuilder();
ans.append('a');

输入输出流

// 输入流声明
class InputReader {
    BufferedReader buf;
    StringTokenizer tok;

    InputReader() {
        buf = new BufferedReader(new InputStreamReader(System.in));
    }

    boolean hasNext() {
        while (tok == null || !tok.hasMoreElements()) {
            try {
                tok = new StringTokenizer(buf.readLine());
            } catch (Exception e) {
                return false;
            }
        }
        return true;
    }

    String next() {
        if (hasNext()) return tok.nextToken();
        return null;
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    BigInteger nextBigInteger() {
        return new BigInteger(next());
    }

    BigDecimal nextBigDecimal() {
        return new BigDecimal(next());
    }
}


// 使用
InputReader sc = new InputReader();
PrintWriter out = new PrintWriter(System.out);
int n = sc.nextInt(), m = sc.nextInt();
out.println(s);
// 记得关闭输出流
out.close();