上一篇：06【接口、多态】

下一篇：08【Java核心API-02】

目录：【JavaSE零基础系列教程目录】

07【Java核心API-01】

一、API概述

1.1 API概述

API（Application Programming Interface，应用程序接口）是一些预先定义的接口（功能），提供给开发人员使用，开发人员无需访问源码，或理解内部工作机制的细节；在JDK中提供了非常丰富的API接口，这些类将底层代码封装起来对外提供非常丰富而又强大的功能；我们这一章节主要来学习JDK给我提供的那些类的使用方法；

简单来说API就是提供的一些方法给我们开发时使用，不使用这些API也能开发，只不过API中封装的功能就得我们自己编写了；

1.2 Java常用包介绍

JDK中为开发开发人员提供了大量可使用的Java类库，类库是以包的形式提供的，这些包统称为API（应用程序接口），下列表格是常用包的功能介绍：

java包和javax包的区别：javax的x是extension的意思，也就是扩展包，一般是对原有的包进行扩展、增强，在原有的基础上增加了许多功能类；

1.3 java.lang包

java.lang包是所有类库的基础，为Java应用程序的运行做支持，java.lang包已经被嵌入到JVM虚拟机中并创建为对象，因此java.lang包下的类不需要使用import语句导入；

1.4 Java开发手册

Java官方提供了开发手册，JDK中所有的类都可以在这个手册中查询到他的使用方法、功能、介绍等；

官方在线手册：https://docs.oracle.com/javase/8/docs/api/

我们打开查看：

在线地址（中文版）：https://www.matools.com/api/java8

官方版（英文版）：https://docs.oracle.com/javase/8/docs/api/

二、Scanner类

2.1 Scanner简介

Java 5 中添加了java.util.Scanner类，这是一个用于扫描输入文本的新的实用程序，可以解析基本类型和字符串的简单文本扫描器；

用法：

Scanner in=new Scanner(System.in);

tips：System.in 系统输入指的是通过键盘录入数据；

2.2 Scanner类的使用

2.2.1 导包

Scanner类在java.util包下，需要我们手动导入：

import 包名.类名;

示例：

java.util.Scanner;

2.2.2 创建对象

使用该类的构造方法，创建一个该类的对象

格式：

数据类型  变量名  =  new 数据类型(参数列表);

示例：

Scanner in=new Scanner(System.in);

Scanner的构造方法传递的是一个输入流类型，System.in返回的是键盘输入流；关于流的知识我们到后面章节再学习；

2.2.3 常用方法

2.2.4 使用示例

package com.dfbz.demo01;

import java.util.Scanner;			// 导入包

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {

        // 创建一个Scanner扫描器
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入一个布尔类型: ");
        boolean boo = scanner.nextBoolean();
        System.out.println("您输入的布尔值是: " + boo);

        System.out.println("请输入一个double值: ");
        double d = scanner.nextDouble();
        System.out.println("您输入的double值是: " + d);

        System.out.println("请输入一个int值: ");
        int i = scanner.nextInt();
        System.out.println("您输入的int值是: " + i);

        System.out.println("请输入一个字符串: ");
        String str = scanner.next();
        System.out.println("您输入的字符串是: " + str);
    }
}

运行结果：

2.2.5 next与nextLine方法

• public String next()：获取输入的一行字符串（该方法不会获取回车符）
• public String nextLine()：获取输入的一行字符串（该方法会获取回车符）

next()方法与nextLine()方法有些许类似，都是获取Scanner扫描的一行字符串，唯一不同的点在于next()方法并不会接收回车符号，而nextLine()方法则会接收回车符号，而Scanner扫描的结束信号恰好就是输入回车键；

这样一来如果使用next()方法来接收键盘输入的值时，单单输入回车并不会使得这一次扫描结束；而如果使用nextLine()则会结束本次扫描，并将接收到的回车符返回给nextLine()方法的调用者；

• next()方法示例代码：

package com.dfbz.demo01;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro: 求偶数
 */
public class Demo04_next方法 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入..");

        // 如果只输入回车键,则next()方法不会接收到任何数据,本次扫描也不会结束
        String str1 = scanner.next();
        System.out.println("您输入的是: " + str1);

        System.out.println("请输入..");
        String str2 = scanner.next();
        System.out.println("您输入的是: " + str2);
    }
}

