JavaSE02

最新推荐文章于 2022-01-12 15:48:21 发布

dingxiaozhuang

最新推荐文章于 2022-01-12 15:48:21 发布

阅读量282

点赞数

分类专栏： java # JAVASE 文章标签： java

本文链接：https://blog.csdn.net/Judith__/article/details/109289871

版权

java 同时被 2 个专栏收录

32 篇文章 0 订阅

订阅专栏

JAVASE

14 篇文章 0 订阅

订阅专栏

1.equals(Object obj)

equalse和==的区别

在基本类型中用于比较变量的值,如果用于引用类型,比较的是两个引用变量是否指向同一个对象
equals重写object中的equals方法,重写以后可以用于比较两个对象的内容是否一样

public class DemoEquals {
		public static void main(String[] args) {
			Point p = new Point(5,6);
			Point p2 = new Point(5,6);
			System.out.println(p == p2);//两个对象，是不同的对象
			System.out.println(p.equals(p2));
		}
}

2.Object(顶级父类)

定义:Object(顶级父类),所有类的一个父类叫Object,默认的父类是Java.lang.Object;Object类型的引用变量可指向任何类型对象(向上造型)
Object常见方法:
toString()返回一个String类型,该方法的意义是将当前对象转换为一个字符串,Object已经实现了该方法,返回的字符串是当前对象(句柄)引用,格式为包名.类型@散列吗,该字符串在实际开发中的意义不大,所以通常需要使用这个方法是需要重写.
3.toString()方法是非常有用的调试工具(一般返回的是类中的成员变量的值,强烈建议自定义的对象toString()方法)

public class DemoObject extends Object {
	public static void main(String[] args) {
		Person p = new Person("测试",30);
		//System.out.println(任意对象);		//直接调用toString方法，在这里toString()可以省略
		System.out.println(p);	
	}
}

3.正则

1.定义:正则在实际开发中,经常需要对字符串数据进行一些复杂的匹配,查找,替换等操作,通过"正则表达式",方便的实现了字符串的复杂操作
2.什么是正则表达式?
(1)正则本来就是一个字符串;
(2)正则用于检索目标字符串中的规则;
(3)正则是规定字符串是否合理;
(4)正则需要解析器执行,Java提供相关的解析器处理API;
(5)常见的编程语言大部分都支持提供正则API.例如:正则表达式"[a-z]“表示从a到z的任意一个字符;正则表达式”[a-z]+"表示从a到z的一个或者多个字符.
(6)matcher(正则表达式)方法,将一个字符串与正则表达式进行匹配,如果匹配成功,就返回true,否则就返回false.
在这里插入图片描述

在这里插入图片描述

public class DemoReg {
	public static void main(String[] args) {
		String regex1 = "[a-z]";
		String regex2 = "[^a-z]";
		String regex3 = "[a-z&&[^bc]]";
		String regex4 = "\\d";								//点和？是双斜杠
		String regex5 = "\\D";			//[^0-9]
		String regex6 = "\\s";			//[\t]
		String regex7 = "\\S";			//[^\s]
		String regex8 = "\\w";			//[a-zA-Z_0-9]
		String regex9 = "\\W";			//[^\w]System.out.println("a".matches(regex1));		//true
		System.out.println("b".matches(regex2));		//false
		System.out.println("f".matches(regex3));		//true
		System.out.println("1".matches(regex4));		//true
		System.out.println("1".matches(regex5));		//false
		System.out.println(" ".matches(regex6));		//true
		System.out.println("s".matches(regex7));		//true
		System.out.println("_".matches(regex8));		//true
		System.out.println("_".matches(regex9));		//false
		System.out.println("s2".matches(regex8));		//false
		System.out.println("c".matches(regex3));		//false
		
		String regex01 = "X?";
		String regex02 = "X*";
		String regex03 = "X+";
		String regex04 = "X{n}";
		String regex05 = "X{N,}";
		String regex06 = "X{n,m}";
		System.out.println("X".matches(regex01));
		System.out.println("".matches(regex02));
		System.out.println("X".matches(regex03));
		System.out.println("n*X".matches(regex04));
	}
}

4.正则表达式的多个表示

