1. API

1. API概述

什么是API

API (Application Programming Interface) ：应用程序编程接口
java中的API

指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

如何使用API帮助文档 :

打开帮助文档
找到索引选项卡中的输入框
在输入框中输入Random
看类在哪个包下
看类的描述
看构造方法
看成员方法

2. Scanner类

1. 什么是Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。例如，以下代码使用户能够从 System.in 中读取一个数：

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

备注：System.in 系统输入指的是通过键盘录入数据。

2. 引用类型使用步骤

导包

使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。格式：

import 包名.类名;

例：

java.util.Scanner;

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

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

例：

Scanner sc = new Scanner(System.in);

调用方法

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

变量名.方法名();

例：

int i = sc.nextInt(); // 接收一个键盘录入的整数

3. 常用方法

在这里插入图片描述

4. Scanner类的使用步骤

查看类

java.util.Scanner ：该类需要import导入后使用。

查看构造方法

public Scanner(InputStream source) : 构造一个新的 Scanner ，它生成的值是从指定的输入流扫描的。

查看成员方法

public int nextInt() ：将输入信息的下一个标记扫描为一个 int 值。

使用Scanner类，完成接收键盘录入数据的操作，代码如下：

//1. 导包
import java.util.Scanner;
public class Demo01_Scanner {
	public static void main(String[] args) {
		//2. 创建键盘录入数据的对象
		Scanner sc = new Scanner(System.in);
		//3. 接收数据
		System.out.println("请录入一个整数：");
		int i = sc.nextInt();
		//4. 输出数据
		System.out.println("i:"+i);
	}
}

5. 练习

求和
键盘录入两个数据并求和，代码如下：

import java.util.Scanner;
public class Test01Scanner {
	public static void main(String[] args) {
		// 创建对象
		Scanner sc = new Scanner(System.in);
		// 接收数据
		System.out.println("请输入第一个数据：");
		int a = sc.nextInt();
		System.out.println("请输入第二个数据：");
		int b = sc.nextInt();
		// 对数据进行求和
		int sum = a + b;
		System.out.println("sum:" + sum);
	}
}

获取最大值
键盘录入三个数据并获取最大值，代码如下：

import java.util.Scanner;
public class Test02Scanner {
		public static void main(String[] args) {
		// 创建对象
		Scanner sc = new Scanner(System.in);
		// 接收数据
		System.out.println("请输入第一个数据：");
		int a = sc.nextInt();
		System.out.println("请输入第二个数据：");
		int b = sc.nextInt();
		System.out.println("请输入第三个数据：");
		int c = sc.nextInt();
		// 如何获取三个数据的最大值
		int temp = (a > b ? a : b);
		int max = (temp > c ? temp : c);
		System.out.println("max:" + max);
	}
}

3. Random类

1. Random类概述

此类的实例用于生成伪随机数。
例如，以下代码使用户能够得到一个随机数：

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

2. 常用方法

1. random.nextInt()

random.nextIn()的作用是随机生成一个int类型，因为int 的取值范围是 -2147483648——2147483647 ，所以生成的数也是处于这个范围，下面是示例代码。

Random random = new Random();
System.out.println("int:"+random.nextInt());
System.out.println("Integer.MIN-Integer.MAX:"+Integer.MIN_VALUE+"-"+Integer.MAX_VALUE);

输出：
int:-1849568817
Integer.MIN-Integer.MAX:-2147483648-2147483647

在上述代码中，我们使用了Integer.MIN_VALUE和Integer.MAX_VALUE，这两个是Integer类设定的最小值和最大值。在Java的八种基础数据类型中，除了boolean为true和false之外，其他的七种类型都是有MIN_VALUE和MAX_VALUE这两个值的，所以我们可以通过这几种基础数据类型相对应的引用数据类型+.MIN_VALUE或.MAX_VALUE就可以得到基础数据类型的最大值和最小值。

2. random.nextInt(int bound)

random.nextInt(int bound)方法的作用是生成一个0-参数bound范围内的随机数，但是要记住，参数bound必须是正数，不可为负数，否则在运行时会报java.lang.IllegalArgumentException: bound must be positive的错误，提示bound必须是正数，下面看用法：

Random random = new Random();
System.out.println("int:"+random.nextInt(20));

