【Java】机考常用操作

【Java】机考常用操作
注释

首先要说的就是注释，在机考中一定要写注释，不然会扣分。
CTRL + /：单行注释//...
CTRL + SHIFT + /：多行注释/*...*/
ALT + SHIFT + J：添加Javadoc注释

输入输出

输入

JDK 1.5.0新增的Scanner类为输入提供了良好的基础。
一般用法为：
```
import java.io.* 
import java.util.* 
public class Main {
    public static void main(String args[]) { 
        Scanner cin = new Scanner(new BufferedInputStream(System.in)); 
    }
}
```
当然也可以直接：
```
Scanner cin = new Scanner(System.in); //加 Buffer 速度会快一些
```
- 读一个整数：int n = cin.nextInt();
  相当于scanf("%d", &n); 或 cin >> n;
- 读一个字符串：String s = cin.next();
  相当于scanf("%s", s); 或 cin >> s;
- 读一个浮点数：double t = cin.nextDouble();
  相当于scanf("%lf", &t); 或 cin >> t;
- 读一整行：String s = cin.nextLine();
  相当于gets(s); 或 cin.getline(...);
- 判断是否有下一个输入：可以用cin.hasNext() 或 cin.hasNextInt() 或 cin.hasNextDouble() 。
输出
- 一般可以直接用：
  - System.out.print()：不换行
  - System.out.println()：换行(line new)
  例如：
```
System.out.println(n); // n 为 int 型
```
- 同一行输出多个整数可以用：
  System.out.println(new Integer(n).toString() + " " + new Integer(m).toString());
- 对于输出浮点数保留几位小数的问题，可以使用DecimalFormat类：
```
import java.text.*; 
// 这里 0 指一位数字，# 指除 0 以外的数字（用来省略末尾的0）
DecimalFormat f = new DecimalFormat("#.00#"); 
DecimalFormat g = new DecimalFormat("0.000"); 
double a = 123.45678, b = 0.12; 
System.out.println(f.format(a)); 
System.out.println(f.format(b)); 
System.out.println(g.format(b)); 
```
大数字

BigInteger 和 BigDecimal 是在java.math包中已有的类：
- BigInteger：表示整数
- BigDecimal：表示浮点数（使用前得先设置 DecimalFormat 类，为大数字设置保留几位小数）
  
  注意：因为大数字不是基本数据类型，所以不能直接用符号运算，如 加(+)、减(-)来运算大数字。需要用方法。
例如：
```
(import java.math.*) // 需要引入 java.math 包
BigInteger a = BigInteger.valueOf(100); 
BigInteger b = BigInteger.valueOf(50); 
BigInteger c = a.add(b) // c = a + b; 
```
主要有以下方法可以使用：
```
BigInteger add(BigInteger other) 
BigInteger subtract(BigInteger other) 
BigInteger multiply(BigInteger other) 
BigInteger divide(BigInteger other) 
BigInteger mod(BigInteger other) 
int compareTo(BigInteger other) 
static BigInteger valueOf(long x) 
//输出大数字时直接使用 System.out.println(a) 即可。
```
数组

注意：所有的变量在声明的时候都不会分配内存，赋值和实例化才会分配内存。

声明数组

方法一：
```
int a[] = null; //声明一维数组
//int[] a = null; 也行，个人习惯
a = new int[10];//分配内存给一维数组
```
方法二：
```
int[] a = new int[10];  //声明数组的同时分配内存
```
遍历数组

例如：
```
//一维数组
String[] str = new String[3];
str[0]="张三";
str[1]="李四";
str[2]="王五";
```
for循环

数组元素下标的合法区间：[0, length-1]。
我们可以用for循环通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。

例如：
```
// for形式遍历数组
for(int i=0;i<str.length;i++) {
    System.out.println("一维数组:for:"+str[i]);
}
```
for-each

增强for循环for-each是JDK1.5新增加的功能，专门用于读取数组或集合中所有的元素，即对数组进行遍历。
格式：用对象遍历集合数组
```
for(类 对象: 集合数组) {
    //操作
}
```
例如：
```
// 增强for-each形式，用变量s遍历所有数组
for(String s:str) {
    System.out.println("一维数组增强:for:"+s);
}
```
注意：foreach不能进行赋值操作，毕竟你赋的值都给了变量s，而不是给了数组。

数组排序

通常情况下我们可以使用Arrays.sort()来对数组进行排序。

