输入输出
Scanner sc = new Scanner(System.in);
String s = sc.next();//字符串
double t = sc.nextDouble(); //浮点数
String s = sc.nextLine();//一行
判断是否有下一个输入，用sc.hasNext()或sc.hasNextInt()或sc.hasNextDouble()或sc.hasNextLine()
//循环输入整数
while(in.hasNextInt()){
int n = sc.nextInt();
}
//循环输入字符
while(in.hasNext()){
}
注意，如果使用nextInt()或next()之后，要用nextLine()，需手动调用.nextLine()吸收掉回车符或空格。但是如果不是交叉使用，比如连续使用next()或next()是可以自动吸收掉空格或回车符的。
nextInt() 只读取整数类型数据，读取完输入后把光标放在同一行该数据的后面。
next() 只读取到空格，不能读取被空格分开的两个单词，读取完后把光标位置同上。
nextLine() 读取整行的数据包括单词间的空格和结束的回车符，读取结束后把光标放在下一行开头。
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
input:
2 3
1 2 3
4 5 6
avd
dvd
abcdf fsfd
output：
123
456
avd
dvd
abcdf fsfd
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
List<List<Integer>> lists = new ArrayList<>();
for(int i=0; i<n; i++){
List<Integer> list = new ArrayList<>();
for(int j=0; j<m; j++){
list.add(sc.nextInt());
}
lists.add(list);
}
String s1 = sc.next();
char[] c = sc.next().toCharArray();
sc.nextLine();//手动 调用.nextLine()越过“/n“
String s2 = sc.nextLine();
//output
for(List<Integer> list:lists){
for(Integer a: list){
System.out.print(a);
}
System.out.println();
}
System.out.println(s1);
System.out.println(c);
System.out.println(s2);
}
}
循环中hasNext()无法结束， 可以在循环中加入break条件，也可以手动设置终止符
//例：以“0”作为终止符
Scanner in = new Scanner(System.in);
while (!in.hasNext("0")) {
System.out.println(in.next());
}
输出
System.out.println();
System.out.printf();
快速查看
最大最小值
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);
char[] c = s.toCharArray();
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<List<Integer>> = new ArrayList<>(); //二维数组
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]