• nextLine()方法示例代码：

package com.dfbz.demo01;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro: 求偶数
 */
public class Demo05_nextLine方法 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入..");
        // nextLine方法会接收回车符,如果只输入回车键,那么也会被nextLine()方法扫描到,并返回给str1字符串
        String str1 = scanner.nextLine();
        System.out.println("您输入的是: " + str1);

        System.out.println("请输入..");
        String str2 = scanner.nextLine();
        System.out.println("您输入的是: " + str2);
    }
}

• next()方法和nextLine()方法混用：

package com.dfbz.demo01;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro: 求偶数
 */
public class Demo06_next与nextLine方法 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("请输入..");
        
        /*
         输入了一段文本回车后,由于next()方法并不会接收最后的回车符
         因此回车符被下面的nextLine()方法接收了,导致输入完回车键后,后面的nextLine()方法也接收到了数据
         */
        String str1 = scanner.next();
        System.out.println("您输入的是: " + str1);

        System.out.println("请输入..");
        String str2 = scanner.nextLine();
        System.out.println("您输入的是: " + str2);
    }
}

Tips：不仅是next()方法不会接收回车符，nextInt()、nextDouble()等方法都不会接收回车符；因此我们在使用Scanner时，需要注意next()不要与nextLine()方法混用；

2.3 练习

2.3.1 求三个数最大值

键盘录入三个数，打印其最大值；

package com.dfbz.demo01;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro: 求最大值
 */
public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第1个数: ");
        int num1 = scanner.nextInt();

        System.out.println("请输入第2个数: ");
        int num2 = scanner.nextInt();

        System.out.println("请输入第2个数: ");
        int num3 = scanner.nextInt();

        if (num1 > num2) {
            System.out.println("最大值: " + (num1 > num3 ? num1 : num3));
        } else {
            System.out.println("最大值: " + (num2 > num3 ? num2 : num3));
        }
    }
}

运行结果：

2.3.2 求偶数

键盘录入一个数，求0到这个数之间的偶数个数；

package com.dfbz.demo01;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro: 求偶数
 */
public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入一个数: ");
        int num = scanner.nextInt();

        int j = 0;
        for (int i = 0; i < num; i += 2) {
            j++;
        }

        System.out.println("0-" + num + "之间的偶数个数为: " + j);
    }
}

三、Random类

3.1 Random类简介

Random类用于实现生产伪随机数，伪随机数，也就是有规则的随机，并不是真正的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。

相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同，第二次生成的随机数字也完全相同。这点在生成多个随机数字时需要特别注意。

下面介绍一下Random类的使用，以及如何生成指定区间的随机数组以及实现程序中要求的几率。

3.2 Random的类使用

Random类也是java.util包下的类，因此也需要导包；

3.2.1 构造方法

创建Random类：

Random r1 = new Random();

Random r2 = new Random(20);

3.2.2 常用方法

[：代表包含

)：代表不包含

3.2.3 使用示例

生成5个10以内的随机数：

package com.dfbz.demo01;

import java.util.Random;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        // 获取Random对象
        Random random = new Random();

        for (int i = 0; i < 5; i++) {
            int num = random.nextInt(10);
            System.out.println(num);
        }
    }
}

3.3 练习

3.3.1 生成指定的随机数

需求：使用键盘录入随机数的最大值，以及需要生成的随机数个数，使用循环随机生成指定个数的随机数；

package com.dfbz.demo01;

import java.util.Random;
import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro: 生成指定的随机数
 */
public class Demo02 {
    public static void main(String[] args) {

        // 获取键盘接收对象
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入随机数的最大值: ");
        int max = scanner.nextInt();

        System.out.println("请输入您要生成的随机数个数: ");
        int count = scanner.nextInt();

        // 获取随机数对象
        Random random = new Random();

        System.out.println("您的随机数为: ");
        // 循环count次(生成count个随机数)
        for (int i = 0; i < count; i++) {

            int num = random.nextInt(max);
            System.out.println(num);
        }

    }
}

3.3.2 点名小游戏

需求：提供一个名称数组，程序随机抽取一个名称；

