1.Scanner 类

一个可以解析基本类型和字符串的简单文本扫描器。

 package cn.wxuns;
import java.util.Scanner;
public class MyScanner {
    public static void main( String[] args){
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入一个数字");
        int sc = myScanner.nextInt();
        System.out.println(sc);
    }
}

2.Random 类

生成伪随机数

 package cn.wxuns;
import java.util.Random;
public class MyRandom {
    public static void main(String[] args){
        int random = new Random().nextInt();
        System.out.println(random);
    }
}

3.ArrayList 类

 定义：ArrayList<String>，ArrayList<Student>
方法：add，set，get，remove，clone，size 等 
 package cn.wxuns;

import java.util.ArrayList;

public class MyArray {

    public static void main(String[] args){

        ArrayList<String> arr = new ArrayList<>();

        arr.add("lisi");

        System.out.println(arr.get());

    }

}

ArrayList 对象不能存储基本类型，只能存储引用类型的数据。类似不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写，转换写法如下：

基本类型基本类型包装类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

4.String 类

类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

1. 字符串不变：字符串的值在创建后不能被更改。

 String s = "abc";
s += "d";
System.out.println(s); // "abcd"
// 内存中有"abc"，"abcd"两个对象，s从指向"abc"，改变指向，指向了"abcd"。

2. 因为 String 对象是不可变的，所以它们可以被共享

 String s = "abc";
String s = "abc";
// 内存中只有一个"abc"对象被创建，同时被s和s2共享。

3.”abc” 等效于 char [] data={ ‘a’ , ‘b’ , ‘c’ } 。

例如：

 String str = "abc";
相当于：
char data[] = {'a', 'b', 'c'};    
String str = new String(data);
// String底层是靠字符数组实现的。

构造方法

public String () ：初始化新创建的 String 对象，以使其表示空字符序列。

public String (char [] value) ：通过当前参数中的字符数组来构造新的 String。