输出：
int:12

3. random.nextLong()

random.nextLong()会随机生成一个Long类型，同理，因为Long的取值范围是 -9223372036854775808——9223372036854775807，所以也会生成一个这个区间的数。

Random random = new Random();
System.out.println("Long:"+random.nextLong());
System.out.println("Long.MIN-Long.MAX:"+Long.MIN_VALUE+"-"+Long.MAX_VALUE);

输出：
Long:-5059225360401714325
Long.MIN-Long.MAX:-9223372036854775808-9223372036854775807

4. random.nextDouble()

random.nextDouble()会生成一个[0,1.0)的double类型，而不是生成double取值范围中的数，下附取值范围，就不多说了。

Random random = new Random();
System.out.println("double:"+random.nextDouble());

输出：
double:0.9059561641891956

5. random.nextFloat()

random.nextFloat()会生成一个随机的0-1之间的浮点型，大体同double一样，下附取值范围。

Random random = new Random();
System.out.println("float:"+random.nextFloat());
System.out.println("Float.MIN-Float.MAX:"+Float.MIN_VALUE+"-"+Float.MAX_VALUE);

输出：
float:0.56538385
Float.MIN-Float.MAX:1.4E-45-3.4028235E38

6. random.nextBoolean()

random.nextBoolean()会生成一个true或false，这个想必就不用多说了。

Random random = new Random();
System.out.println("boolean:"+random.nextBoolean());

输出：
boolean:false

7. random.nextBytes(byte[] bytes)

random.nextBytes()会为一个byte类型的数组随机赋值，具体如下所示：

Random random = new Random();

byte[] bytes = new byte[5];

random.nextBytes(bytes);
for (int i = 0; i < bytes.length; i++) {
	byte aByte = bytes[i];
	System.out.print(aByte+"\n");
}

输出：
25
43
75
-84
-36

因为byte的取值范围为 -128到127，所以也就是说会为一个byte类型的数组在-128,127这个区间内重新随机赋值，此处“重新随机赋值”划重点，也就是说，即使原本的byte数组里面有值，那么也会重新覆盖掉，看下面的例子：

Random random = new Random();

byte[] bytes = {1,2,3,4,5};

random.nextBytes(bytes);
for (int i = 0; i < bytes.length; i++) {
	byte aByte = bytes[i];
	System.out.print(aByte+"\n");
}

输出：
15
82
-67
74
72

8. random.nextGaussian()

random.nextGaussian()的作用是随机生成一个高斯分布的浮点数.

Random random = new Random();
for (int i = 0; i < 50; i++) {
	if(i % 5 == 0){
		System.out.print("\n");
	}
	System.out.print(random.nextGaussian()+"\t");
}

输出
0.23887985879210802	-0.9617517115209373	-0.7310298442527218	0.060675255123321455	2.3028675413581086	
0.4807480559098755	0.19749526765375996	1.107307002104576	0.8729308549572491	1.7926021967090964	
-0.05935633370030737	-2.3210221850587227	-0.6377865724068819	-0.7626926952975743	-1.1944252800370256	
-0.0950028233550837	0.32367629717018137	-0.38937823661336124	0.9536905904785448	0.44357226494324903	
2.083500311831977	-0.23015961529101175	1.4646049357930837	1.3345713742936534	0.1665529809249803	
1.3165533068264064	0.3256581547018778	0.2285771381453708	-0.5689451870599477	-1.265991294683088	
-1.5566759317562093	0.30847902615010453	0.6697716213007865	0.6214732015551208	0.46187917219586727	
-0.4990443240348566	-0.6353880042505946	0.8433862988590144	1.6690553001008204	0.18505536592837407	
-0.28148806860582576	-0.16037858145085357	6.709333136467725E-4	-0.1860336557308238	0.5554098841671794	
0.044651030125437315	-0.14404705820536534	0.047725565972889454	0.43339518441476116	1.1141049066539972

9. 猜数字小游戏

游戏开始时，会随机生成一个1-100之间的整数 number 。玩家猜测一个数字 guessNumber ，会与 number 作比
较，系统提示大了或者小了，直到玩家猜中，游戏结束。

