07【Java核心API-01】

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.applet 创建applet小程序所需的类
java.awt 创建图形化界面和绘制图形图形所属的类
java.io 包含能提供多种输入/输出功能的类。
java.util 包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
java.text 包含了一些java格式化相关的类
java.sql 包含了java进行JDBC数据库编程的相关类/接口
java.lang 包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
java.nio 为输入/输出操作提供缓存的类
java.net 提供用于网络应用程序相关的类
javax.sql 对于java.sql包进行扩展，提供了一些扩展类，如数据源、XA协议等；
javax.swing 针对于AWT功能的升级、加强，提供更多、更丰富的UI组件类；
javax.net 对于java.net包的扩展，提供了许多网络应用扩展类；

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 常用方法

返回值 方法名 作用
boolean nextBoolean() 将输入的下一个标记扫描为布尔值，并返回该值。
byte nextByte() 将输入的下一个标记扫描为 byte
byte nextByte(int radix) 将输入的下一个标记扫描为 byte
double nextDouble() 将输入的下一个标记扫描为 double
float nextFloat() 将输入的下一个标记扫描为 float
int nextInt() 将输入的下一个标记扫描为 int
int nextInt(int radix) 将输入的下一个标记扫描为 int,radix用于指定进制（默认采用10进制）
String next() 获取输入的一行字符串
long nextLong() 将输入的下一个标记扫描为 long
short nextShort() 将输入的下一个标记扫描为 short

2.2.4 使用示例

package com.dfbz.demo01;