public String (byte [] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。

常见 String 类方法：

length（）字符串的长度

charAt（）截取一个字符

getchars（）截取多个字符并由其他字符串接收

getBytes () 将字符串变成一个 byte 数组

toCharArray () 将字符串变成一个字符数组

equals () 和 equalsIgnoreCase () 比较两个字符串是否相等，前者区分大小写，后者不区分

startsWith () 和 endsWith () 判断字符串是不是以特定的字符开头或结束

toUpperCase () 和 toLowerCase () 将字符串转换为大写或小写

concat () 连接两个字符串

trim () 去掉起始和结束的空格

substring（）截取字符串

indexOf () 和 lastIndexOf () 前者是查找字符或字符串第一次出现的地方，后者是查找字符或字符串最后一次出现的地方

compareTo () 和 compareToIgnoreCase (）按字典顺序比较两个字符串的大小，前者区分大小写，后者不区分

replace () 替换

5.Arrays 类

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

1.Arrays.asList(T… data)

注意：该方法返回的是 Arrays 内部静态类 ArrayList，而不是我们平常使用的 ArrayList,，该静态类 ArrayList 没有覆盖父类的 add, remove 等方法，所以如果直接调用，会报 UnsupportedOperationException 异常

将数组转换为集合，接收一个可变参

 List<Integer> list = Arrays.asList(, 2, 3);
Integer[] data = {, 2, 3};
List<Integer> list = Arrays.asList(data);

如果将基本数据类型的数组作为参数传入，该方法会把整个数组当作返回的 List 中的第一个元素，多维数组

 int[] data = {, 2, 3};
List<int[]> list = Arrays.asList(data);

2.Arrays.fill()

用指定元素填充整个数组（会替换掉数组中原来的元素）

 Integer[] data = {, 2, 3, 4};
Arrays.fill(data,);
System.out.println(Arrays.toString(data)); // [, 9, 9, 9]

用指定元素填充数组，从起始位置到结束位置，取头不取尾（会替换掉数组中原来的元素）

 Integer[] data = {, 2, 3, 4};
Arrays.fill(data,, 2, 9);
System.out.println(Arrays.toString(data)); // [, 9, 3, 4]

3.Arrays.sort()

对数组元素进行排序（串行排序

 int[] data = {, 2, 3,1,3,4};
Arrays.sort(data);
System.out.println(data);

对数组元素的指定范围进行排序（串行排序）

 String[] data = {"", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [, 4, 3, 2]
// 对下标[, 3)的元素进行排序，即对1，4，3进行排序，2保持不变
Arrays.sort(data,, 3);
System.out.println(Arrays.toString(data)); // [, 3, 4, 2]

使用自定义比较器，对数组元素的指定范围进行排序（串行排序）

 String[] data = {"", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [, 4, 3, 2]
// 对下标[, 3]的元素进行降序排序，即对1，4，3进行降序排序，2保持不变
Arrays.sort(data,, 3, (str1, str2) -> {
    if (str.compareTo(str2) > 0) {
        return -;
    } else {
        return;
    }
});
System.out.println(Arrays.toString(data)); // [, 3, 1, 2]

4.Arrays.parallelSort()

对数组元素进行排序（并行排序），当数据规模较大时，会有更好的性能

 Arrays.parallelSort(data);

5.Arrays.binarySearch () 二分法查找

注意：在调用该方法之前，必须先调用 sort () 方法进行排序，如果数组没有排序，那么结果是不确定的，此外如果数组中包含多个指定元素，则无法保证将找到哪个元素

6.Arrays.copyOf()

拷贝数组，其内部调用了 System.arraycopy () 方法，从下标 0 开始，如果超过原数组长度，会用 null 进行填充

 Integer[] data = {1, 2, 3, 4};
Integer[] data = Arrays.copyOf(data1, 2);
System.out.println(Arrays.toString(data)); // [1, 2]
Integer[] data = Arrays.copyOf(data1, 5);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4, null]

7.Arrays.copyOfRange(T[] original, int from, int to)

拷贝数组，指定起始位置和结束位置，如果超过原数组长度，会用 null 进行填充，同 6

8.Arrays.equals(Object[] array1, Object[] array2)

判断两个数组是否相等，实际上比较的是两个数组的哈希值，即 Arrays.hashCode (data1) == Arrays.hashCode (data2)

9.Arrays.deepEquals(Object[] array1, Object[] array2)

判断两个多维数组是否相等，实际上比较的是两个数组的哈希值，即 Arrays.hashCode (data1) == Arrays.hashCode (data2)

10.Arrays.hashCode(Object[] array)

返回数组的哈希值

11.Arrays.deepHashCode(Object[] array)

返回多维数组的哈希值

12.Arrays.toString(Object[] array)

返回数组元素的字符串形式

 Integer[] data = {, 2, 3};
System.out.println(Arrays.toString(data)); // [, 2, 3]

13.Arrays.deepToString(Object[] array)

返回多维数组元素的字符串形式

14.Arrays.setAll(T[] array, IntFunction

 Integer[] data = {, 2, 3, 4};
// i为索引值
Arrays.setAll(data, i -> data[i] *);
System.out.println(Arrays.toString(data)); // [, 4, 6, 8]

15.Arrays.parallelSetAll(T[] array, IntFunction

 Integer[] data = {, 3, 4, 5};
// 第一个元素不变，将其与第二个元素3一起作为参数x, y传入，得到乘积6，作为数组新的第二个元素
// 再将和第三个元素4一起作为参数x, y传入，得到乘积24，作为数组新的第三个元素，以此类推
Arrays.parallelPrefix(data, (x, y) -> x * y);
System.out.println(Arrays.toString(data)); // [, 6, 24, 120]

16.Arrays.spliterator(T[] array)

返回数组的分片迭代器，用于并行遍历数组

17.Arrays.stream(T[] array)

返回数组的流 Stream，然后我们就可以使用 Stream 相关的许多方法了

6.Math 类

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

public static long abs (double a): 返回 a 的绝对值。

public static double max (double a,double b): 返回 a、b 的最大值。

public static double min (double a,double b): 返回 a、b 的最小值。

pubic static double random (): 产生一个 0~1 之间的随机数 (不包括 0 和 1)。

public static double pow (double a,double b); 返回 a 的 b 次幂。

public static double sqrt (double a): 返回 a 的平方根。

public static double log (double a): 返回 a 的对数。

public static double sin (double a): 返回 a 的正弦值。

public static double asin (double a): 返回 a 的反正弦值。

public static double ceil (double a): 返回大于 a 的最小整数，并将该整数转化为 double 型数据方法的名字 ceil 是天花板的意思，很形象)。例如，Math. eil52) 的值是 16.0。

public static double floor (double a): 返回小于 a 的最大整数，并将该整数转化为 double 型数据。例如，Math.floor (15.2) 的值是 15.0，Mat.floor (-15.2) 的值是 – 16.0。

public static long round (double a): 返回值是 (long) Math.floor (a+0.5)), 即所谓 a 的 “四舍五入” 后的值。一个比较通俗好记的办法是：如果 a 是非负数，round 方法返回 a 的四舍五入后的整数 (小数大于等于 0.5 入，小于 0.5 舍): 如果 a 是负数，round 方法返回 a 的绝对值的四舍五入后的整数取负，但注意，小数大于 0.5 入，小于等于 0.5 舍，例如，Math.round (-15.501) 的值是 – 16，Math.round (-15.50) 的值是 – 15。

7.Object 类

对象，所有的类都继承与 Object 类，可重写部分方法

8. 日期时间类

Date 类

表示特定的瞬间，精确到毫秒。

after,before,clone,getTime,hashCode,toString

DateFormat 类

是日期 / 时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换，也就是可以在 Date 对象与 String 对象之间进行来回转换。

格式化：按照指定的格式，从 Date 对象转换为 String 对象。

解析：按照指定的格式，从 String 对象转换为 Date 对象。

由于 DateFormat 为抽象类，不能直接使用，所以需要常用的子类 java.text.SimpleDateFormat

创建 SimpleDateFormat

 import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class MySimpleDateFormat {
    public static void main(String[] args) {
        // 对应的日期格式如：-01-16 15:06:38
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }    
}

常用方法：

public String format (Date date)：将 Date 对象格式化为字符串。

public Date parse (String source)：将字符串解析为 Date 对象。

Calendar 类

Calendar 为抽象类，由于语言敏感性，Calendar 类在创建对象时并非直接创建，而是通过静态方法创建 getInstance（），返回子类对象

常用方法：

public int get (int field)：返回给定日历字段的值。

public void set (int field, int value)：将给定的日历字段设置为给定值。

public abstract void add (int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。

public Date getTime ()：返回一个表示此 Calendar 时间值（从历元到现在的毫秒偏移量）的 Date 对象。

Calendar 类中提供很多成员常量，代表给定的日历字段：

变量含义

YEAR 年

MONTH 月（从 0 开始，可以 + 1 使用）

DAY_OF_MONTH 月中的天（几号）

HOUR 小时（12 小时制）

HOUR_OF_DAY 时（24 小时）

MINUTE 分

SECOND 秒

DAY_OF_WEEK 周中的天（周几，周日为 1，可以 – 1 使用）

9.System 类

currentTimeMillis 方法：毫秒级的时间戳

arrayCopy 方法：将数组中指定的数据拷贝到另一个数组中。System.arraycopy( 源数组, 源数组, 目标数组, 目标数组索引起始位置, length);

10.StringBuilder 类

由于 String 类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。

在 API 中对 String 类有这样的描述：字符串是常量，它们的值在创建后不能被更改。为了解决这一问题，可以使用 java.lang.StringBuilder 类。

构造函数：

public StringBuilder ()：构造一个空的 StringBuilder 容器。

public StringBuilder (String str)：构造一个 StringBuilder 容器，并将字符串添加进去。

方法：

public StringBuilder append (…)：添加任意类型数据的字符串形式，并返回当前对象自身。

public String toString ()：将当前 StringBuilder 对象转换为 String 对象。

11. 包装类

Java 提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型对应的包装类（位于 java.lang 包中）