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

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_VALUEInteger.MAX_VALUE,这两个是Integer类设定的最小值和最大值。在Java的八种基础数据类型中,除了boolean为true和false之外,其他的七种类型都是有MIN_VALUEMAX_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. 概述

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

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. 用户登录案例

案例需求 :

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

实现步骤 :

  1. 已知用户名和密码,定义两个字符串表示即可
  2. 键盘录入要登录的用户名和密码,用 Scanner 实现
  3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较,给出相应的提示。
  4. 字符串的内容比较,用equals() 方法实现
  5. 用循环实现多次机会,这里的次数明确,采用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

实现步骤 :

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

代码实现 :

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),则使用***替换

实现步骤 :

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

代码实现 :

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学生对象

实现步骤 :

  1. 编写Student类,用于封装数据

  2. 键盘录入一个字符串,用 Scanner 实现

  3. 根据逗号切割字符串,得到(张三)(23)

    String[] split(String regex) :根据传入的字符串作为规则进行切割
    将切割后的内容存入字符串数组中,并将字符串数组返回

  4. 从得到的字符串数组中取出元素内容,通过Student类的有参构造方法封装为对象

  5. 调用对象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]

实现步骤 :

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

代码实现 :

/*
    思路:
        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是线程安全的类,运行速度慢,多线程的程序使用
两个类的构造方法,和其他的方法,一模一样.

热门文章

暂无图片
编程学习 ·

C语言二分查找详解

二分查找是一种知名度很高的查找算法&#xff0c;在对有序数列进行查找时效率远高于传统的顺序查找。 下面这张动图对比了二者的效率差距。 二分查找的基本思想就是通过把目标数和当前数列的中间数进行比较&#xff0c;从而确定目标数是在中间数的左边还是右边&#xff0c;将查…
暂无图片
编程学习 ·

GMX 命令分类列表

建模和计算操作命令&#xff1a; 1.1 . 创建拓扑与坐标文件 gmx editconf - 编辑模拟盒子以及写入子组(subgroups) gmx protonate - 结构质子化 gmx x2top - 根据坐标生成原始拓扑文件 gmx solvate - 体系溶剂化 gmx insert-molecules - 将分子插入已有空位 gmx genconf - 增加…
暂无图片
编程学习 ·

一文高效回顾研究生课程《数值分析》重点

数值分析这门课的本质就是用离散的已知点去估计整体&#xff0c;就是由黑盒子产生的结果去估计这个黑盒子。在数学里这个黑盒子就是一个函数嘛&#xff0c;这门课会介绍许多方法去利用离散点最大化地逼近这个函数&#xff0c;甚至它的导数、积分&#xff0c;甚至微分方程的解。…
暂无图片
编程学习 ·

在职阿里5年,一个28岁女软测工程师的心声

简单的先说一下&#xff0c;坐标杭州&#xff0c;14届本科毕业&#xff0c;算上年前在阿里巴巴的面试&#xff0c;一共有面试了有6家公司&#xff08;因为不想请假&#xff0c;因此只是每个晚上去其他公司面试&#xff0c;所以面试的公司比较少&#xff09; ​ 编辑切换为居中…
暂无图片
编程学习 ·

字符串左旋c语言

目录 题目&#xff1a; 解题思路&#xff1a; 第一步&#xff1a; 第二步&#xff1a; 第三步&#xff1a; 总代码&#xff1a; 题目&#xff1a; 实现一个函数&#xff0c;可以左旋字符串中的k个字符。 例如&#xff1a; ABCD左旋一个字符得到BCDA ABCD左旋两个字符…
暂无图片
编程学习 ·

设计模式--观察者模式笔记

模式的定义与特点 观察者&#xff08;Observer&#xff09;模式的定义&#xff1a;指多个对象间存在一对多的依赖关系&#xff0c;当一个对象的状态发生改变时&#xff0c;所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式&#xf…
暂无图片
编程学习 ·

睡觉突然身体动不了,什么是睡眠痽痪症

很多朋友可能有这样的体验&#xff0c;睡觉过程中突然意识清醒&#xff0c;身体却动弹不了。这时候感觉非常恐怖&#xff0c;希望旁边有一个人推自己一下。阳光以前也经常会碰到这样的情况&#xff0c;一年有一百多次&#xff0c;那时候很害怕晚上到来&#xff0c;睡觉了就会出…
暂无图片
编程学习 ·

深入理解C++智能指针——浅析MSVC源码

文章目录unique_ptrshared_ptr 与 weak_ptrstd::bad_weak_ptr 异常std::enable_shared_from_thisunique_ptr unique_ptr 是一个只移型别&#xff08;move-only type&#xff0c;只移型别还有std::mutex等&#xff09;。 结合一下工厂模式&#xff0c;看看其基本用法&#xff…
暂无图片
编程学习 ·

@TableField(exist = false)

TableField(exist false) //申明此字段不在数据库存在&#xff0c;但代码中需要用到它&#xff0c;通知Mybatis-plus在做写库操作是忽略它。,.
暂无图片
编程学习 ·

Java Web day15

第十二章文件上传和下载 一、如何实现文件上传 要实现Web开发中的文件上传功能&#xff0c;通常需要完成两步操作&#xff1a;一.是在Web页面中添加上传输入项&#xff1b;二是在Servlet中读取上传文件的数据&#xff0c;并保存到本地硬盘中。 需要使用一个Apache组织提供一个…
暂无图片
编程学习 ·

【51nod 2478】【单调栈】【前缀和】小b接水

小b接水题目解题思路Code51nod 2478 小b接水 题目 输入样例 12 0 1 0 2 1 0 1 3 2 1 2 1输出样例 6解题思路 可以发现最后能拦住水的都是向两边递减高度&#xff08;&#xff1f;&#xff09; 不管两个高积木之间的的积木是怎样乱七八糟的高度&#xff0c;最后能用来装水的…
暂无图片
编程学习 ·

花了大半天写了一个UVC扩展单元调试工具

基于DIRECTSHOW 实现的&#xff0c;用的是MFC VS2019. 详见&#xff1a;http://www.usbzh.com/article/detail-761.html 获取方法 加QQ群:952873936&#xff0c;然后在群文件\USB调试工具&测试软件\UVCXU-V1.0(UVC扩展单元调试工具-USB中文网官方版).exe USB中文网 USB中文…
暂无图片
编程学习 ·

贪心(一):区间问题、Huffman树

区间问题 例题一&#xff1a;区间选点 给定 N 个闭区间 [ai,bi]请你在数轴上选择尽量少的点&#xff0c;使得每个区间内至少包含一个选出的点。 输出选择的点的最小数量。 位于区间端点上的点也算作区间内。 输入格式 第一行包含整数 N&#xff0c;表示区间数。 接下来 …
暂无图片
编程学习 ·

C语言练习实例——费氏数列

目录 题目 解法 输出结果 题目 Fibonacci为1200年代的欧洲数学家&#xff0c;在他的着作中曾经提到&#xff1a;「若有一只免子每个月生一只小免子&#xff0c;一个月后小免子也开始生产。起初只有一只免子&#xff0c;一个月后就有两只免子&#xff0c;二个月后有三只免子…
暂无图片
编程学习 ·

Android开发(2): Android 资源

个人笔记整理 Android 资源 Android中的资源&#xff0c;一般分为两类&#xff1a; 系统内置资源&#xff1a;Android SDK中所提供的已经定义好的资源&#xff0c;用户可以直接拿来使用。 用户自定义资源&#xff1a;用户自己定义或引入的&#xff0c;只适用于当前应用的资源…
暂无图片
编程学习 ·

零基础如何在短时间内拿到算法offer

​算法工程师是利用算法处理事物的职业 算法&#xff08;Algorithm&#xff09;是一系列解决问题的清晰指令&#xff0c;也就是说&#xff0c;能够对一定规范的输入&#xff0c;在有限时间内获得所要求的输出。 如果一个算法有缺陷&#xff0c;或不适合于某个问题&#xff0c;执…
暂无图片
编程学习 ·

人工智能:知识图谱实战总结

人工智能python&#xff0c;NLP&#xff0c;知识图谱&#xff0c;机器学习&#xff0c;深度学习人工智能&#xff1a;知识图谱实战前言一、实体建模工具Protegepython&#xff0c;NLP&#xff0c;知识图谱&#xff0c;机器学习&#xff0c;深度学习 人工智能&#xff1a;知识图…
暂无图片
编程学习 ·

【无标题】

这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题&#xff0c;有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注…