package com.dfbz.demo01;

import java.util.Random;
import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro: 
 */
public class Demo03 {
    public static void main(String[] args) {

        // 定义数组
        String[] NationHero = {
                "精忠报国：岳飞",
            	"海疆英魂：邓世昌",
            	"抗倭英雄：戚继光",
                "虎门销烟：林则徐"
        };

        // 获取随机数对象
        Random random = new Random();

        int index = random.nextInt(NationHero.length);		// 生成0 ~ length-1的随机数

        System.out.println(NationHero[index]);

    }
}

运行结果如下：

3.3.3 猜拳小游戏

需求：使用Scanner录入一个数，再使用Random随机生成一个数与之对比，系统提示大了或者小了，直到玩家猜中，游戏结束。

package com.dfbz.demo01;

import java.util.Random;
import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo04 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Random r = new Random();

        while (true) {
            //  系统随机生成的
            int n = r.nextInt(100) + 1;     // 生成1-100的随机数
            System.out.println("请输入你要猜的数字(1‐100)：");

            // 用户手动输入的
            int i = in.nextInt();
            if (i > n) {
                System.out.println("您输入的是： " + i + ";系统生成的是： " + n + "---大了！！");
            } else if (i < n) {
                System.out.println("您输入的是： " + i + ";系统生成的是： " + n + "---小了！！");
            } else {
                System.out.println("您输入的是： " + i + ";系统生成的是： " + n + "---恭喜你答对了！！");
                break;
            }
        }
    }
}

运行结果：

四、Runtime类

4.1 Runtime简介

在java.lang包中定义的Runtime类封装了与虚拟机相关的一些方法，在每一个Java进程之中都会存在有一个Runtime类的对象。Runtime类可以获取当前程序运行信息、退出程序、关闭虚拟机等操作；

4.2 Runtime类的使用

4.2.1 获取Runtime类

Runtime的创建是由Java虚拟机来完成的，Java程序是不能自己来创建Runtime对象的；

Runtime的构造方法被私有，外界不能通过构造方法来创建Runtime类；

4.2.2 常用方法

4.2.3 使用示例

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        Runtime runtime = Runtime.getRuntime();

        long totalMemory = runtime.totalMemory();
        long maxMemory = runtime.maxMemory();
        long freeMemory = runtime.freeMemory();

        System.out.println("所有可用内存空间: " + totalMemory);
        System.out.println("最大可用内存空间: " + maxMemory);
        System.out.println("空余内存空间: " + freeMemory);

        // 执行酷狗应用程序
        runtime.exec("D:\\KuGou\\KGMusic\\KuGou.exe");
   
    }
}

五、Math类

5.1 Math类简介

java.lang.Math类包含执行基本数字运算的方法。为了使用简单，其方法大都是静态方法；

5.2 Math类的使用

5.2.1 常用方法

5.2.2 使用示例

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {

        // 绝对值
        int abs = Math.abs(-20);
        System.out.println(abs);                // 20

        // 向上取整
        double ceil = Math.ceil(30.2);
        System.out.println(ceil);               // 31.0

        // 向下取整
        double floor = Math.floor(28.9);
        System.out.println(floor);              // 28.0

        // 四舍五入
        long r1 = Math.round(20.3);
        System.out.println(r1);                 // 20

        // 四舍五入
        long r2 = Math.round(20.5);
        System.out.println(r2);                 // 21

        // 生成0~1的随机数
        for (int i = 0; i < 20; i++) {
            System.out.println(Math.random());
        }
    }
}

六、String类

6.1 String类简介

java.lang.String类是用于创建字符串的，创建后不可变，其值在创建之后将被视为常量。String类封装了字符串类型的相关操作方法；

6.2 String 类的使用

6.2.1 构造方法