例如，我们要对数组排序：
```
int[] ints={1,4,7,2,5,8,3,6,9};
```
public class Arrays
extends Object
This class contains various methods for manipulating arrays (such as sorting and searching). This class also contains a static factory that allows arrays to be viewed as lists.
The methods in this class all throw a NullPointerException, if the specified array reference is null, except where noted.

The documentation for the methods contained in this class includes briefs description of the implementations. Such descriptions should be regarded as implementation notes, rather than parts of the specification. Implementors should feel free to substitute other algorithms, so long as the specification itself is adhered to. (For example, the algorithm used by sort(Object[]) does not have to be a MergeSort, but it does have to be stable.)

This class is a member of the Java Collections Framework.
上面说的很清楚，是操作数组(manipulating arrays)，这就是我们的类叫 Arrays 的原因。

全体升序

Arrays.sort(int[] a)：直接对数组进行升序排序
例如：
```
System.out.println("升序排序：");
Arrays.sort(score);
System.out.println(Arrays.toString(score)); //这里我偷了个懒。。把他变成字符串输出了
```
程序运行结果：
```
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```
部分升序

Array.sort(int[] a , int fromIndex, int toIndex)：对数组的从fromIndex到toIndex（[from, to)）进行升序排序。（前闭后开）

例如：
```
System.out.println("
部分升序排序：");
int[] ints2 = {1,4,7,2,5,8,3,6,9};

//对数组的[2,6)位进行排序
Arrays.sort(ints2, 2, 6);

//输出
for (int i=0;i<ints2.length;i++)
{
    System.out.print(ints2[i]+" ");
}
```
程序运行结果：
```
部分升序排序：
9 8 4 5 6 7 3 2 1 
```
降序

因为sort()方法默认为升序排序，所以要实现降序排序的话，要新建一个比较器Comparator，从而实现自定义比较。

注意：要实现降序排序，得通过包装类型数组，基本类型数组是不行的。

Comparator接口可以实现自定义排序，实现Comparator接口时，要重写compare方法：
int compare(Object o1, Object o2)返回一个基本类型的整型。
- 如果要按照升序排序，则
  - o1小于o2，返回-1（负数）
  - 相等，返回0
  - o1大于o2，返回1（正数）
- 如果要按照降序排序，则
  - o1小于o2，返回1（正数）
  - 相等，返回0
  - o1大于o2，返回-1（负数）
看到这里，可能有人就懵了，凭什么升序是这样安排的，降序是那样安排的呢？？

理解：
其实设计compare()的大佬是按照我们正常思维来设计的，即 两个数相比较，小于取负，等于取0，大于取正；
设计sort()的大佬是按照我们正常思维来设计的，即升序，
而设计排序的大佬需要用到这个比较的方法，所以sort()的升序与compare()的正常情况就相统一了。
如果我们要实现降序，只需把compare()方法反过来，即 两个数相比较，小于取正，等于取0，大于取负。

例如：
```
System.out.println("
降序排序：");
//要实现降序排序，得通过包装类型数组，基本类型数组是不行的
Integer[] integers = {1,4,7,2,5,8,3,6,9};
Arrays.sort(integers, new Comparator<Integer>()
{
    public int compare(Integer o1, Integer o2)
    {
//      if(o1 < o2) { 
//          return 1;
//      }else if(o1 > o2) {
//          return -1;
//      }else {
//          return 0;
//      }

        return o2-o1;   //与“小于取正，等于取0，大于取负”相同效果
    }
});

//输出
for (Integer integer:integers)
{
    System.out.print(integer+" ");
}
```
程序运行结果：
```
降序排序：
9 8 7 6 5 4 3 2 1 
```
字符串

String类用来存储字符串。
例如：
```
String a = "Hello"; 
```
字符串连接

可以直接用+号，如
```
String a = "Hello"; 
String b = "world"; 
System.out.println(a + ", " + b + "!"); // output "Hello, world!" 
```
字符串查找

String提供了两种查找字符串的方法，即 indexOf() 与 lastIndexOf() 方法。
- indexOf(String s)：用于返回参数字符串 s 在指定字符串中首次出现的索引位置
  当调用字符串的indexOf()方法时，会从当前字符串的开始位置搜索 s 的位置。
  - 如果没有检索到字符串 s，该方法返回-1