// 导包
import java.util.Random;
public class Test02Random {
	public static void main(String[] args) {
	// 系统产生一个随机数1‐100之间的。
	Random r = new Random();
	int number = r.nextInt(100) + 1;
	while(true){
		// 键盘录入我们要猜的数据
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你要猜的数字(1‐100)：");
		int guessNumber = sc.nextInt();
		// 比较这两个数据(用if语句)
		if (guessNumber > number) {
			System.out.println("你猜的数据" + guessNumber + "大了");
			} else if (guessNumber < number) {
			System.out.println("你猜的数据" + guessNumber + "小了");
			} else {
			System.out.println("恭喜你,猜中了");
			break;
			}
		}
	}
}

4. String类

1. 概述

String 类在 java.lang 包下，所以使用的时候不需要导包
String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象
字符串不可变，它们的值在创建后不能被更改

2. String类的构造方法

常用的构造方法
在这里插入图片描述

public class Demo2StringConstructor {
    /*
        String类常见构造方法:

            public String() : 创建一个空白字符串对象，不含有任何内容
            public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
            public String(String original) : 根据传入的字符串内容，来创建字符串对象
            String s = “abc”;  直接赋值的方式创建字符串对象，内容就是abc

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

                面向对象-继承, Object类
     */
    public static void main(String[] args) {
        // public String() : 创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println(s1);

        // public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
        char[] chs = {'a','b','c'};
        String s2 = new String(chs);
        System.out.println(s2);

        // public String(String original) : 根据传入的字符串内容，来创建字符串对象
        String s3 = new String("123");
        System.out.println(s3);
    }
}

4. 创建字符串对象的区别比较

通过构造方法创建

通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
直接赋值方式创建

以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

5. 字符串的比较

== 比较基本数据类型：比较的是具体的值
== 比较引用数据类型：比较的是对象地址值
String类 : public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写
代码

public class Demo1Equals {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "ABC";
        String s3 = "abc";

        // equals : 比较字符串内容, 区分大小写
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));

        // equalsIgnoreCase : 比较字符串内容, 忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2));
    }
}

6. 用户登录案例

案例需求 :

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

实现步骤 :

已知用户名和密码，定义两个字符串表示即可
键盘录入要登录的用户名和密码，用 Scanner 实现
拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
字符串的内容比较，用equals() 方法实现
用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循

import java.util.Scanner;

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

        思路：
        1. 已知用户名和密码，定义两个字符串表示即可
        2. 键盘录入要登录的用户名和密码，用 Scanner 实现
        3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
            字符串的内容比较，用equals() 方法实现
        4. 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环

     */
    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) +"次机会");
                }

            }
        }

    }
}

7. 判断功能的方法

public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。
boolean startWith(String str)：判断字符串是否以另一个字符串开头,是开头就返回true
boolean endsWith(String str)：判断字符串是否以另一个字符串结尾,是结尾就返回true
boolean contains(String str) ：判断字符串中是否包含另一个字符串,完全包含返回true
boolean isEmpty()：判断字符串的长度是不是0,如果是0返回true

方法演示，代码如下：

public class String_Demo01 {
	public static void main(String[] args) {
		// 创建字符串对象
		String s1 = "hello";
		String s2 = "hello";
		String s3 = "HELLO";
		
		// boolean equals(Object obj):比较字符串的内容是否相同
		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("‐‐‐‐‐‐‐‐‐‐‐");

		 //boolean startWith(String str)判断字符串是否以另一个字符串开头,是开头就返回true
        b = "HelloWorld.Java".startsWith("Hello");

        System.out.println(b);
        b = "HelloWorld.Java".endsWith(".Java");
        System.out.println("=============");
        System.out.println(b);

        //boolean contains(String str) 判断字符串中是否包含另一个字符串,完全包含返回true
       b = "how are you".contains("are  ");
        System.out.println("=============");
        System.out.println(b);

        //boolean isEmpty()判断字符串的长度是不是0,如果是0返回true
        b = "".isEmpty();
        System.out.println("=============");
        System.out.println(b);
	}
}

8. 获取功能的方法

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。

方法演示，代码如下：