import java.util.Scanner;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_Scanner的基本用法 {
    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 Demo02_next方法 {
    public static void main(String[] args) {
        // 创建一个扫描器
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入一个字符串: ");
        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 Demo03_nextLine方法 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);

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

        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 Demo04_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 Demo05_Scanner小练习_01_求最大值 {
    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 Demo06_Scanner小练习_02_求偶数 {
    public static void main(String[] args) {
        // 创建一个扫描器
        Scanner scanner = new Scanner(System.in);

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

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

        /*for (int i = 0; i <= num; i++) {
            if (i % 2 == 0) {
                count++;
            }
        }*/

        System.out.println("0~" + num + "之间的偶数个数为【" + count + "】");
    }
}

三、Random类

3.1 Random类简介

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

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

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

3.2 Random的类使用

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

3.2.1 构造方法

构造方法 介绍
Random() 创建一个新的随机数生成器。
Random(long seed) 根据seed种子创建一个新的随机数生成器。

创建Random类：

Random r1 = new Random();

Random r2 = new Random(20);

3.2.2 常用方法

返回值 方法名 作用
boolean nextBoolean() 随机生成一个布尔值
double nextDouble() 随机生成一个[0~1)之间的double值
int nextInt() 在int的存储范围内随机生成一个int值
int nextInt(int bound) 随机生成一个[0~bound)之间的int数
float nextFloat() 随机生成一个[0~1)之间的float值
long nextLong() 在long的存储范围内随机生成一个long值

[：代表包含

)：代表不包含

3.2.3 使用示例

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

package com.dfbz.demo01;

import java.util.Random;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_Random的用法 {
    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_Random小练习_01_生成随机数 {
    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;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_Random小练习_02_点名程序 {
    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_Random小练习_03_猜拳 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Random random = new Random();

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

            // 用户手动输入的
            int playerNumber = in.nextInt();
            if (playerNumber > systemNumber) {
                System.out.println("您输入的是： " + playerNumber + ";系统生成的是： " + systemNumber + "---大了！！");
            } else if (playerNumber < systemNumber) {
                System.out.println("您输入的是： " + playerNumber + ";系统生成的是： " + systemNumber + "---小了！！");
            } else {
                System.out.println("您输入的是： " + playerNumber + ";系统生成的是： " + systemNumber + "---恭喜你答对了！！");
                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 常用方法

返回值 方法名 作用
Runtime public static getRuntime() 获取当前进程的Runtime实例
long maxMemory() Jvm能够从操作系统申请的最大内存，如果内存本身没有限制，则返回值Long.MAX_VALUE
long totalMemory() Jvm已经向操作系统申请的内存大小，也就是虚拟机这个进程已占用的所有内存。
long freeMemory() 获取JVM中的空闲内存量，JVM已经占用，但实际并未使用的内存
void gc() 运行垃圾回收器
Process exec(String command) 以单独的经常执行其他应用程序

4.2.3 使用示例

【获取Jvm内存信息】

package com.dfbz.demo;


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

        Runtime runtime = Runtime.getRuntime();

        // 最大内存
        long maxMemory = runtime.maxMemory();
        
        // 总的内存
        long totalMemory = runtime.totalMemory();
        
        // 空闲内存
        long freeMemory = runtime.freeMemory();

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

【执行应用程序】

package com.dfbz.demo01;

import java.io.IOException;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_Runtime执行应用程序 {
    public static void main(String[] args) throws IOException {     // 这里需要声明异常,否则编译出错
        Runtime runtime = Runtime.getRuntime();

        // 执行计算机的其他应用程序
        runtime.exec("D:\\KGMusic\\KuGou.exe");
    }
}

五、Math类

5.1 Math类简介

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

5.2 Math类的使用

5.2.1 常用方法

返回值 方法名 作用
int static abs(int a) 获取绝对值
double static ceil(doublea) 向上取整
double static floor(double a) 向下取整
long static round(double a) 四舍五入
double static random() 返回[0~1)的随机数

5.2.2 使用示例

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_Math的基本用法 {
    public static void main(String[] args) {

        System.out.println(Math.ceil(-3.3));            // -3.0
        System.out.println(Math.floor(-3.3));           // -4.0
        System.out.println(Math.floor(-3.7));           // -4.0
        System.out.println(Math.floor(-3.2));           // -3
    }

    public static void test1() {
        // 绝对值
        int abs = Math.abs(-20);
        System.out.println(abs);                // 20

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

        double ceil2 = Math.ceil(30.28);
        System.out.println(ceil2);               // 31.0

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

        double floor2 = Math.floor(28.97);
        System.out.println(floor2);              // 28.0

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

        long r2 = Math.round(20.49);
        System.out.println(r2);                 // 20

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

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

5.2.3 生成验证码小案例

先生成0~9之间的随机数：

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        for (int i = 0; i < 50000; i++) {
            // 0~9的随机数
            System.out.println(Math.random() * 9 + 1);
        }
    }
}

Math.random是生成一个0.xxx的数，假设其生成的随机数为0.9999999999999，那么乘以9的结果为8.999999999991，永远不可能到9；因此在这个基础上+1的结果为：9.999999999991，永远不可能到10；接着将其转换为int类型（向下取整）的结果为9；

但也有可能一开始随机数就生成为0.0000000000001，那么这个时候乘以9就是0.0000000000009，在这个基础上+1的结果就是1.00000000009，接着将其转换为int类型的结果为1；

所以Math.random() * 9 + 1生成的范围就是一个普通的一位数；范围为1~9；

以此类推：如果在Math.random() * 9 + 1的基础上*10，那么生成的最小值为：10.000000009，最大值为：99.9999999999999，转换为int类型的取值范围就是10~99，一个普通的二位数的取值范围；

以此类推：如果在Math.random() * 9 + 1的基础上*100，那么生成的最小值为：100.000000009，最大值为：999.9999999999999，转换为int类型的取值范围就是100~999，一个普通的三位数的取值范围；

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_Math生成验证码小案例 {
    public static void main(String[] args) {
        // 生成5个四位数验证码
        for (int i = 0; i < 5; i++) {
            int num = (int) ((Math.random() * 9 + 1) * 1000);
            System.out.println(num);
        }

        // 生成5个六位数验证码
        for (int i = 0; i < 5; i++) {
            int num = (int) ((Math.random() * 9 + 1) * 100000);
            System.out.println(num);
        }
    }
}

六、String类

6.1 String类简介

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

6.2 String 类的使用

6.2.1 构造方法

构造方法 介绍
String() 创建一个空的字符串对象
String(String original) 根据字符串来创建一个字符串对象
String(char[] value) 通过字符数组来创建字符串对象
String(byte[] bytes) 通过字节数组来构造新的字符串对象
String(byte[] bytes, int offset, int length) 通过字节数组一部分来构造新的字符串对象
  • 举例：
package com.dfbz.demo;


/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_字符串的构造方法 {
    public static void main(String[] args) {
        //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）比较功能方法

方法名 介绍
boolean equals (Object anObject) 将字符串与指定的字符串进行比较
boolean equalsIgnoreCase (String anotherString) 将字符串与指定的字符串进行比较，忽略大小写。
  • 使用示例：
package com.dfbz.demo;

/**
 * @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）获取功能方法

方法名 介绍
int length () 返回此字符串的长度。
String concat (String str) 将指定的字符串连接到该字符串的末尾。
char charAt (int index) 返回指定索引处的字符。
int indexOf (String str) 返回指定子字符串第一次出现在该字符串内的索引。
  • 使用示例：
package com.dfbz.demo;

/**
 * @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）转换功能方法

方法名 介绍
char[] toCharArray () 返回字符串的字符表示形式
byte[] getBytes () 返回字符串的字节表示形式
String toLowerCase() 将字符串转换为小写
String toUpperCase() 将字符串转换为大写
String replace (CharSequence target, CharSequence replacement) 将与target匹配的字符串使用replacement字符串替换。
  • 使用示例：
package com.dfbz.demo;

/**
 * @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）切割功能方法

方法名 介绍
String substring (int beginIndex) 返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
String substring (int beginIndex, int endIndex) 返回一个子字符串，从beginIndex到
String[] split(String regex) 将此字符串按照给定的regex（规则）拆分为字符串数组。
  • 使用示例：
package com.dfbz.demo;

/**
 * @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中的一块内存区域，不同版本的Jdk对常量池所存储的位置都做了一些调整：

  • 在JDK1.8以前：方法区是以永久代的方式实现（HotSpot），常量池是方法区的一部分，但方法区也存储在堆内存，常量池可以说在堆内存中。
  • 从JDK1.8开始：方法区被剥离出来，只不过实现方式不是永久代，此时的方法区叫元数据区，常量池也就在元数据区。

Tips：方法区是JVM的一个规范，实现方式有很多种；

6.3.1 String字符串的比较

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

package com.dfbz.demo;

/**
 * @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.demo;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo07_字符串常量池_小案例 {

    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

    }
}

上述代码，常量池中存储了【5】个字符串，堆内存中存储了【4】个字符串；

6.3.4 intern方法

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

示例代码：

package com.dfbz.demo;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo08_intern方法 {
    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 fromIndex, int toIndex)：从original数组拷贝的from下标拷贝到to下标到新数组，并将新数组返回；其中fromIndex（含），toIndex（不含）
  • public static boolean equals(int[] a, int[] a2)：比较两个数组中的元素是否相同；

1） 返回字符串表示形式

package com.dfbz.demo01;

import java.util.Arrays;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_toString方法 {
    public static void main(String[] args) {
        int[] arr = {32, 132, 19, 28, 17, 54};

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

2） 排序数组

package com.dfbz.demo01;

import java.util.Arrays;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_排序数组 {

    /**
     * sort()方法的其他使用
     */
    public static void main(String[] args) {
        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 test01(String[] args) {
        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]
    }
}

3） 搜索元素

package com.dfbz.demo01;

import java.util.Arrays;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_搜索元素 {
    public static void main(String[] args) {
        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
    }
}

4） 拷贝元素

package com.dfbz.demo01;

import java.util.Arrays;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo04_拷贝数组元素 {
    public static void main(String[] args) {
        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 test1() {
        int[] arr = {32, 132, 19};

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

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

5） 比较数组元素

package com.dfbz.demo01;

import java.util.Arrays;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo05_比较数组元素 {
    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
    }
}
posted @ 2023-02-09 13:43  绿水长流*z  阅读(123)  评论(0)    收藏  举报