public class DemoReg02 {
	public static void main(String[] args) {
		//检索邮政编码（6位数）
		//  \d相当于0-9
		String reg = "[0-9][0-9][0-9][0-9][0-9][0-9]";
		String reg2="\\d\\d\\d\\d\\d\\d";
		String reg3="\\d{6}";//表示6个\\d
		String str ="234561";
		System.out.println(str.matches(reg3));
		
		String regex1="[a-z]*";			//[a-z]有任意多个  
		String regex2="\\w+\\.jar";		//\\w+表示有至少一个w
		String regex3="\\d?[a-z]*";		//
		//System.out.println("abcse".matches(regex1));//表示多个
		//System.out.println("".matches(regex1));//表示0个
/*		System.out.println("lang.jar".matches(regex2));		//true
		System.out.println(".jar".matches(regex2));		//false
		System.out.println("12sdhjhj".matches(regex3));//false
		System.out.println("sdhjhj".matches(regex3));	//true
		System.out.println("2".matches(regex3));		//true
*/		
		String regex4="\\w{5}";
		String regex5="\\d{5,}";
		String regex6="[a-zA-Z0-9]{4,10}";
		System.out.println("asdfe".matches(regex4));		//true
		System.out.println("2345t".matches(regex5));		//false
		System.out.println("34shd34Tr".matches(regex6));	//true
	}
}

5.小练习:匹配手机号/邮箱

public class DemoReg03 {
	public static void main(String[] args) {
	/**
	 * 匹配手机号
	 * 11位数字
	 * +86，+0086
	 * 
	 * (+86)?小括号将+86别弄成一个整体
	 * 分组（）可以将一系列正则表达式看做一个整体
	 * 分组时可以使用"|"表示"或”的关系
	 * 
	 * .和？转义字符“\\"
	 * "^"和”$"符号，^代表字符串开始和$结束
	 * 
	 */
		/*String phoneReg="^(\\+86|0086)?\\s*1\\d{10}$";
		String phone="+8618909892233";
		if(phone.matches(phoneReg)){
			System.out.println("手机号码通过");
		} else {
			System.out.println("请填写正确的手机号");
		}*/
		
		
		/**
		 * 匹配邮箱
		 * 262307846@qq.com
		 */
		String emailReg="^\\w{4,18}@[a-z0-9]+\\.[a-z]{2,3}$";
		String email="ding_262307846@qq.com";
		if(email.matches(emailReg)){
			System.out.println("邮箱通过");
		} else {
			System.out.println("请按找规范输入邮箱");
		}
	}
	
}

6.用正则表达式编写用户注册


public class DemoReg04 {
	public static void main(String[] args) {
		/*
		 * 用户注册
		 * 账号（要求6-12个字符）
		 * 密码（要求6个字符）
		 * 邮箱（满足邮箱格式）
		 * 手机（11位数字）
		 */
		Scanner scanner = new Scanner(System.in);
		System.out.println("用户注册");
		String regName="^\\w{6,12}$";
		String regPwd = "^\\w{6}";
		String regEmail = "^\\w+@[a-z]+\\.[a-z]{2,3}$";
		String regPhone = "1\\d{10}";
		String userName = scanner.next();
		if(!userName.matches(regName)){
			System.out.println("请输入合法账号6-12个字符");
			return;
		}
		System.out.println("请输入密码");
		String userPwd = scanner.next();
		if(!userPwd.matches(regPwd)){
			System.out.println("请输入合法密码6个字符");
			return;
		}
		
		System.out.println("请输入邮箱");
		String userEmail = scanner.next();
		if(!userEmail.matches(regEmail)){
			System.out.println("请输入合法邮箱");
			return;
		}
		
		System.out.println("请输入手机号");
		String userPhone = scanner.next();
		if(!userPhone.matches(regPhone)){
			System.out.println("请输入合法密码6个字符");
			return;
		}
		
		System.out.println("注册成功");
		/*System.out.println("用户注册");
		System.out.println("请输入账号:账号（要求6-12个字符）");
		String acReg="\\w{6,12}";
		String s1 = scanner.nextLine();
		if(s1.matches(acReg)){
			System.out.println("账号输入正确");
		} else {
			System.out.println("请输入正确的账号");
			return ;
		}
		
		System.out.println("请输入密码:密码（要求6个字符）");
		String passReg="^\\d{6}$";
		String s2 = scanner.nextLine();
		if(s2.matches(passReg)){
			System.out.println("密码输入正确");
		} else {
			System.out.println("请输入正确的密码");
			return;
		}
		

		System.out.println("请输入邮箱");
		String emailReg="^\\w{4,12}@[a-z0-9]+\\.[a-z]{2,3}$";
		String s3 = scanner.nextLine();
		if(s3.matches(emailReg)){
			System.out.println("邮箱输入正确");
		} else {
			System.out.println("请输入正确的邮箱");
			return;
		}
		
		System.out.println("请输入手机号");
		String telReg="^\\d{11}$";
		String s4 = scanner.nextLine();
		if(s4.matches(telReg)){
			System.out.println("手机号输入正确");
		} else {
			System.out.println("请输入正确的手机号");
			return;
		}*/
	}
}

7.split()分隔符的应用