public class String_Demo02 {
	public static void main(String[] args) {
		//创建字符串对象
		String s = "helloworld";
		// int length():获取字符串的长度，其实也就是字符个数
		System.out.println(s.length());
		System.out.println("‐‐‐‐‐‐‐‐");
		// String concat (String str):将将指定的字符串连接到该字符串的末尾.
		String s = "helloworld";
		String s2 = s.concat("**hello itheima");
		System.out.println(s2);// helloworld**hello itheima
		// char charAt(int index):获取指定索引处的字符
		System.out.println(s.charAt(0));
		System.out.println(s.charAt(1));
		System.out.println("‐‐‐‐‐‐‐‐");
		// int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
		System.out.println(s.indexOf("l"));
		System.out.println(s.indexOf("owo"));
		System.out.println(s.indexOf("ak"));
		System.out.println("‐‐‐‐‐‐‐‐");
		// String substring(int start):从start开始截取字符串到字符串结尾
		System.out.println(s.substring(0));
		System.out.println(s.substring(5));
		System.out.println("‐‐‐‐‐‐‐‐");
		// String substring(int start,int end):从start到end截取字符串。含start，不含end。
		System.out.println(s.substring(0, s.length()));
		System.out.println(s.substring(3,8));
	}
}

9. 转换功能的方法

String toLowerCase()：字符串中的所有内容转成小写
String toUpperCase()：字符串中的所有内容转成大写
public char[] toCharArray () ：将此字符串转换为新的字符数组。
public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。
static String valueOf(任意类型参数)：参数转成字符串对象

方法演示，代码如下：

public class String_Demo03 {
	public static void main(String[] args) {
		//- String toLowerCase() 字符串中的所有内容转成小写
        // - String toUpperCase() 字符串中的所有内容转成大写
        String str = "abCDefGHJktyM";
        String lower = str.toLowerCase();
        String upper = str.toUpperCase();
        System.out.println("lower = " + lower);
        System.out.println("upper = " + upper);
		
		//创建字符串对象
		String s = "abcde";
	
		// char[] toCharArray():把字符串转换为字符数组
		char[] chs = s.toCharArray();
		for(int x = 0; x < chs.length; x++) {
			System.out.println(chs[x]);
		}
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
		// byte[] getBytes ():把字符串转换为字节数组
		byte[] bytes = s.getBytes();
		for(int x = 0; x < bytes.length; x++) {
		System.out.println(bytes[x]);
		}
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
		// 替换字母it为大写IT
		String str = "itcast itheima";
		String replace = str.replace("it", "IT");
		System.out.println(replace); // ITcast ITheima
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

		// static String valueOf(任意类型参数) 参数转成字符串对象
        int i = 1;
        String strI = String.valueOf(i);
        System.out.println(strI+1);
	}
}

10. 分割、替换、去空格功能

String trim()：去掉字符串两边空格,中间空格不去掉
String replace(String oldString,String newString)：替换字符串
public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

public class String_Demo03 {
	public static void main(String[] args) {
		//String trim() 去掉字符串两边空格,中间空格不去掉
        String str = "  abc  def       ";
        System.out.println(str);
        str = str.trim();
        System.out.println("str = " + str);
        
		//String[] split("规则字符串") 对字符串进行切割
		String s = "aa|bb|cc";
		String[] strArray = s.split("|"); // ["aa","bb","cc"]
		for(int x = 0; x < strArray.length; x++) {
			System.out.println(strArray[x]); // aa bb cc
		}
		
		//String replace(String oldString,String newString)替换字符串
        String repStr = "how do you do";
        repStr = repStr.replace("o","N");
        System.out.println("repStr = " + repStr);
	}
}

11. 拼接字符串练习

定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。

public class StringTest1 {
public static void main(String[] args) {
	//定义一个int类型的数组
	int[] arr = {1, 2, 3};
	//调用方法
	String s = arrayToString(arr);
	//输出结果
	System.out.println("s:" + s);
	}
	/*
	* 写方法实现把数组中的元素按照指定的格式拼接成一个字符串
	* 两个明确：
	* 返回值类型：String
	* 参数列表：int[] arr
	*/
	public static String arrayToString(int[] arr) {
		// 创建字符串s
		String s = new String("[");
		// 遍历数组，并拼接字符串
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length ‐ 1) {
				s = s.concat(arr[x] + "]");
			} else {
				s = s.concat(arr[x] + "#");
			}
		}
	return s;
	}
}

