# 基本操作
## 数组
### 声明数组
**方法一：**
```
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 **注意：**要实现降序排序，得通过**包装类型数组**，**基本类型数组是不行的**。
**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("\n降序排序：");
//要实现降序排序，得通过包装类型数组，基本类型数组是不行的
Integer[] integers = {1,4,7,2,5,8,3,6,9};
Arrays.sort(integers, new Comparator()
{
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
```
## 输入输出
### 输入
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()`：****换行**
**例如：**
```
System.out.println(n); // n 为 int 型
```
- **同一行输出多个整数**可以用：
```
System.out.println(new Integer(n).toString() + " " + new Integer(m).toString());
```
- 对于输出浮点数**保留几位小数**的问题，可以使用**`DecimalFormat`类**：
```
import java.text.*;
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));
//这里 0 指一位数字，#指除 0 以外的数字。
```
# 大数字
**`BigInteger`** 和 **`BigDecimal`** 是在**java.math包**中已有的**类**：
- **`BigInteger`：**表示**整数**
- **`BigDecimal`：**表示**浮点数**
> **注意：**不能直接用符号运算，如**加(+)**、**减(-)**来运算大数字，
**例如：**
```
import java.text.*;
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));
//这里 0 指一位数字，#指除 0 以外的数字。
(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) 即可。
```
# 字符串
**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()`类似，不过在比较时**忽略了大小写**。
## 按字典顺序比较两个字符串
**`compareTo()`**方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的 Unicode 值，按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。
- 如果按字典顺序此 String 对象位于参数字符串**之前**，则比较结果为一个**负整数**；
- 如果按字典顺序此 String 对象位于参数字符串**之后**，则比较结果为一个**正整数**；
- 如果这两个字符串**相等**，则结果为**0**.
## 字母大小写转换
- 字符串的**`toLowerCase()`**方法可将字符串中的所有字符从**大写**字母改写为**小写**字母，
- 而**`toLowerCaseUpperCase()`**方法可将字符串中的**小写**字母改写为**大写**字母。
```
str.toLowerCase();
str.toUpperCase();
```
## 字符串分割
使用**`split()`**方法可以使字符串按指定的分隔字符或字符串对内容进行分割，并将分割后的结果作为**字符串数组**返回。
**`str.split(String sign);`：****sign**为分割字符串的分割符，也可以使用正则表达式。
> **注意：**没有统一的对字符串进行分割的符号，如果想定义多个分割符，可使用符号“|”。
>> **例如，**“,|=”表示分割符分别为“，”和“=”。
```
String str = "hello world";
String[] s = str.split(" ");
for(int i=0; i **注意：**数组定义后必须初始化，如 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
```
