day07【Java核心API-01】

绝地灬酷狼 2022-09-02 11:34 161阅读 0赞

# day07【Java核心API-01】 #

# 一、API概述 #

## 1.1 API概述 ##

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

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

## 1.2 Java常用包介绍 ##

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

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

> 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/

我们打开查看：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]

> 在线地址（中文版）：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 常用方法 ###

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法名</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>boolean</code></td> 
   <td><code>nextBoolean()</code></td> 
   <td>将输入的下一个标记扫描为布尔值，并返回该值。</td> 
  </tr> 
  <tr> 
   <td><code>byte</code></td> 
   <td><code>nextByte()</code></td> 
   <td>将输入的下一个标记扫描为 <code>byte</code> 。</td> 
  </tr> 
  <tr> 
   <td><code>byte</code></td> 
   <td><code>nextByte(int radix)</code></td> 
   <td>将输入的下一个标记扫描为 <code>byte</code> 。</td> 
  </tr> 
  <tr> 
   <td><code>double</code></td> 
   <td><code>nextDouble()</code></td> 
   <td>将输入的下一个标记扫描为 <code>double</code> 。</td> 
  </tr> 
  <tr> 
   <td><code>float</code></td> 
   <td><code>nextFloat()</code></td> 
   <td>将输入的下一个标记扫描为 <code>float</code> 。</td> 
  </tr> 
  <tr> 
   <td><code>int</code></td> 
   <td><code>nextInt()</code></td> 
   <td>将输入的下一个标记扫描为 <code>int</code> 。</td> 
  </tr> 
  <tr> 
   <td><code>int</code></td> 
   <td><code>nextInt(int radix)</code></td> 
   <td>将输入的下一个标记扫描为 <code>int</code> 。</td> 
  </tr> 
  <tr> 
   <td><code>String</code></td> 
   <td><code>next()</code></td> 
   <td>获取输入的一行字符串</td> 
  </tr> 
  <tr> 
   <td><code>long</code></td> 
   <td><code>nextLong()</code></td> 
   <td>将输入的下一个标记扫描为 <code>long</code> 。</td> 
  </tr> 
  <tr> 
   <td><code>short</code></td> 
   <td><code>nextShort()</code></td> 
   <td>将输入的下一个标记扫描为 <code>short</code> 。</td> 
  </tr> 
 </tbody> 
</table>

### 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);
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]

## 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));
            }
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]

### 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 构造方法 ###

<table> 
 <thead> 
  <tr> 
   <th>构造方法</th> 
   <th>介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Random()</code></td> 
   <td>创建一个新的随机数生成器。</td> 
  </tr> 
  <tr> 
   <td><code>Random(long seed)</code></td> 
   <td>根据seed种子创建一个新的随机数生成器。</td> 
  </tr> 
 </tbody> 
</table>

创建Random类：

Random r1 = new Random();
    
    Random r2 = new Random(20);

### 3.2.2 常用方法 ###

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法名</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int</td> 
   <td><code>nextBoolean()</code></td> 
   <td>随机生成一个布尔值</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td><code>nextDouble()</code></td> 
   <td>随机生成一个<code>[0~1)</code>之间的double值</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td><code>nextInt()</code></td> 
   <td>在int的存储范围内随机生成一个int值</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td><code>nextInt(int bound)</code></td> 
   <td>随机生成一个<code>[0~bound)</code>之间的int数</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td><code>nextFloat()</code></td> 
   <td>随机生成一个<code>[0~1)</code>之间的float值</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td><code>nextLong()</code></td> 
   <td>在long的存储方位内随机生成一个long值</td> 
  </tr> 
 </tbody> 
</table>

> `[`：代表包含
> 
> `)`：代表不包含

### 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);
            }
    
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]

### 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]);
    
        }
    }

运行结果如下：

![在这里插入图片描述][5095a26d18d0421ab2221ab9420c31bd.png_pic_center]

### 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;
                }
            }
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]

# 四、Runtime类 #

## 4.1 Runtime简介 ##

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

## 4.2 Runtime类的使用 ##

### 4.2.1 获取Runtime类 ###

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]

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

### 4.2.2 常用方法 ###

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法名</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Runtime</td> 
   <td>public static getRuntime()</td> 
   <td>获取当前进程的Runtime实例</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>totalMemory()</td> 
   <td>获取JVM总的内存量（字节）</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>maxMemory()</td> 
   <td>获取JVM使用的最大内存量（字节）</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>freeMemory()</td> 
   <td>获取JVM中的空闲内存量（字节）</td> 
  </tr> 
  <tr> 
   <td>void</td> 
   <td>gc()</td> 
   <td>运行垃圾回收器</td> 
  </tr> 
  <tr> 
   <td>Process</td> 
   <td>exec(String command)</td> 
   <td>以单独的经常执行其他应用程序</td> 
  </tr> 
 </tbody> 
</table>

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

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

### 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 构造方法 ###

