牛客网
输入
1.sc.haxNext()不是必须要加的
while(sc.hasNext()){
//核心代码
}这句话可以让你一直输入，输入都行，不会因为回车就结束，一般情况下可以不加它，因为题目一般会告诉你有几组数据，外面套个while循环就好。
机考测试的数据是一次性全部放入控制台，如果没说几组数据，可以加sc.hasNext()
如果样例过了，但测试用例没过或之过了一部分，先去检查代码，基本就是代码问题，逻辑问题或者有bug
如果要说了以某个字符终止输入，那么就把这个输入放到（）里面，用双引号包括。
public class StandardInput {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<Integer> list = new ArrayList<>();
while(!sc.hasNext("#")){
int a = sc.nextInt();
list.add(a);
}
System.out.println(list);
}
}输出：
1 2 3 4 5 6 #
[1, 2, 3, 4, 5, 6]2.牛客网接受控制台输入
next()和nextInt()方法读取到任意间隔符（如空格和回车）就结束，nextLine()读取到回车结束也就是“\r”，next()返回值为String类型，nextLine()返回值为String类型，nextInt()返回值为Int类型。
nextInt()返回的是int型,next()返回String。二者特点很相似
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。
//-----------------------------------------
nextLong()、nextDouble()是一样的道理nextLine()：
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。也可以全部用naxtLine()，不过数字型需要转一下
1.读取单个整数，字符串数字转int数字，int转String
// 读取单个整数，字符串数字转int数字
int n = Integer.parseInt(sc.nextLine());
// int转String
int i=3；
String s=Integer.toString(i);
2.读取一行整数，以空格分开
// 读取一行整数，以空格分开
String[] s = sc.nextLine().split(" ");
int[] num = new int[s.length];
for(int i=0;i<s.length;i++){
num[i] = Integer.parseInt(s[i]);
System.out.println(num[i]);
}3.单个char数字转int数字,减去’0’
// 单个char数字转int数字,减去'0'
res[i][j] = c-'0';4.遍历字符串的每个字符，charAt(i)
// 遍历字符串的每个字符，charAt(i)
for(int i=0;i<s.length();i++){
System.out.println(s.charAt(i));
}输出
数组输出
Arrays.toString（）
这个方法是是用来将数组转换成String类型输出的，入参可以是long，float，double，int，boolean，byte，object型的数组。
如果直接i.toString()则是输出地址值
四舍五入输出
//保留4位小数的输出
double f = 3.1415926;
System.out.println(String.format("%.4f",f));暴力遍历
暴力有时候是一种直接明了的方法，比如三数之和，四数之和。在没有掌握到好的办法之前，暴力是一个选择。几个的遍历略有区别，需要注意。
1.二维数组
for(int i=0;i<num.length;i++){
for (int j=0;j<num[0].length;j++){
}
}2.数组任意两个不同的数相加
注意，i只能到倒数第二位，因为j=i+1
for(int i=0;i<num.length-1;i++){
for (int j=i+1;j<num.length;j++){
int sum = num[i]+num[j];
}
}3.数组任意三个不同的数相加
for(int i=0;i<num.length-2;i++){
for (int j=i+1;j<num.length-1;j++){
for (int k=j+1;j<num.length;k++){
int sum = num[i]+num[j]+num[k];
}
}
}Collections.sort() 多重条件排序
package sort;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 排序规则，按照年龄排序，若年龄相同，按照工资排序，若工资相同，按照身高排序
* @author Administrator
*
*/
public class TestObjectSort {
public static void main(String[] args) {
List<Student> students=new ArrayList<Student>();
students.add(new Student("zhangsan",21,3000,180));
students.add(new Student("zhangsan",27,4000,180));
students.add(new Student("zhangsan",15,1000,180));
students.add(new Student("zhangsan",21,5000,180));
students.add(new Student("zhangsan",45,4000,180));
students.add(new Student("zhangsan",21,5000,174));
students.add(new Student("zhangsan",20,4000,180));
students.add(new Student("zhangsan",33,4000,180));
students.add(new Student("zhangsan",45,4000,180));
students.add(new Student("zhangsan",76,4000,180));
students.add(new Student("zhangsan",99,4000,180));
students.add(new Student("zhangsan",21,5000,160));
Collections.sort(students, new Comparator<Student>(){
public int compare(Student a1, Student a2) {
int x = a1.getAge() - a2.getAge();
int y = a1.getSalary() - a2.getSalary();
int z = a1.getHeight() - a2.getHeight();
if(x==0){
if(y==0){
return z;
}
return y;
}
return x;
}
});
for(Student s:students){
System.out.println(s.getName()+"\t"+s.getAge()+"\t"+s.getSalary()+"\t"+s.getHeight());
}
}
}
class Student{
Student(String name,int age,int salary,int height){
this.name=name;
this.age=age;
this.salary=salary;
this.height=height;
}
private String name;
private int age;
private int salary;
private int height;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
}字典序排序
str1.compareTo(str2);结果：
adobe 45 4000 180
tom 45 4000 180
zhangsan 45 4000 180这是一个多条件排序。后面三个数值相等就进行字典序排序。先比较第一个字母，从小到达排列。第一个相等就比较第二个，遇到不等的就里面出结果。
如果是倒着排列就是 str2.compareTo(str1);
HashMap排序
先看一下遍历Map的方法
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");
//第一种：普遍使用，二次取值
System.out.println("通过Map.keySet遍历key和value：");
for (String key : map.keySet()) {
System.out.println("key= "+ key + " and value= " + map.get(key));
}
//第二种
System.out.println("通过Map.entrySet使用iterator遍历key和value：");
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//第三种：推荐，尤其是容量大时
System.out.println("通过Map.entrySet遍历key和value");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
//第四种
System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
for (String v : map.values()) {
System.out.println("value= " + v);
}
}因为Collections.sort针对的是list，所以要对HashMap排序需要先转为List
如果return 后面的值大于0，交换位置。所以下面的代码放回的是降序
List<Map.Entry<Integer, Integer>> font_end_list = new ArrayList<>(map.entrySet());
Collections.sort(font_end_list, new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
return o2.getValue()-o1.getValue();
}
});常用数据结构及方法
数组
对象数组
一般来说有int、double、string等类型数组，写法为
int[] a
double[] b
String[] c但还有一种数组比较特别，对象数组
比如我定义了一个Studeng类，
Student[] a a就是一个Student类数组，a[0] 就是一个Student对象。
数组取最大/小值
Arrays.stream
Arrays.stream(f[m - 1]).min().orElse(-1)- f是一个二维数组，m-1是其中一行
- 后面可以跟min() 或者 max()
- orElse(-1) 表示没有值就返回-1，括号里面也可也填其它值
数组之间的赋值
int[] nums = {1,2,3,4,5,6,20,24};
int[] news = {1,2,3,5}
news = nums;上面的代码，打印news输出的是nums的结果；如果写成nums = news。打印nums，输出的是news的结果。
数组复制/扩容
Arrays.copyOf方法是复制数组中指定范围的元素，复制的长度大于被复制数组的长度，则填充类型默认值，String得默认值是null,int的默认值是0。
int[] a1 =Arrays.copyOf(a,2);//复制指定的数组长度
int[] a2 = Arrays.copeOf(a,a.length); //容量翻倍
数组截取
2. Arrays.copyOfRange数组截取
Arrays.copyOfRange(T[ ] original,int from,int to)
original：第一个参数为要拷贝的数组对象
from：第二个参数为拷贝的开始位置（包含）
to：第三个参数为拷贝的结束位置（不包含）
public class Test {
public static void main(String[] args) {
int[] array = {0, 1, 2, 3, 4, 5, 6};
int[] array2 = Arrays.copyOfRange(array, 2, 4);
System.out.println(Arrays.toString(array2));
}
}输出：
[2, 3]数组排序
这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + " ");
}
}
}2、Arrays.sort(int[] a, int fromIndex, int toIndex)
这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序哦！
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a, 0, 3);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + " ");
}
}
}
3、public static void sort(T[] a,int fromIndex,int toIndex, Comparator c)
1 package test;
2
3 import java.util.Arrays;
4 import java.util.Comparator;
5
6 public class Main {
7 public static void main(String[] args) {
8 //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
9 //而要使用它们对应的类
10 Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
11 //定义一个自定义类MyComparator的对象
12 Comparator cmp = new MyComparator();
13 Arrays.sort(a, cmp);
14 for(int i = 0; i < a.length; i ++) {
15 System.out.print(a[i] + " ");
16 }
17 }
18 }
19 //Comparator是一个接口，所以这里我们自己定义的类MyComparator要implents该接口
20 //而不是extends Comparator
21 class MyComparator implements Comparator<Integer>{
22 @Override
23 public int compare(Integer o1, Integer o2) {
24 //如果n1小于n2，我们就返回正值，如果n1大于n2我们就返回负值，
25 //这样颠倒一下，就可以实现反向排序了
26 if(o1 < o2) {
27 return 1;
28 }else if(o1 > o2) {
29 return -1;
30 }else {
31 return 0;
32 }
33 }
34
35 }
数组填充
3.Arrays.fill 数组
public static void fill(int[] a, int fromIndex, int toIndex, int val)
用来输入给定数组中元素值的。
1、两个参数
public static void fill(int[] a， int val)：给定一个数组，一个val值
含义为为数组a进行赋值，使得其所有元素值都为val。
2、四个参数
public static void fill(int[] a, int fromIndex, int toIndex, int val)：给定一个数组，起始位置fromIndex(包含)，末尾位置toIndex(不包含)，对范围内的元素进行赋值，示例如下：
int[] arr = new int[6];
Arrays.fill(arr, 60);
//此时，arr的值为[60, 60, 60, 60, 60, 60]
Arrays.fill(arr, 3, 5, 100);
//此时，arr的值为[60, 60, 60,100, 100, 60]3.二维数组赋值
int[][] cache = new int[n + 2][n + 2];
for(int i = 0; i<= n + 1; ++i) {
Arrays.fill(cache[i], -1);
}数组转list
4.Arrays.asList
该方法是将数组转化成List集合的方法。
List
注意：
（1）该方法适用于对象型数据的数组（String、Integer…）
（2）该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）
（3）该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新
（4）不支持add()、remove()、clear()等方法
（5）长度不可变
如果你的List只是用来遍历，就用Arrays.asList()。
如果你的List还要添加或删除元素，还是乖乖地new一个java.util.ArrayList，然后一个一个的添加元素。
String
两个字符串是否相等
A.equals(B)相等会返回true
字符串与字符之间的转换
- 遍历字符串
char c : str.toCharArray() - 字符相减
字符直接相减，他们对应的ascill码相减，会返回一个整数。这个一般用做数组下标。 - 字符与整数相加会转换为整数
25 + 'A'
A的ASCII码是65，所以最后的结果是90 - 整数转换为字符
(char)(25 + 'A')
Z的ASCII码是90，所以最后的结果是Z - 字符转字符串
"" + (char)(25 + 'A')
前面加上空字符串即可 - 判断字符是大写还是小写
Character.isUpperCase(c) // 大写返回true，一般用于判断条件 Character.isLowerCase(c) //小写返回true
String对象创建
String str1 = "Hello, 慕课网";
String str2 = new String("Hello, Java");
获取字符串长度
int length = str.length();注意，hello world!中的空格也算一个字符。
字符串查找
char c = str.charAt(7);
System.out.println("索引位置为7的字符为：" + c);获取字符在字符串中第一次出现的位置：
int i = str.indexOf('a');
System.out.println("字符a在字符串str第一次出现的位置为：" + i);获取子串在字符串中第一次出现的位置：
int i = str.indexOf("love");
System.out.println("子串love在字符串str第一次出现的位置为：" + i);字符串替换
//将字符串的空格替换为%20，这是leetcode剑指offer05
str.replace(" ","%20");字符串截取
String substring = str.substring(2);
String substring1 = str.substring(2, 6);
System.out.println("从索引位置2到结束的子串为：" substring);
System.out.println("从索引位置2到索引位置6的子串为：" substring1);字符串切割
//以空格切割
String str1 = "I love Java";
String[] strArr = str1.split(" ");
// 以*切割
String str2 = "I*love*Java";
String[] strArr2 = str2.split("\\*");
// 以\切割
String str3 = "I\\love\\Java";
String[] strArr4 = str3.split("\\\\");
// 以|切割
String str4 = "I|love|Java";
String[] strArr4 = str4.split("\\|");字符串与字节数组转换
// 将字符串转换为字节数组
byte[] ascii = str2.getBytes();
// 此处的ascii为上面通过字符串转换的字节数组
String s = new String(ascii);
字符串大小写转换
String str = "HELLO world";
String s = str.toLowerCase();
System.out.println("字符串str为转换为小写后为：" + s);
String s1 = s.toUpperCase();
System.out.println("字符串s为转换为大写后为：" + s1);字符串比较
String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");
System.out.println("使用equals()方法比较str1和str2的为：" + str1.equals(str2));
System.out.println("使用==运算符比较str1和str2的结果" + (str1 == str2));
System.out.println("使用equals()方法比较str1和str3果为：" + str1.equals(str3));
System.out.println("使用==运算符比较str1和str3的结果" + (str1 == str3));运行结果：
使用equals()方法比较str1和str2的结果为：true
使用==运算符比较str1和str2的结果为：true
使用equals()方法比较str1和str3的结果为：true
使用==运算符比较str1和str3的结果为：false
StringBuilder
StringBuilder 与 String 互转
StringBuilder sb = new StringBuilder();
String s = sb.toString();String s1 = "world";
StringBuilder sb1 = new StringBuilder(s);
ArrayList
Arrays.asList的作用是将数组转化为list,一般是用于在初始化的时候,设置几个值进去,简化代码,省去add的部分。
避免如下第一种方法太啰嗦！！！
HashSet<Character> hash = new HashSet<Character>();
hash.add('a');
hash.add('e');
hash.add('i');
hash.add('o');
hash.add('u');
hash.add('A');
hash.add('E');
hash.add('I');
hash.add('O');
hash.add('U');
HashSet<Character> hash1 =new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U')) ;
LinkedList
java当中栈和队列可以使用LinkedList，重点关注头尾的插入删除，返回。
//表头添加
sites.addFirst("Wiki");
//表头移除
sites.removeFirst();
//获取表头
System.out.println(sites.getFirst());
//表尾添加
sites.addLast("Wiki");
//表尾移除
sites.removeLast();
//获取表尾
System.out.println(sites.getLast());
HashSet
HashMap