```
String str ="We are students";
int size = str.indexOf("a"); // 变量 size 的值是 3 
```
- lastIndexOf(String str)：用于返回字符串最后一次出现的索引位置。
  当调用字符串的lastIndexOf()方法时，会从当前字符串的开始位置检索参数字符串 str，并将最后一次出现 str 的索引位置返回。
  - 如果没有检索到字符串 str，该方法返回-1。
  - 如果lastIndexOf()方法中的参数是空字符串""，则返回的结果与 length 方法的返回结果相同。
获取指定索引位置的字符

使用charAt()方法可将指定索引处的字符返回。
```
String str = "Hello world";
char mychar = str.charAt(5); // mychar 的结果是 w 
```
获取子字符串

通过String类的substring()方法可对字符串进行截取。

这些方法的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从 0 开始的。在字符串中空格占用一个索引位置。
- substring(int beginIndex)：从begin开始，到结尾结束
```
String str = "Hello world";
String substr = str.substring(3); //获取字符串，此时 substr 值为 lo world
```
- substring(int beginIndex, int endIndex)：begin和end区间是前闭后开的，[begin, end)
  
  注意：其实这个区间前闭后开是针对字符来说的，看下面举的例子，0~3截取了Hel这三个字符，即 [0, 3)，第0、1、2个字符。
  - beginIndex：开始截取子字符串的索引位置
  - endIndex：子字符串在整个字符串中的结束位置
  理解：但是，我们可以从存储机制去理解它。
  Hello World 在系统里是这样存储的：
  
  我们截取了地址0~3，所以截取了Hel这三个字符。
```
String str = "Hello world";
String substr = str.substring(0,3); //substr 的值为 Hel
```
去除空格

trim()方法返回字符串的副本，清除了左右两端的空格。
```
String str = "        hello           ";
System.out.println(str.trim());
//程序运行结果：hello
```
字符串替换

replace(String oldChar，String newChar)方法可实现将指定的字符或字符串替换成新的字符或字符串。
- oldChar：要替换的字符或字符串
- newChar：用于替换原来字符串的内容
注意：如果要替换的字符 oldChar 在字符串中重复出现多次，replace()方法会将所有 oldChar 全部替换成 newChar。需要注意的是，要替换的字符 oldChar 的大小写要与原字符串中字符的大小写保持一致。
```
String str= "address";
String newstr = str.replace("a", "A");// newstr 的值为 Address
```
判断字符串是否相等（切不可使用==）
- equals(String otherstr)：
  如果两个字符串具有相同的字符和长度，则使用equals()方法比较时，返回 true。
  
  注意：equals()方法比较时，区分大小写。
- equalsIgnoreCase(String otherstr)：
  
  注意：equalsIgnoreCase()方法与equals()类似，不过在比较时忽略了大小写。
equals()与==的区别：
- ==：
  - 如果作用于基本数据类型的变量（如 byte,short,char,int,long,float,double,boolean），则直接比较其存储的“值”是否相等；
  - 如果作用于引用类型的变量（如 String类），则比较的是所指向的对象的地址（即是否指向同一个对象）。
- equals()方法：是基类Object中的方法，因此对于所有的继承于Object的类都会有该方法。在Object类中，equals()方法是用来比较两个对象的引用是否相等，即是否指向同一个对象。
是不是感觉equals()在Object类中跟==好像是一样的描述啊？？没错，就是一样的，不是我写错了！

Java中Object类是所有类的父类，它里面定义了equals()方法：
```
public boolean equals(Object obj) {
    return (this == obj);
}
```
若object1.equals(object2)为true，则表示equals1和equals2实际上是引用同一个对象。
注意：对于equals()方法，equals()方法不能作用于基本数据类型的变量。
- 如果没有对equals()方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
- 而String类对equals方法进行了重写，用来比较指向的字符串对象所存储的字符串内容是否相等。
  其他的一些自带的引用数据类型，如 Double，Date，Integer等，都对equals()方法进行了重写，用来比较指向的对象所存储的内容是否相等。
按字典顺序比较两个字符串

compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的 Unicode 值，按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。
- 如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数；
- 如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数；
- 如果这两个字符串相等，则结果为0.
字母大小写转换
- 字符串的toLowerCase()方法可将字符串中的所有字符从大写字母改写为小写字母，
- 而toLowerCaseUpperCase()方法可将字符串中的小写字母改写为大写字母。
```
str.toLowerCase();
str.toUpperCase();
```
字符串分割