• 举例：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] arg) {
        //1.String() 创建一个空的字符串对象
        String str1 = new String();
        System.out.println("str1: " + str1);        // 空字符

        // 2.String(String original) 根据字符串来创建一个字符串对象
        String str2 = new String("abc");
        System.out.println(str2);               // abc

        // 3.String(char[] value) 通过字符数组来创建字符串对象
        char[] chs = {'A', 'B', 'C', 'D', 'E'};
        String str3 = new String(chs);
        System.out.println(str3);           // ABCDE

        // 4.String(byte[] bytes) 通过字节数组来构造新的字符串对象
        byte[] bytes = {97, 98, 99, 100, 101};
        String str4 = new String(bytes);
        System.out.println(str4);            // abcde

        // 5.String(byte[] bytes, int offset, int length) 通过字节数组一部分来构造新的字符串对象
        String str5 = new String(bytes, 1, 2);
        System.out.println(str5);           // bc
    }
}

6.2.2 常用方法

1）比较功能方法

• 使用示例：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 字符串比较功能方法
 */
public class Demo02 {
    public static void main(String[] args) {

        //创建字符串对象
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "Hello";

        //  boolean equals(Object anObject) 将此字符串与指定对象进行比较。
        System.out.println(s1.equals(s2));      //true
        System.out.println(s1.equals(s3));      //false
        System.out.println("----------------");

        //  boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2));        //true
        System.out.println(s1.equalsIgnoreCase(s3));        //true
        System.out.println("----------------");

    }
}

2）获取功能方法

• 使用示例：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 字符串获取功能方法
 */
public class Demo03 {
    public static void main(String[] args) {

        String str = "HelloWorld";

        // public int length () ：返回此字符串的长度。
        System.out.println(str.length());           // 10
        System.out.println("---------------");

        // public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
        String str2 = str.concat("_Java");
        System.out.println(str2);                   // HelloWorld_Java
        System.out.println("---------------");

        // public char charAt (int index) ：返回指定索引处的 char值。
        char c1 = str2.charAt(0);
        char c2 = str2.charAt(1);
        System.out.println(c1);                     // H
        System.out.println(c2);                     // e
        System.out.println("---------------");

        // public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
        int a = str.indexOf("o");                   // 4
        int b = str.indexOf("l");                   // 2
        int c = str.indexOf("ll");                  // 2
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println("---------------");

    }
}

3）转换功能方法

• 使用示例：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 字符串转换功能方法
 */
public class Demo04 {
    public static void main(String[] args) {
        String str = "abc";

        // public char[] toCharArray () ：将此字符串转换为新的字符数组。
        char[] chars = str.toCharArray();       // a,b,c
        for (int i = 0; i < chars.length; i++) {
            System.out.print(chars[i] + ",");
        }
        System.out.println("\n-------------");

        // public byte[] getBytes ()：使用平台的默认字符集将该 String编码转换为新的字节数组。
        byte[] bytes = str.getBytes();          // 97,98,99
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + ",");
        }
        System.out.println("\n-------------");

        // public String toLowerCase() ：使用默认语言环境的规则将此 String所有字符转换为小写。
        String lowerCase = str.toLowerCase();
        System.out.println(lowerCase);          // abc
        System.out.println("-------------");

        // public String toUpperCase() ：将此 String所有字符转换为大写，使用默认语言环境的规则。
        String upperCase = str.toUpperCase();
        System.out.println(upperCase);          // ABC
        System.out.println("-------------");

        // public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。
        String str2 = "HelloWorld";
        String str3 = str2.replace("l", "L");
        System.out.println(str2);   //注意，replace会返回一个新的字符串，新字符串才是被替换后的。这里输出HelloWorld
        System.out.println(str3);   //HeLLoWorLd
    }
}

4）切割功能方法

• 使用示例：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 字符串切割功能方法
 */
public class Demo05 {
    public static void main(String[] args) {
        String str = "HelloWorld";
         /*
            public String substring (int beginIndex) ：返回一个子字符串，
            从beginIndex开始截取字符串到字符串结尾。
        */
        String sub1 = str.substring(5);
        System.out.println(sub1);
        System.out.println("---------------");

        /*
            public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到
            endIndex截取字符串。含beginIndex，不含endIndex。
        */
        String sub2 = str.substring(2, 4);
        System.out.println(sub2);
        System.out.println("---------------");


        String word = "大家好,我叫小灰,今年20岁";
        String[] words = word.split(","); //["大家好","我叫小灰","今年20岁"]
        for (int i = 0; i < words.length; i++) {
            System.out.println(words[i]);
        }
    }
}

6.3 常量池