12. 统计字符个数

键盘录入一个字符，统计字符串中大小写字母及数字字符个数

public class StringTest2 {
	public static void main(String[] args) {
		//键盘录入一个字符串数据
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串数据：");
		String s = sc.nextLine();
		//定义三个统计变量，初始化值都是0
		int bigCount = 0;
		int smallCount = 0;
		int numberCount = 0;
		//遍历字符串，得到每一个字符
		for(int x=0; x<s.length(); x++) {
			char ch = s.charAt(x);
			//拿字符进行判断
			if(ch>='A'&&ch<='Z') {
				bigCount++;
			}else if(ch>='a'&&ch<='z') {
				smallCount++;
			}else if(ch>='0'&&ch<='9') {
				numberCount++;
			}else {
				System.out.println("该字符"+ch+"非法");
			}
		}
		//输出结果
		System.out.println("大写字符："+bigCount+"个");
		System.out.println("小写字符："+smallCount+"个");
		System.out.println("数字字符："+numberCount+"个");
	}
}

13. 手机号屏蔽–字符串截取

案例需求 :

以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
最终效果为：156****1234

实现步骤 :

键盘录入一个字符串，用 Scanner 实现
截取字符串前三位
截取字符串后四位
将截取后的两个字符串，中间加上****进行拼接，输出结果

代码实现 :

import java.util.Scanner;

public class Test5 {
    /*
        需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
        最终效果为：156****1234

        思路：
        1. 键盘录入一个字符串，用 Scanner 实现
        2. 截取字符串前三位
        3. 截取字符串后四位
        4. 将截取后的两个字符串，中间加上****进行拼接，输出结果

     */
    public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号:");
        String telString = sc.nextLine();
        // 2. 截取字符串前三位
        String start = telString.substring(0,3);
        // 3. 截取字符串后四位
        String end = telString.substring(7);
        // 4. 将截取后的两个字符串，中间加上****进行拼接，输出结果
        System.out.println(start + "****" + end);
    }
}

14. 敏感词替换–字符串替换

案例需求 :

键盘录入一个字符串，如果字符串中包含（TMD），则使用***替换

实现步骤 :

键盘录入一个字符串，用 Scanner 实现
替换敏感词
String replace(CharSequence target, CharSequence replacement)
将当前字符串中的target内容，使用replacement进行替换，返回新的字符串
输出结果

代码实现 :

import java.util.Scanner;

public class Test6 {
    /*
        需求：键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换

        思路：
        1. 键盘录入一个字符串，用 Scanner 实现
        2. 替换敏感词
                String replace(CharSequence target, CharSequence replacement)
                将当前字符串中的target内容，使用replacement进行替换，返回新的字符串
        3. 输出结果

     */
    public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 替换敏感词
        String result = s.replace("TMD","***");
        // 3. 输出结果
        System.out.println(result);
    }
}

15. 切割字符串

案例需求 :

以字符串的形式从键盘录入学生信息，例如：“张三 , 23”

从该字符串中切割出有效数据,封装为Student学生对象

实现步骤 :

编写Student类，用于封装数据
键盘录入一个字符串，用 Scanner 实现
根据逗号切割字符串，得到（张三）（23）

String[] split(String regex) ：根据传入的字符串作为规则进行切割
将切割后的内容存入字符串数组中，并将字符串数组返回
从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
调用对象getXxx方法，取出数据并打印。

代码实现 :

import com.itheima.domain.Student;

import java.util.Scanner;

public class Test7 {
    /*
         需求：以字符串的形式从键盘录入学生信息，例如：“张三 , 23”
                从该字符串中切割出有效数据,封装为Student学生对象
         思路：
            1. 编写Student类，用于封装数据
            2. 键盘录入一个字符串，用 Scanner 实现
            3. 根据逗号切割字符串，得到（张三）（23）
                    String[] split(String regex) ：根据传入的字符串作为规则进行切割
                    将切割后的内容存入字符串数组中，并将字符串数组返回
            4. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
            5. 调用对象getXxx方法，取出数据并打印。

     */
    public static void main(String[] args) {
        // 2. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生信息:");
        String stuInfo = sc.nextLine();
        // stuInfo = "张三,23";
        // 3. 根据逗号切割字符串，得到（张三）（23）
        String[] sArr = stuInfo.split(",");

//        System.out.println(sArr[0]);
//        System.out.println(sArr[1]);

        // 4. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
        Student stu = new Student(sArr[0],sArr[1]);

        // 5. 调用对象getXxx方法，取出数据并打印。
        System.out.println(stu.getName() + "..." + stu.getAge());
    }
}