<table> 
 <thead> 
  <tr> 
   <th>构造方法</th> 
   <th>介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String()</td> 
   <td>创建一个空的字符串对象</td> 
  </tr> 
  <tr> 
   <td>String(String original)</td> 
   <td>根据字符串来创建一个字符串对象</td> 
  </tr> 
  <tr> 
   <td>String(char[] value)</td> 
   <td>通过字符数组来创建字符串对象</td> 
  </tr> 
  <tr> 
   <td>String(byte[] bytes)</td> 
   <td>通过字节数组来构造新的字符串对象</td> 
  </tr> 
  <tr> 
   <td>String(byte[] bytes, int offset, int length)</td> 
   <td>通过字节数组一部分来构造新的字符串对象</td> 
  </tr> 
 </tbody> 
</table>

*  举例：

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）比较功能方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>boolean equals (Object anObject)</code></td> 
   <td>将字符串与指定的字符串进行比较</td> 
  </tr> 
  <tr> 
   <td><code>boolean equalsIgnoreCase (String anotherString)</code></td> 
   <td>将字符串与指定的字符串进行比较，忽略大小写。</td> 
  </tr> 
 </tbody> 
</table>

*  使用示例：

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）获取功能方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>int length ()</code></td> 
   <td>返回此字符串的长度。</td> 
  </tr> 
  <tr> 
   <td><code>String concat (String str)</code></td> 
   <td>将指定的字符串连接到该字符串的末尾。</td> 
  </tr> 
  <tr> 
   <td><code>char charAt (int index)</code></td> 
   <td>返回指定索引处的字符。</td> 
  </tr> 
  <tr> 
   <td><code>int indexOf (String str)</code></td> 
   <td>返回指定子字符串第一次出现在该字符串内的索引。</td> 
  </tr> 
 </tbody> 
</table>

*  使用示例：

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）转换功能方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>char[] toCharArray ()</code></td> 
   <td>返回字符串的字符表示形式</td> 
  </tr> 
  <tr> 
   <td><code>byte[] getBytes ()</code></td> 
   <td>返回字符串的字节表示形式</td> 
  </tr> 
  <tr> 
   <td><code>String toLowerCase()</code></td> 
   <td>将字符串转换为小写</td> 
  </tr> 
  <tr> 
   <td><code>String toUpperCase()</code></td> 
   <td>将字符串转换为大写</td> 
  </tr> 
  <tr> 
   <td><code>String replace (CharSequence target, CharSequence replacement)</code></td> 
   <td>将与target匹配的字符串使用replacement字符串替换。</td> 
  </tr> 
 </tbody> 
</table>

*  使用示例：

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）切割功能方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>String substring (int beginIndex)</code></td> 
   <td>返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。</td> 
  </tr> 
  <tr> 
   <td><code>String substring (int beginIndex, int endIndex)</code></td> 
   <td>返回一个子字符串，从beginIndex到</td> 
  </tr> 
  <tr> 
   <td><code>String[] split(String regex)</code></td> 
   <td>将此字符串按照给定的regex（规则）拆分为字符串数组。</td> 
  </tr> 
 </tbody> 
</table>

*  使用示例：

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
        }
    }

内存图解：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]

### 6.3.2 字符串的创建 ###

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

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

#### 1）例1： ####

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]

#### 2）例1： ####

String s1 = "10" + "1";

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]

#### 3）例2： ####

String s1 = new String("abc");

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]

#### 4）例3： ####

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

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]

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

### 6.3.3 字符串的比较练习 ###

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

观察如下代码：

int i = 1;
    
    String s1 = "10" + i;
    String s2 = "10" + i;
    
    System.out.println(s1 == s2);           // false

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]

将变量换成常量：

String s1 = "10" + 1;		
    String s2 = "10" + 1;
    
    System.out.println(s1 == s2);           // true

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]

*  练习题：

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
        }
    }

图解：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]

--------------------

**上一篇**：[day06【接口、多态】][day06]

**下一篇**：[day08【Java核心API-02】][day08_Java_API-02]

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

--------------------

# 记得点赞~！！！ #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/8897626e51094466bf234a119abbf498.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/e6d3e45432c74dec96e9a6b28a58f9d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/7d2923a95243420bbba26336f91c89b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220829/1dc7278ac1b14002bfd23bde55cadf42.png
[5095a26d18d0421ab2221ab9420c31bd.png_pic_center]: /images/20220829/73b657ddf44b41ad9ec39c4398af247a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220829/4408cd8827ab4809b4176fa1d8c37a63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20220829/d1e9333c5d134d9d94bdef5113c57042.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20220829/0291d92f9a1748f1bfced77327f4a142.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20220829/6377d05344af479293480d5f2e283c7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20220829/1343bcd514104696980168cd00ddd22a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20220829/ec98589c2a954a5fb04461684390de1e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20220829/b156bbc237fa4ffcae65a6208e473876.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20220829/a952cdf3384e4cc696cfe7d8ed3b5eac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20220829/42b1175d89bd4445971a33676eeab561.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20220829/f57e6b77339e490586f283d8f339eb5c.png
[day06]: https://blog.csdn.net/Bb15070047748/article/details/119255557?spm=1001.2014.3001.5501
[day08_Java_API-02]: https://blog.csdn.net/Bb15070047748/article/details/119348121?spm=1001.2014.3001.5501