常量池也是JVM中的一块内存区域，在JDK1.6及以前，常量池是存储在方法区的，在JDK1.7之后，常量池被划分到了堆内存。常量池存储的是普通字面量的常量，其存储的东西只会保存一份；

6.3.1 String字符串的比较

创建字符串的方式有很多种，不同的方式创建的字符串在内存中的表现形式是不一样的；因此我们在使用字符串做==比较时需要格外注意；因为==比较的是两个对象的内存地址值；

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo06 {
    public static void main(String[] args) {

        // 存储在常量池
        String s1 = "abc";

        // new的东西都存储在堆内存
        String s2 = new String("abc");

        // new的东西都存储在堆内存
        String s3 = new String("abc");

        System.out.println(s1);     // abc
        System.out.println(s2);     // abc
        System.out.println(s3);     // abc
        System.out.println(s1 == s2);     // false
        System.out.println(s2 == s3);     // false
    }
}

内存图解：

6.3.2 字符串的创建

我们之前就介绍过，String是一个不可变的字符序列，即字符串一旦创建就是不可变的；但我们在操作字符串时，字符串好像是可以拼接改变的，这究竟是怎么回事呢？

下列代码产生了几个字符串？

1）例1：

String s1="1";
s1="2";

答：2个，“1”、“2”；

2）例1：

String s1 = "10" + "1";

答：3个，“10”、“1”、“101”；并且3个都存储在常量池

3）例2：

String s1 = new String("abc");

答：2个，一个”abc”存储在常量池，另一个”abc”存储在堆内存；s1保存着堆内存中”abc”的引用；

4）例3：

String s1 = "10";
s1 += "1";			// s1=s1+"1";

• 答：3个，“10”、”1″存储在常量池，”101″存储在堆内存，s1保存着堆内存中”101″的引用；

tips：任何与变量相加的字符串都会产生一个新字符串，存储在堆内存；

总结：字符串一旦创建了就不能改变，如果改变了那也是创建了一个新的字符串将其返回，再也不是原来那个字符串了；

6.3.3 字符串的比较练习

在字符串拼接时，只要是和变量相加，其都会产生一个新的字符串；

观察如下代码：

int i = 1;

String s1 = "10" + i;
String s2 = "10" + i;

System.out.println(s1 == s2);           // false

将变量换成常量：

String s1 = "10" + 1;		
String s2 = "10" + 1;

System.out.println(s1 == s2);           // true

• 练习题：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo08 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        String s3 = "ab" + "c";
        String s4 = "ab" + new String("c");
        String s5 = new String("abc");
        String s6 = "a";
        String s7 = "bc";
        String s8 = s6 + s7;

        System.out.println(s1 == s2);       // true(都存储在常量池)
        System.out.println(s1 == s3);       // true(常量相加,生成的值也是在常量池,保留常量池中的引用)
        System.out.println(s1 == s4);       // false(只要是和变量相加,都会new出一份新的)
        System.out.println(s1 == s8);       // false(只要是和变量相加,都会new出一份新的)
        System.out.println(s4 == s5);       // false
    }
}

6.3.4 intern方法

• public String intern()：当调用intern方法时，如果常量池已经包含与equals()方法确定相当的字符串时（比较的是字符串内容而不是地址值），则返回来自常量池的字符串，否则将此字符串添加到常量池中并返回；

示例代码：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo09 {

    public static void main(String[] args) {
        String s1 = "1" + new String("1");

        // 查看常量池是否有"11"这个字符串,如果没有,则将"11"存入常量池,并返回常量池的地址
        String s2 = s1.intern();

        String s3 = "11";
        System.out.println(s2 == s3);			// true
    }
}

图解：

七、Arrays类

7.1 Arrays类简介

java.util.Arrays类是一个有关于数组操作的工具类，比如数组排序，搜索，拷贝，字符打印，数组转集合等操作。Arrays工具类中的方法均为静态方法，使用起来非常方便；

7.2 Arrays类的使用

7.2.1 常用方法

• public static String toString(int[] a)：返回该数组的字符串表示形式
• public static void sort(int[] a) ：对a数组进行升序排序
• public static void sort(int[] a, int fromIndex, int toIndex) ：对a数组指定范围内的元素进行排序
  • fromIndex：含
  • toIndex：不含
