基本操作

数组

声明数组

方法一：

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-each形式，用变量s遍历所有数组
for(String s:str) {
    System.out.println("一维数组增强:for:"+s);
}

数组排序

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

例如，我们要对数组排序：

int[] ints={1,4,7,2,5,8,3,6,9};

全体升序

Array.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("\n部分升序排序：");
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("\n降序排序：");
//要实现降序排序，得通过包装类型数组，基本类型数组是不行的
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 

输入输出

输入

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<s.length; i++) {
    System.out.println(s[i]);
}

程序运行结果：

hello
world

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

在主类中 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

【Java】机考常用知识

原文：https://www.cnblogs.com/blknemo/p/12430407.html