Scanner、Random、stirng

API的使用

API : Application Programming Interface [应用程序编程接口] -> 帮助文档,词典 [对JDK的翻译文档]

ft6543ggfdhy6
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aWo9KVNQ-1670235353300)(https://cdn.staticaly.com/gh/quinhua/pics@main/markdown/kol9876trgfew3.66j59ldmi580.webp)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YdnxduSX-1670235353300)(https://cdn.staticaly.com/gh/quinhua/pics@main/markdown/rew34r5tgfrefvgb.3h5q9570cui0.webp)]
fvdr45t6yhgbtfrew3e

dre45tgyhgbfrewgbhg

Scanner键盘录入

已知推理未知 :
	键盘录入整数 : int nextInt() -> 已知
    键盘录入字符串 : String nextString() -> 猜
    	
真实情况 :
	String next() : 能录入字符串 但是遇到了空格不再继续录入了;
	String nextLine()  : 能录入所有的字符串 --> 目标方法 [一次录入一行内容]
	
总结 : Scanner 对象能录入的是基本数据类型和字符串

//实例:计算句子中英文大小写及数字出现的次数
public static void main(String[] args) {  
    Scanner sc = new Scanner(System.in);  
    System.out.println("请输入一句话:");  
    String line = sc.nextLine();  
    int smallcount = 0;  
    int bigcount = 0;  
    int numbercount = 0;  
    int othercount = 0;  
    for (int i = 0; i < line.length(); ++i) {  
        char ch = line.charAt(i);  
        if (ch >= 'a' && ch <= 'z') {  
            smallcount++;  
        } else if (ch >= 'A' && ch <= 'Z') {  
            bigcount++;  
        } else if (ch >= '0' && ch <= '9') {  
            numbercount++;  
        } else {  
            othercount++;  
        }  
    }  
    System.out.println("smallcount = " + smallcount);  
    System.out.println("bigcount = " + bigcount);  
    System.out.println("numbercount = " + numbercount);  
    System.out.println("othercount = " + othercount);  
}

Random类中seed参数

目标 : API中方法的形参名隐藏着很多信息 ;
	index : 索引
	count/length : 个数
	arr : 数组
	...
        
Random中带种子参数的构造方法 :
	Random(long seed) : seed -> 种子 
		功能 : 如果使用带种子的构造方法创建random对象,只要种子不变那么每次获取随机数的数值都不变

//示例1:输出指定范围内的随机数
public static void main(String[] args) {  
    int max=89;  
    int min=40;  
    System.out.println(rRandom(min,max));  
    System.out.println(mathRandom(min,max));  
}  
public static int rRandom(int min,int max){  
    Random r=new Random();  
    return r.nextInt(max-min)+min;  
}  
public static int mathRandom(int min,int max){  
    return (int)Math.round(Math.random()*(max-min)+min);  
}

String 类的概述[重点]

String 类 : 字符串 类  [引用数据类型]

String 类对象的特点 :
	1. 只要是双引号引起来的内容都是 String 类的对象
	2. String 类是Java中唯一一个 不需要new就可以创建的对象类型; ->  String str = "HelloWorld";
	3. String 类是Java中唯一一个 可以做运算的引用数据类型; [运算只能是 加法运算(拼接)]
    4. String 类是Java中唯一一个 既是引用数据类型又是常量类型的数据类型
    5. String 类型的本质是 字符数组 ; "Hello" -> char[] chs = {'H','e','l','l','o'};
	6. String 类型的本本质是 字节数组 ; "abc" - > byte[] bys = {97,98,99};
	7. String 类型的对象一旦被定义 不能改变(长度和内容都不能变) [如果改变了一定是生成了新的字符串对象]
	8. String 类型的对象使用可以被共享 -> 不能变带来的好处
	9. String 类型的对象做 拼接 非常消耗内存资源 [如果是字符串常量拼接因为有常量优化机制所以不耗内存,只有字符串变量做拼接消耗内存资源] -> 不能变带来的坏处
		"Hello" + "World" + "Java" -> 内存中有 : "Hello" , "World" , "Java" ,"HelloWorldJava" -> 不消耗内存
		String str = "Hello";
		str + "World" + "Java" - > "Hello" , "World" , "Java" ,"HelloWorldJava" ,"HelloWorld" -> 消耗内存

String 类的构造方法

String 类对象的创建方式 :
	1. 直接赋值 : String str = "abc"; -> 最推荐的方式
	
	//废物构造
	2. String() : 创建一个内容为空的字符串对象 -> ""
    3. String(String original) : 根据传入的字符串对象内容来创建一个字符串对象 
    	String str = new String("Hello"); -> "Hello"
        
    //具备转换功能的构造方法 :
    //char[] --> String
    String(char[] value) : 把传入的字符数组中所有的字符内容组成一个字符串对象  
    String(char[] value, int offset, int count) : 把传入的字符数组的一部分内容转换成字符串对象
    	offset : 偏移量 [起始索引]
    	count : 几个 [转几个]
    	
   //byte[] --> String
   String(byte[] bytes) : 把传入的字节数组中所有的字节内容组成一个字符串对象 
   String(byte[] bytes, int offset, int length) 把传入的字节数组中一部分的字节内容组成一个字符串对象  //offset : 偏移量 [起始索引] length : 几个 [转几个]

String类的比较功能

    == : 比较是否相等
        基本数据类型 : 数值是否相等
        引用数据类型[对象] : 一定是地址值是否相等
        
 boolean equals(Object anObject)  : 判断调用方法的字符串对象和传入的对象内容是否相同 -> 校验用户名和密码
 boolean equalsIgnoreCase(String anotherString) : 判断调用方法的字符串对象和传入的字符串对象内容是否相同 -> 忽略大小写   -> 校验验证码

//示例
public static void main(String[] args) {  
    String s1="helloworld";  
    String s2="helloworld";  
    String s3="HelloWorld";  
    String s4="hello";  
    String s5="world";  
    System.out.println(s1==s2);//true  
    System.out.println(s2==s3);//false  
    System.out.println(s4+s5==s1);//false  
    System.out.println("qianhui"==s1);//false  
}

equals方法的源码分析

equals:用于检测一个对象是否等于另外一个对象
源码 :
	1. 大局观 : 学会分层
	2. 夯实的语法基础
	3. 连蒙带猜
	
equals方法的源码 : 
	public boolean equals(Object anObject) {
        //第一阶段
        //判断(调用方法的对象 和 传入方法的对象 的地址值是否相同) -> 目的 : 提高代码的效率
        //如果2个对象的地址值相同,说明是同一个对象,那么没有必要比较内容! 直接返回true!
        if (this == anObject) { // 自己比自己
            return true;
        }
        
        //前提 : 传入的对象和调用方法的对象不是同一个对象
        
        //第二阶段
        //if(传入的数据是否属于字符串类型) -> false : 说明传入的数据不是字符串类型
        //作用 : 1. 提高代码效率 2. 提高代码的安全性 [为向下转型做准备]
        if (anObject instanceof String) {
            //能进来说明 实参一定是String类型
            String anotherString = (String)anObject;//向下转型 -> 实参 : anotherString
            //char[] value : 是字符串对象的底层字符数组
            //调用方法的字符串对象的底层数组的长度
            int n = /*this.*/value.length;//获取字符串对象的字符个数
            //第三阶段 : 
            /*
            	调方法的字符串对象的字符个数 == 传入方法的字符串对象的字符个数
            	
            	目的: 提高代码的效率
           	*/
            if (n == anotherString.value.length) {
                //能进此 if 说明 : 2个字符串对象的字符个数是一样的!
                //比较2个字符串对象的每一个索引位置的字符都相同!
                //接下来就是遍历字符串
                char v1[] = /*this.*/value;//获取调用方法的字符串对象底层数组 -> V1
                char v2[] = anotherString.value; //获取传入方法的字符串对象底层数组 -> V2
                
                //初始化语句
                int i = 0;
                //判断条件语句
                while (n-- != 0) { //--> 等效于 i < n
                    //能进来说明 字符串的字符还没有比较完
                    //循环体语句
                    //反向逻辑比较 : v1数组和v2数组只要有一个i位置的索引元素不相同,equals方法就直接返回false
                    if (v1[i] != v2[i]){
                         return false;
                    }
                    //步进表达式
                    i++;
                }
                //2个字符串对象中每一个索引位置的字符都相同才能从上方的循环能够走下来!
                return true; //equals方法就返回true
            }
        }
        //第四阶段
        //1. 如果传入方法数据的类型不是String类型,那么equals方法的结果直接返回false
        //2. 如果传入方法字符串对象的长度和调用方法字符串对象的长度不相同直接返回false
        return false;//比较内容不相等
    }

//示例:用户登录
public static void main(String[] args) {  
    String username = "admin";  
    String password = "123";  
    String code = "Q1h6";  
    Scanner sc = new Scanner(System.in);  
    for (int i = 0; i < 3; i++) {  
        System.out.println("请输入用户名:");  
        String uname = sc.nextLine();  
        System.out.println("请输入密码:");  
        String upwd = sc.nextLine();  
        System.out.println("请输入验证码 [Q1h6]:");  
        String ucode = sc.nextLine();  
  
        if (username == null || password == null || code == null) {  
            System.out.println("用户名或密码或验证码为空!");  
        } else {  
            if (username.equals(uname) && password.equals(upwd) && code.equalsIgnoreCase(ucode)) {  
                System.out.println("用户-" + username + "-登录成功!");  
                break;  
            } else {  
                if (i == 2) {  
                    System.out.println("3次机会用完，用户账号被锁定!请联系管理员!");  
                    break;  
                }  
                System.out.println("用户还有" + (2 - i) + "次机会尝试机会!");  
            }  
        }  
    }  
}

String类的获取功能

//字符串对象的遍历
*char charAt(int index) : 获取字符串对象指定位置上的字符
*int length() : 获取字符串对象的长度 [字符个数]

//获取传入的字符/字符串第一次出现在调用方法字符串对象的索引,如果没有出现返回 -1
 int indexOf(int ch) 
 int indexOf(String str) 
 //fromIndex 从哪个索引开始算第一次出现
 int indexOf(int ch, int fromIndex) 
 int indexOf(String str, int fromIndex)   
    
//获取传入的字符/字符串最后一次出现在调用方法字符串对象的索引,如果没有出现返回 -1  
 int lastIndexOf(int ch) 
 int lastIndexOf(String str) 
 int lastIndexOf(int ch, int fromIndex) 
 int lastIndexOf(String str, int fromIndex)

//示例
public static void main(String[] args) {  
    String str="HelloWorld!";  
    //判断字符第一出现的位置下标  
    System.out.println(str.indexOf("e"));  
    System.out.println(str.indexOf(101));  
    System.out.println(str.indexOf("l"));  
    System.out.println(str.indexOf("y"));  
    System.out.println("----------");  
    //判断字符串第一次出现的位置下标  
    System.out.println(str.indexOf("el"));  
    System.out.println(str.indexOf("le"));  
    System.out.println("----------");  
    //判断字符串从指定下标开始出现的位置下标  
    System.out.println(str.indexOf("l",0));  
    System.out.println("----------");  
    //判断字符串最后一次出现的位置下标  
    System.out.println(str.lastIndexOf("l"));
}

String类的判断功能

判断功能 : 判断方法的功能返回值都是boolean

boolean contains(CharSequence s) : 判断传入的字符串是否包含于调用方法的字符串内部

//判断开头和结尾的方法
boolean startsWith(String prefix) : 判断调用方法的字符串对象是否以prefix字符串开头 -> 判断姓氏
boolean endsWith(String suffix) : 判断调用方法的字符串对象是否以suffix字符串结尾 -> 判断文件名后缀

//示例
public static void main(String[] args) {  
    String str="HelloWorld!";   
    //判断字符串中是否包含指定字符串  
    System.out.println(str.contains("oWo"));  
    System.out.println(str.contains("ooo"));  
    System.out.println("----------");  
    //判断字符串是否是以指定字符串开头  
    System.out.println(str.startsWith("Hello"));  
    System.out.println(str.startsWith("hello"));  
    System.out.println("----------");  
    //判断字符串是否是以指定字符串结尾  
    System.out.println(str.endsWith("World!"));  
    System.out.println(str.endsWith("ddd"));  
    System.out.println("----------");   
}

String类的转换功能

    //char[] --> String
    String(char[] value) : 把传入的字符数组中所有的字符内容组成一个字符串对象  
    String(char[] value, int offset, int count) : 把传入的字符数组的一部分内容转换成字符串对象
    	offset : 偏移量 [起始索引]
    	count : 几个 [转几个]
    	
    //String --> char[]
     char[] toCharArray() : 把字符串对象转换成字符数组        
    	
   //byte[] --> String
   String(byte[] bytes) : 把传入的字节数组中所有的字节内容组成一个字符串对象 
   String(byte[] bytes, int offset, int length) 把传入的字节数组中一部分的字节内容组成一个字符串对象  //offset : 偏移量 [起始索引] length : 几个 [转几个]
   
   //String -> byte[]
    byte[] getBytes() : 把字符串对象转换成字节数组 [按照平台默认编码格式]
    byte[] getBytes(String charsetName)  : 把字符串对象转换成字节数组 [按照指定的编码格式] 
    
    UTF-8 : 一个汉字占用3个字节
    GBK : 一个汉字占用2个字节
      -> 汉字字节都是以负数开头的      
      
----------------------------------------------------------------
 String toUpperCase() : 把字符串对象中所有英文小写字符转换成英文大写字符
 String toLowerCase() : 把字符串对象中所有英文大写字符转换成英文小写字符

//示例
public static void main(String[] args) {  
    //把字符串数组转换为字节数组  
    char[] chs=str.toCharArray();  
    System.out.println(Arrays.toString(chs));  
    System.out.println("----------");  
    //把字符串数组转换为字符数组  
    byte[] bys=str.getBytes();  
    System.out.println(Arrays.toString(bys));  
    System.out.println("----------");  
    //英文字符转换为小写  
    System.out.println(str.toLowerCase());  
    //英文字符转换为大写  
    System.out.println(str.toUpperCase());  
}

String类的替换功能

String replace(CharSequence target, CharSequence replacement) : 把调用方法的字符串中target字符串替换成replacement,生成新的字符串对象
    target : 目标
    replacement : 替换物

//示例
public static void main(String[] args) {  
    //敏感字屏蔽  
    Scanner sc=new Scanner(System.in);  
    System.out.println("录入:");  
    String line=sc.nextLine();  
    //TMD- >* * *  
    String replace=line.replace("TMD","***");  
    System.out.println("replace替换:"+replace);  
}

String类的截取功能

 String substring(int beginIndex) : 截取调用方法字符串对象内容 -> [beginIndex,结尾]
 String substring(int beginIndex, int endIndex) : 截取调用方法字符串对象内容 ->[beginIndex,endIndex)

//示例
public static void main(String[] args) {  
    String str="HelloWorld";  
    //i下标- >结尾  
    System.out.println(str.substring(1));  
    //i下标- >j下标 [i,j)  左闭右开
    System.out.println(str.substring(2,4));  
    System.out.println(str.substring(5,str.length()));  
}

String类的切割功能

String[] split(String regex)  : 按照传入的regex字符串内容进行切割,得到切割后的字符串数组
	//按什么切,就传入什么!! 如果不小心触碰了正则规则 就在要切的内容前面加 \\

String regex : [regex : 正则表达式] -> 不要花时间研究[要用baidu]

	正则表达式 : 独立的语法规则 [校验,判断] -> 语法突出简化[不简单]
	
常用的正则规则 :
	x+ : x出现一次或者多次都按一次算
	. : 通配符 // \\. 
	\ : 转义符 -> \t : tab ,  \r\n : 转行

//示例
public static void main(String[] args) {  
    String str1="HelloWorld";  
    String str2="1991-11-22";  
    System.out.println(Arrays.toString(str1.split("o")));  
    System.out.println(Arrays.toString(str2.split("-")));  
}

String类的匹配功能

boolean matches(String regex) : 判断调用方法的字符串对象内容是否符合传入的正则规则

需要查找常用正则规则请百度!![面向百度编程]

//示例:强密码校验
public static void main(String[] args) {  
    String pwd="15236117757ffF";  
    boolean flag=pwd.matches("^(?=.*\\d)(?=.*[a-z])(?=.*[A-Z])[a-zA-Z0-9]{8,16}$");  
    System.out.println(flag);  
}

String类的其他功能

String concat(String str) : 连接 [废物方法 : 可以用加法取代]
String toString() : 把调用方法的字符串对象转换成一个字符串对象 [源代码 : return this;]

static String valueOf(任意类型的数据) : 把传入的任意对象转换成字符串对象 [底层逻辑 : 转换的逻辑是依仗toString()方法的逻辑]
 	1. 基本数据类型的实参 : valueOf的逻辑 -> 基本数据类型值 + ""
    2. 引用数据类型的实参 : valueOf的逻辑 -> 引用数据类型数据.toString()的结果
    	String.valueOf(学生对象) --> 学生对象.toString() [调用的是学生类的toString()]
    	
String trim() : 去除字符串对象两端的空格      //拿到用户给的数据时,会把字符串数据trim一下