Java11 个常用 API 整理

一些简单代码示例。

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(100);
        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(0));
    }
}

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

4.String类

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

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

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

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

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和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类方法：

1. length（）字符串的长度
2. charAt（）截取一个字符
3. getchars（）截取多个字符并由其他字符串接收
4. getBytes()将字符串变成一个byte数组
5. toCharArray()将字符串变成一个字符数组
6. equals()和equalsIgnoreCase()比较两个字符串是否相等，前者区分大小写，后者不区分
7. startsWith()和endsWith()判断字符串是不是以特定的字符开头或结束
8. toUpperCase()和toLowerCase()将字符串转换为大写或小写
9. concat() 连接两个字符串
10. trim()去掉起始和结束的空格
11. substring（）截取字符串
12. indexOf()和lastIndexOf()前者是查找字符或字符串第一次出现的地方，后者是查找字符或字符串最后一次出现的地方
13. compareTo()和compareToIgnoreCase(）按字典顺序比较两个字符串的大小，前者区分大小写，后者不区分
14. replace() 替换

5.Arrays类

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

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

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

List<Integer> list = Arrays.asList(1, 2, 3);

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

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

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

2.Arrays.fill()

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

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

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

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

3.Arrays.sort()

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

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

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

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

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

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

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

Arrays.parallelSort(data);

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

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

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

Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOf(data1, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]
Integer[] data2 = Arrays.copyOf(data1, 5);
System.out.println(Arrays.toString(data2)); // [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 = {1, 2, 3};
System.out.println(Arrays.toString(data)); // [1, 2, 3]

13.Arrays.deepToString(Object[] array)
返回多维数组元素的字符串形式

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

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

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

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

16.Arrays.spliterator(T[] array)
返回数组的分片迭代器，用于并行遍历数组

17.Arrays.stream(T[] array)
返回数组的流Stream，然后我们就可以使用Stream相关的许多方法了

6.Math类

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

1. public static long abs(double a):    返回a的绝对值。
2. public static double max(double a,double b):     返回a、b的最大值。
3. public static double min(double a,double b):     返回a、b的最小值。
4. pubic static double random():    产生一个0~1之间的随机数(不包括0和1)。
5. public static double pow(double a,double b);    返回a的b次幂。
6. public static double sqrt(double a):    返回a的平方根。
7. public static double log(double a):    返回a的对数。
8. public static double sin(double a):    返回a的正弦值。
9. public static double asin(double a):    返回a的反正弦值。
10. public static double ceil(double a):    返回大于a的最小整数，并将该整数转化为double型数据方法的名字ceil是天花板的意思，很形象)。例如，Math. eil52)的值是16.0。
11. public static double floor(double a):     返回小于a的最大整数，并将该整数转化为double型数据。例如，Math.floor(15.2)的值是 15.0，Mat.floor(-15.2)的值是-16.0。
12. 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) {
        // 对应的日期格式如：2018-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类中提供很多成员常量，代表给定的日历字段：

9.System类

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

10.StringBuilder类

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。
在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。为了解决这一问题，可以使用java.lang.StringBuilder类。

构造函数：

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

方法：

• public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
• public String toString()：将当前StringBuilder对象转换为String对象。

11.包装类

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

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

Over.

本作品采用《CC 协议》，转载必须注明作者和本文链接