使用split()方法可以使字符串按指定的分隔字符或字符串对内容进行分割，并将分割后的结果作为字符串数组返回。

str.split(String regex);：regex为分割字符串的分割符，也可以使用正则表达式。

注意：没有统一的对字符串进行分割的符号，如果想定义多个分割符，可使用符号“|”。（这个是正则表达式的“或”概念）

例如，“,|=”表示分割符分别为“，”和“=”。
```
String str = "hello world";
String[] s = str.split(" ");
for(int i=0; i<s.length; i++) {
    System.out.println(s[i]);
}
```
程序运行结果：
```
hello
world
```
字符串变数字

用对应类的parse方法即可，如
```
String t = "123";
Integer.parseInt(t);
```
switch case 语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

当我们遇到多个if语句的时候，可以尝试用switch来简化整个代码。

语法格式：
```
switch(expression){
    case value:
       // 语句
       break; // 可选
    case value:
       // 语句
       break; // 可选
    case value:
    case value:
        // 语句（前两个判断的公共语句）
        break;
    //你可以有任意数量的case语句
    default: // 默认（可选）
       // 语句
}
```
语句规则：
- switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了。
  同时 case 标签必须为常量或字面常量。
- switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
- case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
- 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
- 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。
  如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
- switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
- switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。
实例：
```
public class Test {
   public static void main(String args[]){
      //char grade = args[0].charAt(0);
      char grade = 'C';
 
      switch(grade)
      {
         case 'A':
            System.out.println("优秀"); 
            break;
         case 'B':  // 如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
         case 'C':
            System.out.println("良好");
            break;
         case 'D':
            System.out.println("及格");
            break;
         case 'F':
            System.out.println("你需要再努力努力");
            break;
         default:
            System.out.println("未知等级");
      }
      System.out.println("你的等级是 " + grade);
   }
}
```
程序运行结果：
```
良好
你的等级是 C
```
调用递归（或其他动态方法）

在主类中 main 方法必须是 public static void 的，在 main 中调用非 static 类时会有警告信息，可以先建立对象，然后通过对象调用方法。

其他注意的事项
- Java 是面向对象的语言，思考方法需要变换一下，里面的函数统称为方法，不要搞错。
- Java 里的数组有些变动，多维数组的内部其实都是指针，所以 Java 不支持 fill 多维数组。
  
  注意：数组定义后必须初始化，如 int[] a = new int[100];
- 布尔类型为 boolean，只有 true 和 false 二值，在 if (...) / while (...) 等语句的条件中必须为 boolean 类型。
  
  注意：在 C/C++中的 if (n % 2) 在 Java 中无法编译通过。
- 下面在 java.util 包里 Arrays类的几个方法可替代 C/C++里的 memset、qsort/sort
```
int[] a = {9,8,7,6,5,4,3,2,1};
Arrays.sort(a) //java 自带的优化后的快速排序
Arrays.fill(a, 3);  //用3填充数组，结果为3,3,3,3,3,3,3,3,3
```
  注意：是Arrays类，不是Array类。
  数组类Array：Java中最基本的一个存储结构。
  Array代表的是一个数组类型
  静态类Arrays：专门用来操作array，提供搜索、排序、复制等静态方法。
  Arrays代表的是能操作数组们（所有数组）
相关阅读:
org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): 问题解决方法
 springboot入门（一）--快速搭建一个springboot框架
 SpringBoot 中常用注解@Controller/@RestController/@RequestMapping介绍
 理解Spring4.0新特性@RestController注解
 Intellij IDEA 搭建Spring Boot项目(一)
Java checked 异常和 RuntimeException(运行时异常)
Java 如何抛出异常、自定义异常、手动或主动抛出异常
 微服务设计
 为什么需要API网关？
微服务API网关
原文地址：https://www.cnblogs.com/blknemo/p/12430407.html

【Java】机考常用操作

注释

输入输出

输入

输出

大数字

数组

声明数组

遍历数组

for循环

for-each

数组排序

全体升序

部分升序

降序

字符串

字符串连接

字符串查找

获取指定索引位置的字符

获取子字符串

去除空格

字符串替换

判断字符串是否相等（切不可使用==）

按字典顺序比较两个字符串

字母大小写转换

字符串分割

字符串变数字

switch case 语句

调用递归（或其他动态方法）

其他注意的事项