16. String方法总结

String类的常用方法 :

public boolean equals(Object anObject) 比较字符串的内容，严格区分大小写

public boolean equalsIgnoreCase(String anotherString) 比较字符串的内容，忽略大小写

public int length() 返回此字符串的长度

public char charAt(int index) 返回指定索引处的 char 值

public char[] toCharArray() 将字符串拆分为字符数组后返回

public String substring(int beginIndex, int endIndex) 根据开始和结束索引进行截取，得到新的字符串（包含头，不包含尾）

public String substring(int beginIndex) 从传入的索引处截取，截取到末尾，得到新的字符串

public String replace(CharSequence target, CharSequence replacement) 使用新值，将字符串中的旧值替换，得到新的字符串

public String[] split(String regex) 根据传入的规则切割字符串，得到字符串数组

5. String类正则表达式相关功能

1. 字符类 :

[abc] 字符串的这个位置只能是abc
[^abc] 字符串的这个位置不能是abc
[a-zA-Z] 字符串的这个位置必须是字母,52个
[^a-zA-Z] 字符串的这个位置必须不能是字母,52个

2. 数字类:

[0-9] 字符串的这个位置只能是数字
[^0-9] 字符串的这个位置不能是数字
[\d] 等同于 [0-9]
[\D] 等同于 [^0-9]

3. 预定义字符 :

. 匹配所有的字符
[\d] 等同于 [0-9]
[\D] 等同于 [^0-9]
[\w] 文字字符,包含数字,字母,下划线 [a-zA-Z0-9_]
[\W] 文字字符,不能包含数字,字母,下划线 [^a-zA-Z0-9_]

4. 数量词 :

X{m} X这个字符只能出现m次 a{3}
X{m,} X这个字符至少出现m次
X{m,n} X这个字符至少出现m次,不超过n次
X? X这个字符出现一次,或者一次也没有
X* X这个字符出现零次或者多次
X+ X这个字符出现至少一次

5. 正则表达式的匹配功能

String类的方法matches()

/**
     *  检查邮箱
     *  规则 :
     * @ 前面 : 可以是数组,字母,混合,_  位数放下
     * @ 后面 : 数组,字母  sina qq 126 1393 yahoo gmail 位数放下
     * . 固定 : com  cn org  edu gov 字母  位数放下
     */
public static void stringMethod2(){
    String email = "shihehe@sina.com";
    String reg = "[\\w]+@[a-z0-9]+(\\.[a-z]+)+";
    boolean b = email.matches(reg);
    System.out.println(b);

}
/**
     *  正则表达式检查手机号是否合法
     *  开头必须是1,长度固定11
     *  第二位3 4 5 6 7 8 9
     *  第三位 必须是都是数字
     */
public static void stringMethod(){
    String tel = "13800138000";
    //定义正则的规则,也是字符串
    String regex = "1[3459678][0-9]{9}";
    //正则规则,和字符串校验
    //String类的方法 matches()
    boolean b = tel.matches(regex);
    System.out.println(b);
}

6. String类的split

 public static void stringMethod3(){
        String str = "as123d387654w5465fasfr234567sa";
        String[] strings = str.split("\\d+");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        System.out.println("================");
        String ip = "192.....168.....35.121";
        String[] ipArray = ip.split("\\.+");
        for (int i = 0; i < ipArray.length; i++) {
            System.out.println(ipArray[i]);
        }
    }

7. String类的方法replaceAll

public static void stringMethod4(){
        String str = "as123d387654w5465fasfr234567sa";
        //字符串中的所有数字,换成#
        String repString = str.replaceAll("\\d+","#");
        System.out.println(repString);
		//字符中的第一个数字，换成#
        String first =  str.replaceFirst("\\d+","#");
        System.out.println(first);
    }

6. StringBuilder类

1. 概述

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的

2. StringBuilder类和String类的区别

