常用类库
java.lang
java.lang包下放置了Java开发中常用的类和接口,所以为简化该包下类的使用,java.lang包下的类在使用时不需要导入这些类
java.lang包下常用类有:
- Object
- String
- StringBuffer和StringBuilder
- 八种基本数据类型的包装类
- Thread等等
一、Object类
java.lang.Object类是类层次结构中最顶层父类。所有的类(包括数组)直接或者间接的继承自Object类,同时也继承了该类中的方法
Object的构造方法:
- Object类只有一个无参的构造方法
- Object()
Object中常用的方法:
- boolean equals(Object o) 比较两个对象是否相同
- int hashCode() 返回一个对象的哈希码
- String toString() 将一个对象转换为字符串
1.getClass()
获取该对象的类的完整路径结构!
//getClass(): //获取该对象的类的完整结构
Student stu= new Student("张三",18);
Class clazz = stu.getClass();
System.out.println(clazz);
Class clazz_1 = Student.class;
String name = clazz_1.getName();//获取完整路径
System.out.println(name);
String simpleName = clazz_1.getSimpleName();
System.out.println(simpleName);//获取当前类名
运行结果:
class com.changyongleiku.Objece_1.Student
com.changyongleiku.Objece_1.Student
Student
2.hashcode()*
获取对象在内存中的地址!
@Override
public int hashCode() {
return Objects.hash(name, age);
}
//hashcode() //获取对象在内存中的地址
int i = stu.hashCode();
System.out.println(i);
运行结果:
460141958
注意:
相同的对象应该具有相同的哈希码值,所以重写equals()的方法也要重写hashcode()方法。
3.toString()*
对象的字符串形式!
@Override
public String toString() {
return super.toString();
}
重写toString()方法:
@Override
public String toString() {
return this.name+" "+this.age;
}
//toString()对象的字符串形式
System.out.println(stu);
运行结果:
张三 18
4.equals()*
判断字符串是否相等:
equals(Object obj);判断传入的对象和当前对象是否相等
boolean equals(Object o):
- Object类的equals方法用于判断两个对象是否相等
- Object类的equals方法的返回值为boolean的true和false
- Object类的equals方法只有一种情况返回true:两个非空的引用变量o1和o2指向的是同一个对象时
//判断传入的对象和当前对象是否相等
public boolean xd(Object obj){
if(obj == null){
return false;
}if(!(obj instanceof Student)){
return false;
}
Student stu = (Student)obj;
if(stu.getAge() == this.age && stu.getName() == this.name){
return true;
}
return false;
}
//自己写的
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
//自带的
equals方法和==的区别:
- ==可以用于比较基本数据类型的值
- ==可以用于比较两个对象是否相等
- equals只能比较两个对象是否相等
== 比较地址(基本数据类型)
equals比较值(引用数据类型)
注意:
当此方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码.
5.Clone()
克隆: 要实现接口Cloneable
public class Student implements Cloneable{
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
克隆后判断相等。
Student stu_3 = (Student)stu.clone();
System.out.println(stu.equals(stu_3));
6.finalize()
当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。
7.创建一个类重写方法
package com.changyongleiku.Objece_1;
import java.util.Objects;
public class PErson {
private String name;
private int age;
private String gender;
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
/* @Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
PErson pErson = (PErson) o;
if (age != pErson.age) return false;
if (name != null ? !name.equals(pErson.name) : pErson.name != null) return false;
if (gender != null ? !gender.equals(pErson.gender) : pErson.gender != null) return false;
return email != null ? email.equals(pErson.email) : pErson.email == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
result = 31 * result + (gender != null ? gender.hashCode() : 0);
result = 31 * result + (email != null ? email.hashCode() : 0);
return result;
}*/
//判断字符串是否相等
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
PErson pErson = (PErson) o;
return age == pErson.age &&
Objects.equals(name, pErson.name) &&
Objects.equals(gender, pErson.gender) &&
Objects.equals(email, pErson.email);
}
//哈希编码
@Override
public int hashCode() {
return Objects.hash(name, age, gender, email);
}
//显示属性
@Override
public String toString() {
return "PErson{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
", email='" + email + '\'' +
'}';
}
//构造方法
public PErson() {
}
public PErson(String name, int age, String gender, String email) {
this.name = name;
this.age = age;
this.gender = gender;
this.email = email;
}
}
二、String类
-
String类代表字符串,提供了开发中常用的字符串处理的方法,如:求字符串的长度、截取字符串、替换字符串等方法
-
字符串是常量,它的值创建之后就不可以再修改了。
String类常用构造方法
- String() 无参构造方法
- String(String str) 有一个字符串参数的构造方法
- String(char[]ch) 有一个char类型数组参数的构造方法
- String(byte[] b) 有一个byte数组参数的构造方法
声明和创建字符串对象的方式
String类常用方法:
- int length() 求字符串值的字符个数
- boolean equals(Object o) 比较两个字符串是否相同
- String replace(char old,char n) 字符串替换
- char charAt(int index) 返回指定字符串指定位置的字符
- int **compareTo(String s)**按字典顺序比较字符串大小
- boolean endsWith(String s) 比较字符串是否以指定的参数结尾
- boolean **startsWith(String s)**比较字符串是否以指定的参数开头
- String **valueOf(int i)**将基本数据类型转换为字符串
- boolean isEmpty() 判别一个字符串值的长度是不是为0
- int indexOf(int ch) 返回指定字符ch在字符串中的索引
- int **lastIndexOf(int ch)**返回指定字符ch在字符串中最后出现的索引
- String **substring(int begin)**从指定索引位置截取字符串
- split 根据给定分隔符拆分此字符串
- toCharArray 将此字符串转换为一个新的字符数组。
- toLowerCase 转小写
- toUpperCase 转大写
- trim 去掉前后空格/忽略前导空白和尾部空白
- concat 字符串拼接
String类中的构造方法和常用方法:
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws UnsupportedEncodingException {
//常用构造方法
//String 类被final修饰,
//字符串一旦声明好,长度不能改变。对他的运算就是产生新的字符串。
String str = "hello";//基本数据类型
String s = new String("hello");//引用数据类型
System.out.println(s.equals(str));//true
System.out.println(s==str);//false
//将ASCII转换成字符
s = new String (new byte[]{97, 98, 99});
System.out.println(s);//abc
s = new String(new byte[]{97,98,99},"utf8");
System.out.println(s);//abc
//编码 解码
s = "好";
byte[] utf8s = s.getBytes("utf8");
for (int i = 0; i < utf8s.length; i++) {
System.out.println(utf8s[i]);
}
/* -27
-91
-67*/
s = new String(utf8s,"utf8");
System.out.println(s);//好
//常用方法
//charAt() 返回指定索引处 的Char值
s = "sadqwdzxc";
char c = s.charAt(3);
System.out.println(c);//q
//compareTo 按字典顺序比较两个字符串
int qwe = s.compareTo("qwe");
System.out.println(qwe);//2
int aFc = s.compareToIgnoreCase("AFc");//忽略大小写,按字典顺序比较两个字符串
System.out.println(aFc);//18
//concat 字符串拼接
s = "sadqwdzxc";
String concat = s.concat(" word");
System.out.println(concat);//sadqwdzxc word
//contains 是否包含此字符
s = "sadqwdzxc";
boolean a = s.contains("a");
System.out.println(a);//true
//endsWith 判断是否以该字符结尾的
s = "sadqwdzxc";
boolean wewe = s.endsWith("wewe");
System.out.println(wewe);//false
//startsWith 判断是否以该字符开头的
s = "sadqwdzxc";
boolean wewe1 = s.startsWith("wewe");
System.out.println(wewe);//false
//indexOf 返回指定字符在此字符串中第一次出现处的索引
s = "sadqwdzxc";
int d = s.indexOf("d");
System.out.println(d);//2
//isEmpty 当且仅当 length() 为 0 时返回 true
boolean empty = s.isEmpty();
System.out.println(empty);//false
//replace 返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
s = "sadqwdzxc";
String replace = s.replace("d", "*");
System.out.println(replace);//sa*qw*zxc
//split 根据给定分隔符拆分此字符串
s = "aaa,bbb,ccc,ddd";
String[] split = s.split(",");
System.out.println(Arrays.toString(split));//[aaa, bbb, ccc, ddd]
//substring 从指定位置 截取返回一个新的字符串,它是此字符串的一个子字符串。
s = "hello world";
String substring = s.substring(6);
System.out.println(substring);//world
//substring 截取指定索引到指定索引的元素 [左闭右开)
String substring1 = ss.substring(2,4);
System.out.println(substring1);//ll
//toCharArray 将此字符串转换为一个新的字符数组。
char[] chars = s.toCharArray();
System.out.println(chars);//hello world
//toLowerCase 转小写
String s1 = s.toLowerCase();//转小写
System.out.println(s1);//hello world
//toUpperCase 转大写
String s2 = s.toUpperCase();
System.out.println(s2);//HELLO WORLD
//trim 去掉前后空格/忽略前导空白和尾部空白
s= " sd sd dasd ";
String trim = s.trim();
System.out.println(trim);//sd sd dasd
//转成字符串
int i = 1;
s = i + "";
String s4 = String.valueOf(10);
System.out.println(s);//1
System.out.println(s4);//10
// valueOf 返回 char 数组参数的特定子数组的字符串表示形式
String s3 = String.valueOf(new char[]{'a', 's', 's', 'a', 's'}, 2, 3);
System.out.println(s3);//sas
}
}
String类、StringBuffer和StringBuilder之间的区别:
String字符串是常量,一旦创建无法修改
StringBuffer和StringBuilder是可变字符串,创建之后仍可以修改
StringBuffer是线程安全的、StringBuilder线程不安全
三、StringBuffer类和StringBuilder
StringBuffer和StringBuilder都是带有缓冲区的可变字符串
为什么要使用StringBuffer或者StringBuilder?
一个String对象的长度是固定的,不能改变它的内容,也不能附加新的字符至String对象中。可以使用加号“+”运算符来连接字符串以达到附加新字符或字符串的目的,但使用加号“+”运算符会产生一个新的String实例,即需要另外分配空间。如果既想节省开销,又能改变字符串的内容,则可以使用StringBuilder类。
StringBuffer类的构造方法
- StringBuffer()
- StringBuffer(String s)
StringBuffer的常用方法
- StringBuffer **append(int i)**在可变字符串末尾追加I
- StringBuffer **insert(int offset,String s)**在可变字符串指定位置插入另外一个字符串s
- int length() 返回可变字符串中字符的个数
- String toString() 将可变字符串转化为字符串对象
public class Main {
public static void main(String[] args) {
String a = "as";
//构造方法
//构造一个其中不带字符的字符串缓冲区,初始容量为 16 个字符
StringBuffer s = new StringBuffer();
//构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容。
String str = "hello word ";
StringBuffer ss = new StringBuffer(str);
System.out.println(ss);
//常用方法
//append 追加
ss.append(" hello");
System.out.println(ss);//hello word hello
//delete 删除
ss.delete(15,20);//开始下标,结束下标
System.out.println(ss);//hello word
//insert 插入
ss.insert(5,"hello");//插入位置,插入字符
System.out.println(ss);//hellohello word
//replace 替换
ss.replace(0,5,"*****");//开始下标,结束下标,替换字符
System.out.println(ss);//*****hello word
//reverse() 倒转
ss.reverse();
System.out.println(ss);// drow olleh*****
//toString 转回字符串
String s1 = ss.toString();
System.out.println(s1);
}
}
四、包装类
java.lang包下为8种基本数据类型提供对应的包装类
8中基本数据类型以及对应的包装类
包装类提供了字符串、基本数据类型和包装类相互转化的方法
数字基本数据类型的包装类都继承了Number类,它们的使用方式相似,下面以常用的基本数据类型int对应的包装类Integer为例说明数字类型包装类的使用。
基本数据类型 int值转化为Integer类型对象:
-
int i = 20;
-
Integer integer1 = new Integer(i);//方法一
-
Integer integer2 = Integer.valueOf(i);//方法二
-
Integer对象转化为基本数据类型int值:
-
Integer integer = new Integer(20);
-
int i1 = integer**.intValue**();
-
-
String类型的数字转化为Integer对象:
-
String s = “120”;
-
Integer integer1 = new Integer(s);//方法一
-
Integer integer2 = Integer.valueOf(s);//方法二
-
-
Integer类型转化为String类型:
-
Integer integer = new Integer(20);
-
String s1 = integer.toString();
-
String类型的数字转化为基本数据类型的int值:
- String s = “120”;
- int i1 = Integer.parseInt(s);//方 法一
- Integer integer = new Integer(s);
- int i2 = integer.intValue();//方法二
基本数据类型int转化为字符串:
- int i1 = 20;
- String str = String.valueOf(i1);//方法一
- str = Integer.toString(i2);//方法二
Integer的equals方法:
-
Integer的equals方法继承自Object,并且进行了重写
-
Integer的equals方法只有一种情况返回true:两个Integer类型的对象 i1 和 i2包含的值相等时;其他情况返回false
如:
-
Integer i1 = new Integer(20);
-
Integer i2 = new Integer(30);
-
Integer i3 = new Integer(20);
-
boolean b = i1.equals(i2);//false
-
b = i1.equals(i3);//true
-
根据基本数据类型int和对应包装类Integer的知识,总结如下内容
- byte/short/long/float/double类型和包装类之间转换的方法
- byte/short/long/float/double的包装类和字符串之间的转换方法
- byte/short/long/float/double类型和字符串之间的转换方法
boolean类型的包装类Boolean
- Boolean用于将一个基本数据类型boolean值包装为对象
将boolean值转换为Boolean对象
- Boolean b1 = new Boolean(true);//方法一
- Boolean b2 = Boolean.valueOf(true);//方法二
将Boolean对象转换为boolean值
- Boolean b = new Boolean(true);
- boolean b1 = b.booleanValue();//方法一
String类型对象转换为Boolean对象
- String s=“true”;
- Boolean b1 = new Boolean(s);//方法一
- Boolean b2 = Boolean.valueOf(s);//方法二
将Boolean对象转换为String类型
- Boolean b = new Boolean(true);
- String s1 = b.toString();//方法一
- String s2 = Boolean**.toString**(b);//方法二
- String s3 = String.valueOf(b);//方法三
boolean值转换为String对象
- boolean b = true;
- String s1 = String.valueOf(b);
String对象转换为boolean值
- String s = “true”;
- boolean b1 = Boolean.parseBoolean(s);//方法一
- Boolean b = new Boolean(s);
- boolean b2 = b.booleanValue();//方法二
字符包装类Character用于将char类型值包装为对象
将char值转换为Character对象
- Character c1= new Character(‘A’);//方法一
- Character c2 = Character.valueOf(‘A’);//方法二
将Character对象转换为char值
- Character c1= new Character(‘A’);
- char ch1 = c1.toString();//方法一
- char ch2 = Character.toString(c1);//方法二
Character包装类除了提供以上char和Character相互转换的方法外也提供了以下有用的方法
包装类是将基本数据类型的值包装为Java中的对象,Java语言为8种基本数据类型分别提供了包装类.
包装类提供了基本数据类型、包装类、字符串之间的相互转换的方法,这些转换的的方法在今后的开发中十分有用。
public class Main {
public static void main(String[] args) {
//包装类
//把基本数据类型包装一下,
//Integer 构造方法的使用
//int--> Integer
Integer i = new Integer(90);
Integer.valueOf(i);
System.out.println(i);//90
//Integer--> int
int i1 = i.intValue();
System.out.println(i1);//100
//String-->Integer
i = new Integer("100");//只能转 "数字"
Integer.valueOf(i);
System.out.println(i);//100
//Integer--> String
String s = i.toString();
System.out.println(s);//100
//int-->String
String str = 10 +"";
String s1 = String.valueOf(str);
System.out.println(s1);
//String --> int
i = Integer.parseInt(str);
System.out.println(i);
//其他常用方法
Integer x = new Integer(3);
Integer y = new Integer(5);
//compareTo 比较两个对象大小
int i2 = x.compareTo(y);
System.out.println(i2);//-1 //x<y
//boolean 类型的包装类
//boolean --> Boolean
Boolean boo = new Boolean(true);
System.out.println(boo);
//String --> boolean
boo = new Boolean("true");
System.out.println(boo);//ture
boo = new Boolean("sdadadad");
System.out.println(boo);//false
//Boolean --> boolean
boolean b = boo.booleanValue();
System.out.println(b);
//String-->boolean
boolean asdad = Boolean.parseBoolean("asdad");
System.out.println(asdad);//false
//Boolean -- > String
boo.toString();
System.out.println(boo);//false
//Character 包装类
//char --> Character
Character charq = new Character('a');
//Character-->char
charq.charValue();
//Character-->String
charq.toString();
//char-->String
String.valueOf('a');
//String --> char
"a".charAt(0);
//Character的其他方法
Character cc = new Character('a');
// isDigit 确定指定字符是否为数字。
boolean a = Character.isDigit('5');
System.out.println(a);//true
//isLetter 确定指定字符是否为字母。
boolean a_1 = Character.isLetter('K');
System.out.println(a_1);//true
//isLetterOrDigit 确定指定字符(Unicode 代码点)是否为字母或数字。
boolean a_2 = Character.isLetterOrDigit('K');
System.out.println(a_2);//true
// isLowerCase 确定指定字符是否为小写字母。
boolean a_3 = Character.isLowerCase('K');
System.out.println(a_3);//fasle
// isUpperCase 确定指定字符是否为大写字母。
boolean a_4 = Character.isUpperCase('K');
System.out.println(a_4);//true
// 确定指定字符是否为空白字符。isWhitespace
boolean spaceChar = Character.isSpaceChar(' ');
System.out.println(spaceChar);//true
boolean whitespace = Character.isWhitespace('\n');///\\一般用这个
System.out.println(whitespace);//true
//转小写toLowerCase |、转大写:toUpperCase
Character.toLowerCase('H');
}
}
自动拆装箱:
public class main {
public static void main(String[] args) {
//自动拆装箱
//自动装箱
Integer i = 10;
Boolean o = true;
Integer q = 10;
Integer w = 10;
System.out.println(q==w);//true
Integer q_1 = 200;
Integer w_1 = 200;
System.out.println(q_1==w_1);//false
/* 范围 -128 ~ 127 一个字节内相等*/
//自动拆箱
int j = new Integer(10);
boolean ji = new Boolean(true);
//自动装箱
tt(5);
}
public static void tt(Object o){
System.out.println(o);
}
}
五、Math类
在java.lang.Math类中提供了在数学应用中常见的常量(如:PI值)以及方法(如:三角函数)
Math的构造方法是私有的,所有无法创建Math对象
Math中只有static修饰的常量和类方法
public class main {
public static void main(String[] args) {
//Math类 静态方法
Math.max(10,14);//最大
double pi = Math.PI; //静态常量 pi
Math.ceil();//向上取整
Math.floor();//向下取整
Math.round();//四舍五入
Math.sqrt();//平方根
Math.random();//获取一个随机数
//Random类 随机数
//Random r = new Random();
//r.nextInt(101);//1-100之间的随机数
//Sanner类 扫描器
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();//输入一个整数
String next = sc.next();//获取输入的字符串,以空格结束,空格后面的获取不到
String s = sc.nextLine();//获取输入的一整行
}
}
六、System
- System类代表运行时系统,提供了一些获取设置和获取当前系统运行环境的方法
- System有三个成员变量
- in 标准输入流
- out 标准输出流
- err 错误输出流
System中的方法
- System.arrayCope()//快速复制数组的方法
- System.exit(0);//退出Java虚拟机的方法
public class Main {
public static void main(String[] args) {
//System类
System.out.println("hello word");
PrintStream out = System.out;//输出流
InputStream in = System.in;//输入流
//从1970年到现在的秒数
long l = System.currentTimeMillis();
System.out.println(l);//1626939039073
long l_1 = System.currentTimeMillis();
System.out.println(l_1-l);//0
System.exit(0);//退出虚拟机 后面的东西不会运行
}
}
七、练习
练习一:
1.创建一个Student类,该有String类型的学号stuNo,String类型的姓名,要求将该类所有的成员变量进行封装,并且提供公共的getter和setter方法,重写equals方法,只要学生的学号相同即返回true,重写toString()方法,toString方法返回值类似”姓名:张三 学号:201301 ”
String 类 String str = “abcd”; 求字符串的字符个数
将str字符串截取为”cd”
import java.util.Objects;
public class Student {
private String stuNo;
private String name;
public String getStuNo() {
return stuNo;
}
public void setStuNo(String stuNo) {
this.stuNo = stuNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//只要学生的学号相同即返回true
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return Objects.equals(stuNo, student.stuNo);
}
@Override
public int hashCode() {
return Objects.hash(stuNo);
}
@Override
public String toString() {
return "学号:'" + stuNo + '\'' +
", 姓名='" + name + '\'' ;
}
//字符个数
public int count(String str){
return str.length();
}
//截取字符
public String jie(String str){
return str.substring(2);
}
public Student() {
}
public Student(String stuNo, String name) {
this.stuNo = stuNo;
this.name = name;
}
}
public class main {
public static void main(String[] args) {
Student stu = new Student("1026", "张三");
Student stu_1 = new Student("1026", "李四");
boolean equals = stu.equals(stu_1);
System.out.println("两个学生是否相等:"+equals);
String str = "abcd";
//打印学生信息
System.out.println(stu.toString());
System.out.println(stu_1.toString());
//获取字符串个数
int count = stu.count(str);
System.out.println("字符串个数为:"+count);
//截取字符串
String jie = stu.jie(str);
System.out.println("截取后的字符串为:"+jie);
}
}
练习二:
编写敏感词过滤程序
在网络程序中,如聊天室、聊天软件等,经常需要对一些用户所提交的聊天内容中的敏感性词语进行过滤。如“性”、“色情”、“爆炸”、“恐怖”、“枪”等,这些都不可以在网上进行传播,需要过滤掉或者用其他词语替换掉。
思路:将用户的聊天内容保存到一个字符串对象或一个StringBuilder对象中,然后与敏感词语进行比对。如果属于敏感词语,就过滤掉或替换掉。
正则解法:
public class Genghuan {
public static String gh(String str){
return str.replaceAll("(?:性|色情|爆炸|恐怖|枪)","*");
}
}
public class main {
public static void main(String[] args) {
String str = "你性福吗,色情这个东西,恐怖分子拿着枪,闯进了银行!";
String gh = Genghuan.gh(str);
System.out.println(gh);
}
}
StringBuffer 解法:
package com.changyongleiku.hw.hw_2;
public class mmIN {
public static void main(String[] args) {
String[] a = {"性","爆炸","在这里","怎样"};
String aa = "asdad性sdjafj爆炸sdsad性是否奈法在这里啊,你要怎么样怎样啊";
StringBuffer ss = new StringBuffer(aa);
for (int i = 0; i < a.length; i++) {
StringBuffer aaaa = new StringBuffer();
for (int j = 0; j < a[i].length(); j++) {
aaaa.append("*");
}
for(;;) {
ss.replace(ss.indexOf(a[i]), ss.indexOf(a[i]) + a[i].length(), String.valueOf(aaaa));
if(ss.indexOf(a[i])<0){
break;
}
}
}
ss.toString();
System.out.println(ss);
}
}
练习三:
在注册时通常要验证用户名和密码是否合法,运用学习过的知识完成如下操作:
用户名长度大于等于6位,必须包含数字和英文字母
密码长度大于等于8位,必须包含特殊符合_或者$,英文字母以及数字
以上两个条件同时成立注册才能成功。
正则解法:
public class ZhuCe {
private String usename;
private String password;
public void check(String username, String password) {
if ((username.length() < 6 || password.length() < 8) && (username != "^(\\d+[A-Za-z]+[A-Za-z0-9]*)|([A-Za-z]+\\d+[A-Za-z0-9]*)$"
|| password != "^[[0-9]+[a-zA-Z]+[$|_]+]+$")) {
System.out.println("注册失败");
} else {
System.out.println("注册成功");
}
}
public String getUsename() {
return usename;
}
public void setUsename(String usename) {
this.usename = usename;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
public ZhuCe() {
}
public ZhuCe(String usename, String password) {
this.usename = usename;
this.password = password;
}
public class main {
public static void main(String[] args) {
ZhuCe z = new ZhuCe();
Scanner scan = new Scanner(System.in);
System.out.println("请输入要注册的账号:");
String zhanghao = scan.next();
System.out.println("请输入要注册的密码:");
String mima = scan.next();
z.setUsename(zhanghao);
z.setPassword(mima);
z.check(z.getUsename(), z.getPassword());
}
}
Character解题:
package com.changyongleiku.hw.hw_3;
public class User1 {
//注册账号功能
public boolean verifyUserName(String username){
if(username.length()>=6&&containsDigit(username)&&containsLetter(username)&&!containsSpecialChar(username)&&!containsOtherSpecialChar(username)){
return true;
}
return false;
}
//注册密码
public boolean verifyPassword(String password){
if(password.length()>=8&&containsDigit(password)&&containsLetter(password)&&containsSpecialChar(password)&&!containsOtherSpecialChar(password)){
return true;
}
return false;
}
// 是否包含数字
public boolean containsDigit(String str){
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
if(Character.isDigit(chars[i])){
return true;
}
}
return false;
}
// 是否包含字母
public boolean containsLetter(String str){
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
if(Character.isLetter(chars[i])){
return true;
}
}
return false;
}
// 是否包含_或者$
public boolean containsSpecialChar(String str){
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
if(chars[i]=='_'||chars[i]=='$'){
return true;
}
}
return false;
}
// 是否包含其他字符
public boolean containsOtherSpecialChar(String str){
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
if(chars[i]!='_'&&chars[i]!='$'&&!Character.isDigit(chars[i])&&!Character.isLetter(chars[i])){
return true;
}
}
return false;
}
}
package com.changyongleiku.hw.hw_3;
public class mmmmAin {
public static void main(String[] args) {
User1 us = new User1();
boolean a1 = us.verifyUserName("asdawweqf123");
boolean a2 = us.verifyPassword("asdaszc12151_");
if(a1 && a2){
System.out.println("注册成功!");
}else{
System.out.println("注册失败!");
}
}
}