Java基础学习笔记（六）—— 常用API（1）

引用类型使用步骤：

（1）导包

import 包名.类名;

注意：
只有java.lang包下的内容不需要导包，其他的包都需要import语句

（2）创建对象
使用该类的构造方法，创建一个该类的对象。 格式：

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

（3）调用方法

调用该类的成员方法，完成指定功能。 格式：

变量名.方法名();

扫描二维码关注公众号，回复： 14463296 查看本文章

1 Scanner类

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

import java.util.Scanner;

Scanner sc = new Scanner(System.in); 
int i = sc.nextInt();

注意：

• System.in系统输入指的是通过键盘录入数据。
• 获取键盘输入的一个int数字：int num = sc.nextInt();
• 获取键盘输入的一个字符串：String str = sc.next();

2 Random类

此类的实例用于生成伪随机数

Random r = new Random(); 
int i = r.nextInt();

注意：

• 产生1-10之间的随机数：int i = sc.nextInt(10)+1;
• 获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt()
• 获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3)
  实际上代表的含义是：[0,3)，也就是0~2

拓展：next()与nextLine()都可以用来接收字符串

• next() : 遇到了空格, 就不再录入数据了
  – 结束标记: 空格, tab键
• nextLine() : 可以将数据完整的接收过来
  – 结束标记: 回车换行符
• nextInt和nextLine方法都是以回车为结束符，二者配合使用的时候, nextLine方法就没有键盘录入的机会了。
  – 建议: 今后键盘录入数据的时候, 如果是字符串和整数一起接受, 建议使用next方法接收字符串.

案例：猜数字
需求：程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？当猜错的时候根据不同情况给出相应的提示

• 如果猜的数字比真实数字大，提示你猜的数据大了
• 如果猜的数字比真实数字小，提示你猜的数据小了
• 如果猜的数字与真实数字相等，提示恭喜你猜中了

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

public class Test {
    
    
	public static void main(String[] args){
    
    
		// 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
		Random r = new Random();
		Scanner sc = new Scanner(System.in);
		// 2. 使用Random产生一个1-100之间的数, 作为要猜的数
		int randomNum = r.nextInt(100) + 1;
		
		// 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
		while(true){
    
    
			// 3. 键盘录入用户猜的的数据
			System.out.println("请输入您猜的数据:");
			int num = sc.nextInt();
			// 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
			if(num > randomNum){
    
    
				System.out.println("猜大了");
			}else if(num < randomNum){
    
    
				System.out.println("猜小了");
			}else{
    
    
				// 6. 猜对之后, break结束.
				System.out.println("恭喜,猜中了");
				break; // 加了break，死循环后的语句可能可以执行到
			}
		}
		
		System.out.println("感谢您的使用"); // 死循环中，不加break该语句会报错
	}
}

3 String类

java.lang.String类代表字符串。
API当中说：Java 程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。
其实就是说：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。）

字符串的特点

• Java程序当中所有的双引号字符串，都是String类的对象
• 字符串是常量，它们的值在创建后不可以被更改
• 正是因为字符串不可改变，所以字符串是可以共享使用的（字符串常量池）
• 字符串效果上相当于是char[]字符数组，但是底层原理是被final 修饰的 byte[]字节数组

3.1 String类的构造方法

创建字符串的对象（创建对象的过程就是调用构造方法）

public static void main(String[] args) {
    
    
    // 使用空参构造
    String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。
    System.out.println("第1个字符串：" + str1);

    // 根据字符数组创建字符串
    char[] charArray = {
    
     'A', 'B', 'C' };
    String str2 = new String(charArray);
    System.out.println("第2个字符串：" + str2);

    // 根据字节数组创建字符串
    byte[] byteArray = {
    
     97, 98, 99 };
    String str3 = new String(byteArray);
    System.out.println("第3个字符串：" + str3);

    // 直接创建
    String str4 = "Hello";
    System.out.println("第4个字符串：" + str4);
}

注意：
String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址，而是该对象所记录的真实内容

3.2 创建字符串对象的区别

问题：构造方法可以创建对象，双引号也可以创建字符串对象，二者有什么区别？

（1）双引号创建字符串对象

以""方式直接给出字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，JVM都只会创建一个String对象并在字符串常量池中维护，字符串常量池从JDK7开始，从方法区挪到了堆内存中。

当使用双引号创建字符串对象的时候，系统会检查该字符串是否在字符串常量池中存在

• 不存在：创建
• 存在：不会重新创建，而是直接复用

（2）通过构造方法创建字符串对象，在堆内存中存储，每一次 new 都会申请新的内存空间，虽然内容相同，但是地址不同

注意：== 号作比较

• 对于基本类型来说，== 是进行【数值】的比较。
• 对于引用类型来说，== 是进行【地址值】的比较。

