1、API和API帮助文档
API:应用程序接口。
简单理解:API就是别人已经写好的东西,我们不需要自己编写,直接使用即可。
JavaAPI:指的就是JDK中提供的各种功能的Java类。这些类将底层的实现封装了起来,我们不需要这些类是如何实现的,只需要学习这些类是如何使用的即可。
API帮助文档:帮助开发人员更好的使用API和查询API的一个工具。
2、String概述(字符串知识点1)
1、String概述:Java.long.String类代表字符串,Java程序中的所有字符串文字(例如“abc”)都为此类的对象。表示字符串的类,定义了很多操作字符串的方法。
2、String的注意点:字符串的内容是不会发生改变的,它的对象在创建后不能被更改。
3、String是Java定义好的一个类。在Java.long包中,所以使用的时候不需要导包。(Java.long包是Java的核心包)
3、String构造方法代码实现和和内存分析
1、创建String对象的两种方式。
(1)、直接赋值。
例如:String name = "小明";
(2)、new一个。
举例如下:
package StringDemo1;
public class StringDemo1 {
public static void main(String[] args) {
//1、使用直接赋值的方式获取一个字符串对象
String s1 = "abc";
System.out.println(s1); //abc
//2、使用new的方式来获取一个字符串对象
//2.1、空参构造:可以获取一个空白的字符串对象。
String s2 = new String();
System.out.println("@"+s2+"!"); //@!
//2.2、传递一个字符串,根据传递的字符串内容再创建一个新的字符串对象
String s3 = new String("abc");
System.out.println(s3); //abc
//2.3、传递一个字符数组,根据字符数组的内容再创建一个新的字符串对象
//使用场景:我要修改字符串的内容。 abc Qbc
//abc --> {'a','b','c'} --> {'Q','b','c'} --> Qbc
char[] chs = {'a','b','c','d'};
String s4 = new String(chs);
System.out.println(s4); //abcd
//2.4、传递一个字节数组,根据字节数组的内容再创建一个新的字符串对象
//使用场景:以后在网络当中传输的数据其实都是字节信息。
//我们一般要把字节信息进行转换,转换成字符串,此时就要用到这个构造了。
byte[] bytes = {97,98}; //97、98在ASCLL码表中的对应值为a、b
String s5 = new String(bytes);
System.out.println(s5); //ab
}
}
2、创建String对象的两种方式的内存分析。
4、字符串的比较
1、==号比的到底是什么?
1、基本数据类型
int a = 10;
int b = 20;
System.out.println(a == b); //false
基本数据类型比较的是数据值
2、引用数据类型
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); //false
引用数据类型比较的是地址值
2、字符串比较
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); //true
String c1 = new String("abc"); //记录堆里面的地址值
String c2 = "abc"; //记录串池中的地址值
System.out.println(c1 == c2); //false
3、字符串比较调用方法
boolean equals方法(要比较的字符串) 完全一样结果才是true,否则为false
Boolean equalsIgnoreCase(要比较的字符串) 忽略大小写的比较
package sss;
import java.util.Scanner;
public class StringDome {
public static void main(String[] args) {
//1.1、创建两个字符串对象
String s1 = new String("abc");
String s2 = "Abc";
//1.2、==号比较
//基本数据类型:比的是数据值
//引用数据类型:比的是地址值
System.out.println(s1 == s2); //false
//1.3、比较字符串对象中的内容是否相等
boolean result1 = s1.equals(s2);
System.out.println(result1); //false
//1.4、比较字符串对象中的内容是否相等,忽略大小写
boolean result2 = s1.equalsIgnoreCase(s2);
System.out.println(result2); //true
//2.1假设我现在键盘录入一个abc
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str1 = sc.next(); //abc 是new出来的。
//2.2代码中再定义一个字符串abc
String str2 = "abc";
//2.3 用==比较,这两者是否一样?
System.out.println(str1 == str2); //false
//结论:以后只要想比较字符串的内容,就必须要用String里面的equals或equalsIgnoreCase方法
}
}
5、练习-用户登录
需求:已知正确的用户名和密码,请用程序实现模拟用户登录。总共给三次机会,登录之后,给出相应的提示。
package sss;
import java.util.Scanner;
public class StringDome {
public static void main(String[] args) {
//1、定义两个变量记录正确的用户名和密码
String rightname = "susu";
String rightpassword = "123456";
int n = 3; //三次登录机会,n的值可以根据条件修改,没有写死
Scanner sc = new Scanner(System.in);
for (int i=0; i<n ;i++) {
//模拟用户输入
System.out.println("请输入用户名");
String username = sc.next();
System.out.println("请输入密码");
String userpassword = sc.next();
//对比账户和密码
if( rightname.equals(username) && rightpassword.equals(userpassword) ){
System.out.println("登陆成功");
break; //登陆成功后,直接跳出循环
} else {
if((n-1 -i)==0){
System.out.println("账户被锁定,请联系客服人员");
} else{
System.out.printf("账号或密码错误,");
System.out.println("您还有"+ (n-1 -i) +"次机会");
}
}
}
}
}
6、练习-遍历字符串和统计字符个数
案例1:遍历字符串
需求:键盘录入一个字符串,使用程序实现在控制台遍历该字符串。
补充知识:
public char charAt(int index); 根据索引返回字符,index是索引
public int length(); 返回此字符串的长度
数组长度:数组名.length
字符串长度:字符串对象.length()
package sss;
import java.util.Scanner;
public class StringDome {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
System.out.println(c);
}
}
}
案例2:统计字符次数
需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符出现的次数,(不考虑其他字符)
package sss;
import java.util.Scanner;
public class StringDome {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
int bigCount=0;
int smallCount=0;
int numberCount=0;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if(c>='A' && c<='Z'){
bigCount++;
} else if(c>='a' && c<='z'){
smallCount++;
} else if(c>='0' && c<='9'){
numberCount++;
}
}
System.out.println("大写字符有"+bigCount+"个");
System.out.println("小写字符有"+smallCount+"个");
System.out.println("数字字符有"+numberCount+"个");
}
}
7、练习-字符串拼接和反转
案例1:拼接字符串
需求:定义一个方法,把int数组中的数据按照指定的格式拼接成一个字符串返回,调用该方法,并在控制台输出结果。例如:
数组为 int[] arr = {1,2,3};
执行方法后的输出结果为:[1,2,3]
package sss;
public class StringDome {
public static void main(String[] args) {
int[] arr = {1,2,3};
String str =arrToString(arr);
System.out.println(str);
}
/**定义一个方法
* 我要干嘛? 遍历数组,把数组拼接成一个字符串
* 需要什么才能完成? 数组
* 是否需要返回值? 需要
*/
public static String arrToString(int[] arr){
if(arr == null){
return ""; //字符串的值为null的时候返回空
}
if(arr.length == 0){
return "[]"; //字符串长度为0的时候,返回[]
}
String result = "["; //设置字符串的初始值
for (int i = 0; i < arr.length; i++) {
if(i == arr.length - 1){
result = result + arr[i];
} else{
result = result + arr[i] + ",";
}
}
result = result+"]";
return result;
}
}
案例2:字符串反转
需求:定义一个方法,实现字符串反转。键盘录入一个字符串,调用该方法后,在控制台输出结果。例如:键盘录入abc,输出结果cba
package sss;
public class StringDome {
public static void main(String[] args) {
String s = reverser("abc");
System.out.println(s);
}
/**定义一个方法
* 我要干嘛? 遍历数组,把数组拼接成一个字符串
* 需要什么才能完成? 数组
* 是否需要返回值? 需要
*/
public static String reverser(String str){
String result = "";
//i.forr可实现倒着循环
for (int i = str.length() - 1; i >= 0; i--) {
char c = str.charAt(i);
result =result + c; //字符串拼接
}
return result;
}
}
8、较难练习-金额转换
分析:
package sss;
import java.sql.SQLOutput;
import java.util.Scanner;
public class StringDome {
public static void main(String[] args) {
//1、获取键盘输入
Scanner sc = new Scanner(System.in);
int money;
while(true){
System.out.println("请录入一个整数");
money = sc.nextInt();
if(money>=0 && money<=9999999){
break;
} else{
System.out.println("金额无效");
}
}
//2、得到money里面每位上的数字,并转化成大写
/*int len = (money+"").length(); //求输入的数字的长度
System.out.println("金额长度为:"+len);*/
//定义一个变量来表示钱的大写
String moneyStr = "";
while(true){
int ge = money%10;
String capitalNumber = getCapitalNumber(ge);
moneyStr = capitalNumber + moneyStr;
money = money/10;
//如果money每一位上的数字都被获取到了,则money记录的值就为0,此时循环结束
if(money==0){
break;
}
}
//System.out.print(moneyStr); //打印对应的大写
//3、在前面补零,补齐7位
int count = 7 - moneyStr.length();
for (int i = 0; i < count; i++) {
moneyStr = "零" + moneyStr;
}
//System.out.println(moneyStr); //打印补零后的结果
//4、插入单位
//定义一个数组表示单位
String[] arr = {"佰","拾","万","仟","佰","拾","元"};
// 零 零 零 二 三 四 五
//遍历moneyStr,依次获得 零 零 零 二 三 四 五
//然后把arr的单位插入进去
String result = "";
for (int i = 0; i < moneyStr.length(); i++) {
char c = moneyStr.charAt(i);
result = result + c + arr[i];
//System.out.print(c);
//打印一下单位
//System.out.print(arr[i]);
}
//5、打印结果
System.out.println(result);
}
//定义一个方法,把数字变成大写中文
public static String getCapitalNumber(int number){
String[] arr = {"零","一","二","三","四","五","六","七","八","九"};
return arr[number];
}
}
9、练习-手机号屏蔽-身份证号码信息查看-游戏骂人敏感词替换
补充知识:
String substring(int beginIndex,int endIndex) 截取
注意点:包头不包尾,包左不包右
只有返回值才是截取的小串
String substring(int beginIndex) 截取到末尾
String replace(旧值,新值) 替换
注意点:只有返回值才是替换之后的结果
案例1:手机号屏蔽。
package sss;
import java.sql.SQLOutput;
import java.util.Scanner;
public class StringDome {
public static void main(String[] args) {
//1、获取一个手机号码
String phoneNumber = "12345678911";
//2、截取手机号码前三位
String star = phoneNumber.substring(0,3);
//3、截取手机号码后四位
String end = phoneNumber.substring(7);
//4、拼接
String result = star + "****" + end;
//5、打印结果
System.out.println(result);
}
}
案例2:身份证信息查看
身份证号1、2位表示省份,3、4位表示城市,5、6位表示区县,7~14位表示出生年月日,15、16位表示所在地派出所,17位表示性别(奇数为男生,偶数为女生),18位表示个人信息码(随机产生)
7~14位表示出生年月日,17位表示性别(奇数为男生,偶数为女生),已知身份证号码,打印出生年月日和性别。
package sss;
import java.sql.SQLOutput;
import java.util.Scanner;
public class StringDome {
public static void main(String[] args) {
//1、定义一个字符串记录身份证号码
String id = "123456202207276789";
//2、获取出生年月日
String year = id.substring(6,10);
String month = id.substring(10,12);
String day = id.substring(12,14);
System.out.println("人物信息为:");
System.out.println("出生年月日:" + year + "年" + month + "月" + day + "日");
//3、获取性别
/**利用ASCII码表进行转换,将字符转换为数字
* '0' -----> 48
* '1' -----> 49
* '2' -----> 50
* '3' -----> 51
* ASCII码号比数字值大48
*/
char gender = id.charAt(16);
int num = gender- 48; //将字符转化为数字
System.out.print("性别为:");
if(num%2==0){
System.out.println("女");
} else{
System.out.println("男");
}
}
}
案例3:敏感词替换
package sss;
public class StringDome {
public static void main(String[] args) {
//1、获取说的话
String talk = "你玩的真好,TMD";
//2、把里面的敏感词TMD,替换成***
String result = talk.replace("TMD","***");
//3、打印结果
System.out.println(result);
}
}
package sss;
public class StringDome {
public static void main(String[] args) {
//1、获取说的话
String talk = "你玩的真好,TMD,SB";
//定义一个敏感词库
String[] arr = {"TMD","CNM","SB","MLGB"};
//循环得到数组中的每一个敏感词,依次进行替换
for (int i = 0; i < arr.length; i++) {
talk = talk.replace(arr[i],"***");
}
//3、打印结果
System.out.println(talk);
}
}
10、StringBuilder的基本操作(字符串知识点2)
1、StringBuilder概述。
StringBuilder可以看成是一个容器,创建之后里面的内容是可变的。
作用:提高字符串的操作效率。
一个可变的操作字符串的容器,可以高效的拼接字符串,还可以将容器里面的内容反转。
2、StringBuilder构造方法。
1、方法名:
public StringBuilder()
说明:创建一个空白可变字符串对象,不含有任何内容。
StringBuilder sb = new StringBuilder();
2、方法名:
public StringBuilder(String str)
说明:根据字符串的内容,来创建可变字符串对象。
StringBuilder sb = new StringBuilder("abc");
3、StringBuilder常用方法。
package GGG;
public class hhh {
public static void main(String[] args) {
//1、创建对象
StringBuilder sb1 = new StringBuilder();
System.out.println(sb1); //打印时无输出
StringBuilder sb2 = new StringBuilder("abc");
System.out.println(sb2); //打印时输出abc
StringBuilder sb3 = new StringBuilder("abcdef");
//2、添加元素
sb2.append(1);
sb2.append(2.3);
sb2.append(true);
System.out.println(sb2); //添加后输出abc12.3true(容器的属性值,并非字符串)
sb1.append(1).append(2.3).append(true); //链式编程
System.out.println(sb1); //输出为12.3true
//3、再把StringBuilder变回字符串
String str = sb2.toString();
System.out.println(str); //输出abc12.3true(字符串)
//3、反转
sb3.reverse();
System.out.println(sb3); //输出fedcba
//4、获取长度
int len = sb3.length();
System.out.println(len); //6
/**普及:
* 因为StringBuilder是Java已经写好的类
* Java在底层对他进行了一些特殊处理
* 打印对象不是地址值,而是属性值。
*/
}
}
4、练习题:对称字符串。
需求:键盘接受一个字符串,程序判断出该字符串是否是对称字符串,并在控制台打印是或不是,对称字符串:123321、111;非对称字符串:123123。
package GGG;
import java.util.Scanner;
public class hhh {
public static void main(String[] args) {
/**使用StringBuilder的场景
* 1、字符串的拼接
* 2、字符串的反转
*/
//1、键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
//2、反转键盘录入的字符串
//创建StringBuilder容器,然后把str的值放进容器,反转容器中的字符串,
//将容器中的字符串转化为现实中的字符串,然后将结果赋值给result
String result = new StringBuilder().append(str).reverse().toString();
//3、比较
if(str.equals(result)){
System.out.println("对称字符串");
} else {
System.out.println("非对称字符串");
}
}
}
5、练习题:拼接字符串。
需求:定义一个方法,把int数组中的数据,按照指定的格式拼接成一个字符串返回。调用该方法,并在控制台输出结果。
例如:数组为int[] arr = {1,2,3};
执行方法后的输出结果为:[1,2,3]
package GGG;
public class hhh {
public static void main(String[] args) {
//1、定义数组
int[] arr = {1,2,3};
//2、调用方法把数组变成字符串
String str = arrToString(arr);
System.out.println(str);
}
public static String arrToString(int[] arr){
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("]");
return sb.toString();
}
}
11、Stringjoiner(字符串知识点3)
1、StringJoiner概述
StringJoiner跟StringBuilder一样,也可以看成是一个容器,创建之后里面的内容是可变的。
作用:提高字符串的操作效率,而且代码编写特别简洁,但是目前市场上很少有人用。
JDK8出现的一个可变的操作字符串的容器,可以高效,方便的拼接字符串,在拼接的时候,可以指定间隔符号,开始符号,结束符号。
2、StringJoiner的构造方法。
3、StringJoiner的成员方法。
package GGG;
import java.util.StringJoiner;
public class hhh {
public static void main(String[] args) {
//1、创建一个对象,并指定中间的间隔符号
StringJoiner sj1 = new StringJoiner("---");
StringJoiner sj2 = new StringJoiner(",","[","]");
//2、添加元素
sj1.add("aaa").add("bbb").add("ccc");
sj2.add("aaa").add("bbb").add("ccc");
//3、获取长度
int len = sj2.length();
System.out.println(len); //13
//4、打印结果
System.out.println(sj1); //aaa---bbb---ccc
System.out.println(sj2); //[aaa,bbb,ccc]
//5、变成字符串
String str = sj1.toString();
System.out.println(str); //aaa---bbb---ccc
}
}
12、字符串相关类的底层原理(字符串知识点4)
扩展底层原理1:字符串存储的内存原理。
(1)、直接赋值会复用字符串常量池中的。
(2)、new出来不会复用,而是开辟一个新的空间。
扩展底层原理2:==号比较的到底是什么?
(1)、基本数据类型 比较数据值。
(2)、引用数据类型 比较地址值。
扩展底层原理3:字符串拼接的底层原理。
扩展底层原理4:StringBuilder提高效率原理图。
扩展底层原理5:StringBuilder源码分析。
13、较难练习-罗马数字的两种写法
练习案例1:转换罗马数字。
需求:键盘录入一个字符串,
要求1:长度小于等于9
要求2:只能是数字
将内容变成罗马数字
解法1:查表法
package GGG;
import java.util.Scanner;
import java.util.StringJoiner;
public class hhh {
public static void main(String[] args) {
//1、键盘了录入一个字符串
Scanner sc = new Scanner(System.in);
String str;
while (true) {
System.out.println("请输入一个人字符串");
str = sc.next(); //输入123456
//2、校验字符串是否满足规则
boolean flag = checkStr(str); //调用方法,对输入进行检测
if(flag){ //输入符合规范
break;
} else {
System.out.println("请重新输入");
continue;
}
}
//2、查表法:将内容变成罗马数字
StringJoiner sb = new StringJoiner("-"); //用于字符串拼接
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i); //根据索引获取字符串每一位上的值
int number = c - 48; //将获得的字符串转化为数字
String s = changeLuoMa(number); //用数字作为索引,获取对应的罗马数字
sb.add(s); //对罗马数字进行拼接操作
}
System.out.println(sb); //打印拼接后的结果I-II-III-IV-V-VI
}
//定义方法,把阿拉伯数字转化为罗马数字
public static String changeLuoMa(int number){
//定义一个数组,让索引跟罗马数字产生一个对应的关系
String[] arr = {"","I","II","III","IV","V","VI","VII","VIII","IX"};
return arr[number]; //number的值为1时,函数返回值为I
}
//定义方法,检测输入是否规范
public static boolean checkStr(String str){
//要求1:长度为小于等于9
if(str.length() > 9){
return false;
}
//要求2:只能是数字0~9
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if(c < '0' || c > '9'){
return false;
}
}
//当所有的检测都通过之后,证明输入符合规范,则返回true
return true;
}
}
解法2:switch法
package GGG;
import java.util.Scanner;
import java.util.StringJoiner;
public class hhh {
public static void main(String[] args) {
//1、键盘了录入一个字符串
Scanner sc = new Scanner(System.in);
String str;
while (true) {
System.out.println("请输入一个人字符串");
str = sc.next(); //输入123456
//2、校验字符串是否满足规则
boolean flag = checkStr(str); //调用方法,对输入进行检测
if(flag){ //输入符合规范
break;
} else {
System.out.println("请重新输入");
continue;
}
}
//2、查表法:将内容变成罗马数字
StringJoiner sb = new StringJoiner("-"); //用于字符串拼接
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i); //根据索引获取字符串每一位上的值
String s = changeLuoMa(c); //用字符作为索引,获取对应的罗马数字
sb.add(s); //对罗马数字进行拼接操作
}
System.out.println(sb); //打印拼接后的结果I-II-III-IV-V-VI
}
//定义方法,把阿拉伯数字转化为罗马数字
public static String changeLuoMa(char num){
//定义一个数组,让索引跟罗马数字产生一个对应的关系
String s;
switch(num){
case '0' : s = ""; break;
case '1' : s = "I"; break;
case '2' : s = "II"; break;
case '3' : s = "III"; break;
case '4' : s = "IV"; break;
case '5' : s = "V"; break;
case '6' : s = "VI"; break;
case '7' : s = "VII"; break;
case '8' : s = "VIII"; break;
case '9' : s = "IX"; break;
default: s = ""; break;
}
return s; //number的值为1时,函数返回值为I
}
//定义方法,检测输入是否规范
public static boolean checkStr(String str){
//要求1:长度为小于等于9
if(str.length() > 9){
return false;
}
//要求2:只能是数字0~9
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if(c < '0' || c > '9'){
return false;
}
}
//当所有的检测都通过之后,证明输入符合规范,则返回true
return true;
}
}
JDK12新特性:JDK版本在12以后,解法2switch中的代码可以写成下面的形式
14、较难练习-调整字符串的内容
练习题:调整字符串。
需求:给定两个字符串,A和B。
A的旋转操作就是将A最左边的字符移动到最右边。
例如:若A='abcde',在移动一次之后结果就是'bcdea'。
如果在若干次调整操作之后,A能变成B,那么返回True。
如果不能匹配成功,则返回false。
package GGG;
public class hhh {
public static void main(String[] args) {
//1、定义两个字符串
String strA = "abcde";
String strB = "cdeab";
//2、调用方法,旋转字符串
boolean result = check(strA,strB);
//3、输出结果
System.out.println(result);
}
//定义方法,循环旋转并比较
public static boolean check(String strA,String strB){
for (int i = 0; i < strA.length(); i++) { //循环次数和字符串长度有关系
strA = rotate(strA); //将移动后的字符串赋值给strA
if(strA.equals(strB)){ //将strA与strB作比较
return true;
}
}
return false; //当所有情况都比较完毕后,如果还不一样,则输出false
}
//定义方法,选择字符串,把左侧的字符移动到右侧
public static String rotate(String str){
/**套路
* 如果我们看到要修改字符串的内容,可以有两个办法:
* 方法1、用subString进行截取,把左边的字符截取出来拼接到右侧去。
* 方法2、可以把字符串先变成一个字符数组,然后调整字符数组里面的数据,最后再把字符数组变成字符串。
*/
/*方法1的代码
char first = str.charAt(0); //获取第一个字符
String end = str.substring(1); //获取剩余的字符
String result = end +first; //拼接操作
return result;*/
//方法2的代码:
char[] arr = str.toCharArray(); //把字符串变为字符数组
char first = arr[0]; //拿到0索引上的字符
//把剩余的字符依次往前移动一个位置
for (int i = 1; i < arr.length; i++) {
arr[i - 1] = arr[i];
}
arr[arr.length - 1] = first; //把原来0索引上的字符放到最后一个索引
//利用字符数组创建一个字符串对象
String result = new String(arr);
return result;
}
}
15、后续练习思路分析
案例1:键盘录入任意字符串,打乱里面的内容。
package GGG;
import java.util.Random;
import java.util.Scanner;
public class hhh {
public static void main(String[] args) {
//1、键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
//2、打乱里面的内容
char[] arr = str.toCharArray();
//3、打乱数组里面的内容
//从0索引开始,跟一个随即索引进行位置的交换
//当数组里面的每一个元素都跟一个随即索引进行交换完毕之后,那么内容就打乱了
Random r = new Random();
for (int i = 0;i < arr.length;i++) {
int sui = r.nextInt(arr.length - 1);
char temp = arr[i];
arr[i] = arr[sui];
arr[sui] = temp;
}
//4、把字符数组再变回字符串
String result = new String(arr);
System.out.println(result);
}
}
案例2:生成验证码。
需求:可以是小写字母,也可以是大写字母,还可以是数字。
规则:长度为5,4个字母,1个数字。其中数字只有1位,可以出现在任意位置。
package GGG;
import java.util.Random;
public class hhh {
public static void main(String[] args) {
String result = "";
//1、把大写字母和小写字母放到数组当中
char[] chs = new char[52]; //定义字符型数组,用来存储大小写字母
for (int i = 0; i < chs.length; i++) {
if(i<=25){ //i的范围为0~25
//添加小写字母。ASCLL码表中a对应97
chs[i]=(char)(97+i);
} else{ //i的范围为26~52
//添加大写字母。ASCLL码表中A对应65
chs[i]=(char)(65 + (i - 26));
}
}
//2、随机抽取四次
//随机抽取数组中的索引
Random r = new Random();
for (int i = 0; i <4 ; i++) { //多次抽取,要利用循环
//随机抽取一个元素,将对应的字母赋值给变量randomchar
int randomchar = r.nextInt(chs.length);
result = result + chs[randomchar]; //字符串+字符的拼接 结果为字符串
}
//3、随机抽取一个数字,赋值给变量randomNumber
int randomNumber = r.nextInt(10); //获取一个0~9之间的随机数
result = result + randomNumber; //字符串拼接
//4、打印生成的验证码:字母+数字
System.out.println(result);
//5、打乱里面的内容
char[] arr = result.toCharArray(); //变成字符数组
Random rs = new Random();
int sui = rs.nextInt(arr.length - 1);
//随机索引对应的值与最后的数字调换
char temp = arr[arr.length-1];
arr[arr.length-1] = arr[sui];
arr[sui] = temp;
//6、把字符数组再变回字符串
String ss = new String(arr);
System.out.println(ss);
}
}
案例3:给定两个以字符串形式表示的非负整数num1和num2,返回两者的乘积,他们的乘积也表示成字符串的形式 。
不需要考虑乘积过大之后的结果,认为乘积一定小于int的最大值
package GGG;
/**
* 给定两个以字符串形式表示的非负整数num1和num2,返回两者的乘积,他们的乘积也表示成字符串的形式
* 不需要考虑乘积过大之后的结果,认为乘积一定小于int的最大值
*/
public class hhh {
public static void main(String[] args) {
String num1 = "11";
String num2 = "22";
//把num1和num2变成对应的整数才可以
//先遍历每一个字符,然后把字符变成数字,然后再把数字做调整
int num11 = toInt(num1);
int num22 = toInt(num2);
//System.out.println(num11*num22);
String zf = num11*num22 + "";
System.out.println(zf);
}
//定义一个方法,输入一个字符串,把它变成对应的int类型的整数
public static int toInt(String a) {
int sum = 0;
for (int i = 0; i < a.length(); i++) {
char c = a.charAt(i);
int shu = c - 48;
sum = sum * 10 +shu;
}
return sum;
}
}
案例4:
给你一个字符串s,由若干单词组成,单词前后用一些空格字符隔开。 * 返回字符串中最后一个单词的长度。 * 单词是指仅由字母组成、不包含任何空格字符的最大字符串。 * * 实例 1:输入:s = "hello world" 输出 5 * 解释:最后一个单词是“world”,长度为5 * * 实例 1:输入:s = "fly me to the moon" 输出 4 * 解释:最后一个单词是“moon”,长度为4 * * 实例 1:输入:s = "luffy is still joyboy" 输出 6 * 解释:最后一个单词是“joyboy”,长度为6
package GGG;
public class hhh {
public static void main(String[] args) {
String str = "fly me to the moon";
String strh = "";
int count = 0;
for (int i = str.length() - 1; i > 0; i--) {
char c = str.charAt(i);
if(Character.isSpaceChar(c)){
break;
} else {
strh = c + strh ;
count++;
}
}
System.out.println(strh);
System.out.println(count);
}
}