• public static int binarySearch(int[] a, int key)：使用搜索前必须使用sort方法进行排序，在a数组中搜索是否存在key这个元素
  • 如果搜索到：返回元素的索引
  • 如果没有搜索到：按顺序计算到key元素应该插入的位置index，最终返回(-index-1)的值
• public static int[] copyOf(int[] original, int newLength)：从original数组拷贝的0下标拷贝到newLength下标到新数组，并将新数组返回；其中0（含），newLength（不含）
• public static int[] copyOfRange(int[] original, int from, int to) ：从original数组拷贝的from下标拷贝到to下标到新数组，并将新数组返回；其中from（含），to（不含）
• public static boolean equals(int[] a, int[] a2)：比较两个数组中的元素是否相同；

7.2.1 使用示例

• 示例代码：

package com.dfbz.demo;

import java.util.Arrays;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {

        int[] arr1 = {32, 132, 19, 28, 17, 54};
        int[] arr2 = {32, 132, 19, 28, 17, 54};

        // 比较两个数组里面的元素是否相同
        System.out.println(Arrays.equals(arr1, arr2));           // true
    }

    public static void test6() {
        int[] arr = {32, 132, 19, 28, 17, 54};

        // 从0(包含)下标开始拷贝到4下标(不包含),将中间的元素放入新数组,并将新的数组返回
        int[] newArr_1 = Arrays.copyOfRange(arr, 0, 4);

        // 从2(包含)下标开始拷贝到4下标(不包含),将中间的元素放入新数组,并将新的数组返回
        int[] newArr_2 = Arrays.copyOfRange(arr, 2, 4);

        System.out.println(Arrays.toString(arr));           // [32, 132, 19, 28, 17, 54]
        System.out.println(Arrays.toString(newArr_1));      // [32, 132, 19, 28]
        System.out.println(Arrays.toString(newArr_2));      // [19, 28]
    }

    public static void test5() {
        int[] arr = {32, 132, 19};

        // 拷贝arr数组的0下标开始拷贝2个元素到新的数组,并将新数组返回
        int[] newArr = Arrays.copyOf(arr, 2);

        System.out.println(Arrays.toString(newArr));            // [32, 132]
    }

    /**
     * binarySearch()方法
     */
    public static void test4() {
        int[] arr = {32, 132, 19, 28, 17, 54};

        // 搜索前必须先排序
        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));           // [17, 19, 28, 32, 54, 132]

        // 在数组中搜索54
        int index = Arrays.binarySearch(arr, 54);       // 4
        System.out.println(index);

        int index2 = Arrays.binarySearch(arr, 35);      // 35插入的索引是:4, 最终查询到的索引位置是: (-4-1)=-5
        System.out.println(index2);                         // -5

        int index3 = Arrays.binarySearch(arr, 18);      // 18插入的索引是:1, 最终查询到的索引位置是: (-1-1)=-2
        System.out.println(index3);                         // -5
    }


    /**
     * sort()方法的其他使用
     */
    public static void test3() {
        int[] arr = {32, 132, 19, 28, 17, 54};
        System.out.println(Arrays.toString(arr));           // [32, 132, 19, 28, 17, 54]

        // 数组排序,排序0~3(不含)索引的元素
        Arrays.sort(arr, 0, 3);
        System.out.println(Arrays.toString(arr));           // [19, 32, 132, 28, 17, 54]
    }

    /**
     * sort()方法
     */
    public static void test2() {
        int[] arr = {32, 132, 19, 28, 17, 54};
        System.out.println(Arrays.toString(arr));           // [32, 132, 19, 28, 17, 54]

        // 数组排序(默认为升序排序)
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));           // [17, 19, 28, 32, 54, 132]
    }


    /**
     * toString()方法
     */
    public static void test() {
        int[] arr = {32, 132, 19, 28, 17, 54};

        String arrStr = Arrays.toString(arr);

        System.out.println(arrStr);    // [32, 132, 19, 28, 17, 54]
    }
}

上一篇：06【接口、多态】

下一篇：08【Java核心API-02】

目录：【JavaSE零基础系列教程目录】

记得点赞~！！！