public static void main(String[] args) {
    
    
        String str1 = "abc";
        String str2 = "abc";
        System.out.println(str1 == str2); // true

        char[] charArray = {
    
    'a', 'b', 'c'};
        String str3 = new String(charArray);
		String str4 = new String(charArray);
		System.out.println(str3 == str4); // false

		String str5 = "abc";
        String str6 = "ab";
        String str7 = str6+"c";
        System.out.println(str5 == str7); // false

当字符串之间使用 + 号拼接时，系统底层会在堆内存自动创建一个StringBuilder对象，然后再调用其 append 方法完成拼接，最后再调用 toString 方法转为 String 类型

	    String str8 = "abc";
	    String str9 = "a"+"b"+"c";
	    System.out.println(str8 == str9); // true

Java存在常量优化机制，在编译的时候，就会将 “a”+“b”+“c” 拼接为 “abc”

3.3 字符串的常用方法

（1）判断功能的方法

== 是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

• public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
• public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

注意：

• equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
• 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
  推荐："abc".equals(str) 不推荐：str.equals("abc")

（2）获取功能的方法

• public int length () ：返回此字符串的长度。
• public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
• public char charAt (int index) ：返回指定索引处的 char值。
• public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
• public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
  public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到 endIndex截取字符串。含beginIndex，不含endIndex。

注意：

• 数组的长度：数组名.length
• 字符串的长度：字符串对象.length()

（3）转换功能的方法

• public char[] toCharArray () ：将此字符串转换为新的字符数组。
• public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
• public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使 用replacement字符串替换。备注：CharSequence意思就是说可以接受字符串类型。

public class Demo {
    
    
    public static void main(String[] args) {
    
    
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); // H
        System.out.println(chars.length); // 5
        System.out.println("==============");

        // 转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
    
    
            System.out.println(bytes[i]);
        }
        System.out.println("==============");

        // 字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1); // How do you do?
        System.out.println(str2); // H*w d* y*u d*?
        System.out.println("==============");
    }
}

（4）分割功能的方法

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

注意：
split方法的参数其实是一个正则表达式，如果按照英文句点 “.” 进行切分，必须写"\\."（两个反斜杠）

3.5 字符串的应用

（1）用户登陆

需求：已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示

public static void main(String[] args) {
    
    
    // 1. 已知用户名和密码，定义两个字符串表示即可
    String username = "admin";
    String password = "123456";
    // 2. 键盘录入要登录的用户名和密码，用 Scanner 实现
    Scanner sc = new Scanner(System.in);
    // 4. 用循环实现多次机会，这里的次数明确，采用for循环实现
    for (int i = 1; i <= 3; i++) {
    
    
        System.out.println("请输入用户名:");
        String scUsername = sc.nextLine();
        System.out.println("请输入密码:");
        String scPassword = sc.nextLine();
        // 3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
        if (username.equals(scUsername) && password.equals(scPassword)) {
    
    
            System.out.println("登录成功");
            break;
        } else {
    
    
            if (i == 3) {
    
    
                System.out.println("您的登录次数已达到今日上限, 请明天再来");
            } else {
    
    
                System.out.println("登录失败,您还剩余" + (3 - i) + "次机会");
            }

        }
    }

}

（2）遍历字符串

第一种方法

public static void main(String[] args) {
    
    
    //  1. 键盘录入一个字符串，用 Scanner 实现
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入:");
    String s = sc.nextLine();
    // 2. 遍历字符串，首先要能够获取到字符串中的每一个字符
    for(int i = 0; i < s.length(); i++){
    
    
        // i : 字符串的每一个索引
        char c = s.charAt(i);
        System.out.println(c);
    }
}

第二种方法

public static void main(String[] args) {
    
    
    //  1. 键盘录入一个字符串，用 Scanner 实现
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入:");
    String s = sc.nextLine();
    // 2. 将字符串拆分成字符数组
    char[] chars = s.toCharArray()
    for(int i = 0; i < chars.length; i++){
    
    
        // 3. 遍历字符数组
        System.out.println(chars[i]);
    }
}

4 StringBuilder类

StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲 区，通过某些方法调用可以改变该序列的长度和内容。

4.1 构造方法

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

public class Demo {
    
    
    public static void main(String[] args) {
    
    
        //空参数构造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);// bu1:

        //带字符串的构造方法
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);// bu2:abc
    }
}

4.2 常用方法

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

public class Demo {
    
    
    public static void main(String[] args) {
    
    
        // 创建StringBuilder对象
        StringBuilder bu = new StringBuilder();
        // 使用append方法往StringBuilder中添加数据
        // append方法返回的是this,调用方法的对象bu,this==bu
        StringBuilder bu2 = bu.append("abc");// 把bu的地址赋值给了bu2
        System.out.println(bu);// "abc"
        System.out.println(bu2);// "abc"
        System.out.println(bu==bu2);// 比较的是地址 true

        // 使用append方法无需接收返回值
        bu.append("abc");
        bu.append(1);
        bu.append(true);
        bu.append(8.8);
        bu.append('中');
        System.out.println(bu);// abc1true8.8中

        /*
            链式编程:方法返回值是一个对象,可以继续调用方法
         */
        System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase());
        bu.append("abc").append(1).append(true).append(8.8).append('中');
        System.out.println(bu);// abc1true8.8中

    }
}

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

StringBuilder和String可以相互转换:

• String->StringBuilder:可以使用StringBuilder的构造方法
  StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
• StringBuilder->String:可以使用StringBuilder中的toString方法
  public String toString()：将当前StringBuilder对象转换为String对象。

public class Demo {
    
    
    public static void main(String[] args) {
    
    
        //String->StringBuilder
        String str = "hello";
        System.out.println("str:"+str);// str:hello
        StringBuilder bu = new StringBuilder(str);
        //往StringBuilder中添加数据
        bu.append("world");
        System.out.println("bu:"+bu);// str:helloworld

        //StringBuilder->String
        String s = bu.toString();
        System.out.println("s:"+s);// s:helloworld
    }
}