以下代码均为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();