public class DemoReg05 {
	public static void main(String[] args) {
		/*
		 * split()分隔字符串\s
		 * 主要用途就是：字符串的分割，而且在涉及“变动字符串，如我们常说的StringBuffer中最为常用
		 */
		String str = "java    cpp   php  c#";
		String[] s = str.split("\\s+");
		System.out.println(Arrays.toString(s));
		
		String line = "1000+200-900=300";
		String[] ss = line.split("\\+|-|=");			//+必须加转义字符，-和=可以没有
		System.out.println(Arrays.toString(ss));
	}
}

8.replaceAll(String regex,String str)方法

String提供了用于字符串替换的方法:replaceAll:将字符串匹配正则表达式regex的字符串替换成str;
repalce:替换部分数据

public class DemoReplaceAll {
	public static void main(String[] args) {
		String str = "sbcaonima1223zoukai78998768";
		str = str.replace("caonima", "字符");
		System.out.println(str);
		str = str.replaceAll("1223|12|23|78998768", "数字");
		System.out.println(str);
	}
}

9.小练习2:利用正则替换用户输出信息中的敏感词

public class DemoReplaceAll02 {
	public static void main(String[] args) {
		//敏感词
		String messageReg="TMD";
		Scanner scanner = new Scanner(System.in);
		System.out.println("发送消息……");
		String input = scanner.next();
		input = input.replaceAll(messageReg, "**");			//把敏感词替换成***
		System.out.println(input);
	}
}

10.包装类型

由于基本类型没有面向对象的特征,为了他们能够参与到面向对象的开发中,java为这8个基本类型提供了对应的8个包装类
6个数字相关的包装类继承自java.lang.Number;number是Byte Double Float Integer Long Short类的父类,Numebr是一个抽象了,定义了不同类型的数字之间相互转换的方法,所以6个数字类型包装类都可以将其基本类型在这之间转换
== int和Integer的区别==
(1)Integer是int的包装类,int则是java的一种基本数据类;
(2)Integer变量实例化后才能使用,而int变量不需要
(3)Integer实际是对象的引用,当new一个Integer时,实际上是生成一个指针,指针指向此对象,而int则是直接存放数据
(4)Integer的默认值是null,int的默认值是0
把包装类转换称为基本类型:int a2 = i2.intValue();

public class IntegerDemo {
	//int a=null;
	Integer a1 = null;
	public static void main(String[] args) {
		Number d = 122.34;
		Number n = 7775;
		//输出d和n对象所属类型
		System.out.println(d.getClass().getName());
		System.out.println(n.getClass().getName());
		//将基本类型转换为包装类型
		int a = 2;
		int b=2;
		Integer i1 = new Integer(a);
		System.out.println(i1.getClass().getName());
		
		//推荐使用包装类的静态方法valueOf()来转换
		Integer i2 = Integer.valueOf(b);
		Integer i3 = Integer.valueOf(a);
		System.out.println(i2.getClass().getName());
		System.out.println(i2.equals(i3));
		System.out.println(i2==i3);
		
		/**
		 * 把包装类型转换为基本类型
		 * 比如：Integer转换为int类型用intValue();
		 */
		int a2 = i2.intValue();
		System.out.println(a2);
	}
}

11.数字类型的包装类

数字类型的包装类都支持两个常量
MAX_VALE,MIN_VALUE;

public class IntegerDemo02 {
	public static void main(String[] args) {
		//获取int最大值
		int max=Integer.MAX_VALUE;
		System.out.println(max);
		//获取int最小值
		int min=Integer.MIN_VALUE;
		System.out.println(min);
		//获取long最大值
		long max2 =Long.MAX_VALUE;
		System.out.println(max2);
		//获取long最小值
		long min2 = Long.MIN_VALUE;
		System.out.println(min2);
	}
}

12.包装类的静态方法

包装类的静态方法:parseXX(String str),可以将字符串解析为对应的基本类型数据,但是前提是该字符串描述的数据能被基本类型正确表示

public class IntegerDemo03 {
	public static void main(String[] args) {
		String str ="123";
		//把字符串转换为int基本类型
		int n = Integer.parseInt(str.toString());
		int n1 = Integer.valueOf(str);
		System.out.println(n);
		System.out.println(n1);
		
		Double b = Double.parseDouble(str);
		System.out.println(b);
	}
}

13.拆装箱

在JDK1.5之后推出一个新的特性,自动拆装箱,该特性是编译器认可,但不是JVM编译,编译器在编译代码时若遇到基本类型与包装类型互用时,会自动补全他们之间转换的代码.这样做可以让我们在源代码中编写时不再考虑互换.

public class IntegerDemo04 {
	public static void main(String[] args) {
		int a = 2;
		//Integer n = new Integer(a);
		Integer n = Integer.valueOf(a);
		int a1 = n.intValue();
		
		int i1=n;
		/*int i1=n;
		 * 触发了自动拆装箱型特性，编译器会将代码改编为
		 * int i1 = new Integer(2).int Value(); 
		 */
		Integer i2 =a;
		
	}
}