String类：内容是不可变的
StringBuilder类：内容是可变的

3. StringBuilder类的构造方法

常用的构造方法

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

示例代码：

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());

        //public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }
}

4. StringBuilder常用的成员方法

添加和反转方法

方法名	说明
public StringBuilder append(任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	返回相反的字符序列

示例代码

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //创建对象
        StringBuilder sb = new StringBuilder();

        //public StringBuilder append(任意类型)：添加数据，并返回对象本身
//        StringBuilder sb2 = sb.append("hello");
//
//        System.out.println("sb:" + sb);
//        System.out.println("sb2:" + sb2);
//        System.out.println(sb == sb2);

//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append(100);

        //链式编程
        sb.append("hello").append("world").append("java").append(100);

        System.out.println("sb:" + sb);

        //public StringBuilder reverse()：返回相反的字符序列
        sb.reverse();
        System.out.println("sb:" + sb);
    }
}

5. StringBuilder和String相互转换

StringBuilder转换为String

public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
String转换为StringBuilder

public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
示例代码

public class StringBuilderDemo02 {
    public static void main(String[] args) {
        /*
        //StringBuilder 转换为 String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");

        //String s = sb; //这个是错误的做法

        //public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
        String s = sb.toString();
        System.out.println(s);
        */

        //String 转换为 StringBuilder
        String s = "hello";

        //StringBuilder sb = s; //这个是错误的做法

        //public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
        StringBuilder sb = new StringBuilder(s);

        System.out.println(sb);
    }
}

6. StringBuilder拼接字符串案例

案例需求 :

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，

并在控制台输出结果。例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

实现步骤 :

定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
返回值类型 String，参数列表 int[] arr
在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
调用方法，用一个变量接收结果
输出结果

代码实现 :

/*
    思路：
        1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
          返回值类型 String，参数列表 int[] arr
        3:在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        4:调用方法，用一个变量接收结果
        5:输出结果
 */
public class StringBuilderTest01 {
    public static void main(String[] args) {
        //定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};

        //调用方法，用一个变量接收结果
        String s = arrayToString(arr);

        //输出结果
        System.out.println("s:" + s);

    }

    //定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
    /*
        两个明确：
            返回值类型：String
            参数：int[] arr
     */
    public static String arrayToString(int[] arr) {
        //在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder();

        sb.append("[");

        for(int i=0; i<arr.length; i++) {
            if(i == arr.length-1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }

        sb.append("]");

        String s = sb.toString();

        return  s;
    }
}

注意：
StringBuilder类是线程不安全的类,运行速度快 , 推荐使用StringBuilder
StringBuffer是线程安全的类,运行速度慢,多线程的程序使用
两个类的构造方法,和其他的方法,一模一样.

Java基础3.1---Scanner、Random、String和其正则表达式、StringBuilder

1. API

1. API概述

2. Scanner类

1. 什么是Scanner类

2. 引用类型使用步骤

3. 常用方法

4. Scanner类的使用步骤

5. 练习

3. Random类

1. Random类概述

2. 常用方法

1. random.nextInt()

2. random.nextInt(int bound)

3. random.nextLong()

4. random.nextDouble()

5. random.nextFloat()

6. random.nextBoolean()

7. random.nextBytes(byte[] bytes)

8. random.nextGaussian()

9. 猜数字小游戏

4. String类

1. 概述

2. String类的构造方法

4. 创建字符串对象的区别比较

5. 字符串的比较

6. 用户登录案例

7. 判断功能的方法

8. 获取功能的方法

9. 转换功能的方法

10. 分割、替换、去空格功能

11. 拼接字符串练习

12. 统计字符个数

13. 手机号屏蔽–字符串截取

14. 敏感词替换–字符串替换

15. 切割字符串

16. String方法总结

5. String类正则表达式相关功能

1. 字符类 :

2. 数字类:

3. 预定义字符 :

4. 数量词 :

5. 正则表达式的匹配功能

6. String类的split

7. String类的方法replaceAll

6. StringBuilder类

1. 概述

2. StringBuilder类和String类的区别

3. StringBuilder类的构造方法

4. StringBuilder常用的成员方法

5. StringBuilder和String相互转换

6. StringBuilder拼接字符串案例

热门文章