Java常用类（一）--------14

最新推荐文章于 2023-01-25 10:15:40 发布

Hsu.Y

最新推荐文章于 2023-01-25 10:15:40 发布

阅读量292

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_54287371/article/details/124671195

版权

一、包装类

1.1含义

Java为每种基本数据类型分别匹配的类

1.2出现原因

Java为纯面向对象语言，一切皆对象，8种基本数据类型不能创建对象，就破坏了Java
为纯面向对象语言的特征，所以Java为8种基本数据类型都分别匹配了对应的类，这种类
我们叫做包装类/封装类

1.3包装类

基本数据类型	包装类	继承关系
byte	Byte	Object.Number.Byte
short	Short	Object.Number.Short
int	Integer	Object.Number.Integer
long	Long	Object.Number.Long
float	Float	Object.Number.Float
double	Double	Object.Number.Double
char	Character	Object.Character
boolean	Boolean	Object.Boolean

1.4注意

int和char类型对应的包装类Integer和Character，其余的都是首字母大写

1.5应用场景

集合类似于数组，也是存放数据的容器，但是集合只能存放引用数据类型，如果想要存储基本数据类型，就存储基本数据类型对应的包装类对象

package com.qf.package_class;

public class Test01 {

	public static void main(String[] args) {
		
		//手动装箱：基本数据类型 转 包装类
		int i = 100;
		Integer integer = Integer.valueOf(i);
		System.out.println(integer);
	
		//手动拆箱：包装类  转 基本数据类型
		Integer integer = new Integer(100);
		int i = integer.intValue();
		System.out.println(i);
		
		//JDK1.5的新特性：自动装箱 和 自动拆箱
		
		//自动装箱：基本数据类型 转 包装类
		int i = 100;
		Integer integer = i;//底层：Integer.valueOf(i);
		System.out.println(integer);
			
		//自动拆箱：包装类  转 基本数据类型
		Integer integer = new Integer(100);
		int i = integer;//底层：integer.intValue();
		System.out.println(i);
		
		//将字符串转换为int值
		String str = "123";
		int value = Integer.valueOf(str);
		System.out.println(value);
	}
}

1.6包装类面试题

Integer底层有个缓存数组，缓存数组中存储了-128~127的Integer对象

package com.qf.package_class;

public class Test02 {

	public static void main(String[] args) {

		Integer integer1 = Integer.valueOf(100);//从缓存数组中获取Integer对象
		Integer integer2 = Integer.valueOf(100);//从缓存数组中获取Integer对象
		System.out.println(integer1 == integer2);//true
		
		Integer integer3 = Integer.valueOf(200);//新建Integer对象
		Integer integer4 = Integer.valueOf(200);//新建Integer对象
		System.out.println(integer3 == integer4);//false
	}
}

二、String类的使用

2.1知识点

String的底层是将字符串分解成字符数组

package com.qf.string_class;

public class Test01 {

	public static void main(String[] args) {

		String str = "123abc";
		
		str = str.concat("DEF123");//在此字符串末尾追加子字符串，并返回新的字符串
		str = str.substring(2);//从开始下标处截取到字符串末尾，并返回新的字符串
		str = str.substring(1, 7);//从开始下标处(包含)截取到结束下标处(不包含)，并返回新的字符串
		str = str.toLowerCase();//转小写，并返回新的字符串
		str = str.toUpperCase();//转大写，并返回新的字符串
		
		str = "  123  ab  c DEF 11 234557755  ";
		
		str = str.trim();//去掉首尾空格，并返回新的字符串
		
		str = str.replace('7', 'x');//替换字符，并返回新的字符串
		str = str.replaceFirst("23", "彭于晏");//替换第一次出现的字符串，并返回新的字符串
		str = str.replaceAll("55", "吴彦祖");//替换字符串，并返回新的字符串
		str = str.replaceAll(" ", "");//去空格
		
		System.out.println("判断字符串是否以某个字符串开头：" + str.startsWith("1彭于晏"));//true
		System.out.println("判断字符串是否以某个字符串结尾：" + str.endsWith("吴彦祖"));//true
		
		System.out.println("判断两个字符串是否相同(区分大小写)：" + str.equals("1彭于晏abcDEF11234吴彦祖xx吴彦祖"));//true
		System.out.println("判断两个字符串是否相同(不区分大小写)：" + str.equalsIgnoreCase("1彭于晏ABCdef11234吴彦祖xx吴彦祖"));//true
		
		System.out.println("查找子字符串在此字符串中第一次出现的下标：" + str.indexOf("吴彦祖"));
		System.out.println("查找子字符串在此字符串中最后一次出现的下标：" + str.lastIndexOf("吴彦祖"));
		
		System.out.println("获取指定下标上的字符：" + str.charAt(4));
		
		System.out.println("获取字符串的长度：" + str.length());
		
		System.out.println(str);//1彭于晏abcDEF11234吴彦祖xx吴彦祖
		
		//valueOf -- String类的静态方法
		//含义：将其他数据类型转换为String类型
		System.out.println(String.valueOf(100));
		System.out.println(String.valueOf(123.123));
		System.out.println(String.valueOf('a'));
		System.out.println(String.valueOf(true));
		
		//将其他数据类型转换为String类型 的简便方法
		System.out.println(100 + "");
		System.out.println(123.123 + "");
		System.out.println('a' + "");
		System.out.println(true + "");
		
	}
}

2.2StringBuffer类

2.21知识点

StringBuffer代表可变的字符序列（字符串）
StringBuffer称为字符串缓冲区
它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列
StringBuffer是可变对象，这个是String最大的不同

2.2.2继承关系

public abstract class AbstractStringBuilder{
char[] value;
}
public final class StringBuffer extends AbstractStringBuilder{}

package com.qf.string_class;

public class Test02 {

	public static void main(String[] args) {

		//创建StringBuffer的对象，默认创建16个长度的字符数组
		//StringBuffer sb = new StringBuffer();
		
		//创建StringBuffer的对象，自定义字符数组的长度
		//StringBuffer sb = new StringBuffer(100);
	
		//创建StringBuffer的对象，长度为："123abc".length() + 16
		StringBuffer sb = new StringBuffer("123abc");
	
		sb.append("DEF123");//在末尾追加字符串
		sb.insert(3, "xxxyyyzzz");//在指定下标上插入字符串
		sb.setCharAt(4, 'X');//替换指定下标上的字符
		sb.deleteCharAt(4);//删除指定下标上的字符
		sb.delete(3, 11);//删除开始下标处(包含)到结束下标处(不包含)的字符串
		sb.reverse();//反转字符串
		
		System.out.println(sb);//321FEDcba321
		
	}
}

三、StringBuilder类

3.1知识点

StringBuilder代表可变的字符序列（字符串）。
StringBuilder称为字符串缓冲区，
它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。
StringBuilder是可变对象，这个是String最大的不同

3.2继承关系

public abstract class AbstractStringBuilder{
char[] value;
}
public final class StringBuilder extends AbstractStringBuilder{}

package com.qf.string_class;

public class Test03 {

	public static void main(String[] args) {
		
		//创建StringBuilder的对象，默认创建16个长度的字符数组
		//StringBuilder sb = new StringBuilder();
		
		//创建StringBuilder的对象，自定义字符数组的长度
		//StringBuilder sb = new StringBuilder(100);
	
		//创建StringBuilder的对象，长度为："123abc".length() + 16
		StringBuilder sb = new StringBuilder("123abc");
	
		sb.append("DEF123");//在末尾追加字符串
		sb.insert(3, "xxxyyyzzz");//在指定下标上插入字符串
		sb.setCharAt(4, 'X');//替换指定下标上的字符
		sb.deleteCharAt(4);//删除指定下标上的字符
		sb.delete(3, 11);//删除开始下标处(包含)到结束下标处(不包含)的字符串
		sb.reverse();//反转字符串
		
		System.out.println(sb);//321FEDcba321
		
		/**
		 * StringBuffer vs StringBuilder
		 * 
		 * 相同点：这两个类都是继承 AbstractStringBuilder，所有的数据都是存储在父类中的*char[] value里
         *
		 *   StringBuffer：线程安全的（上锁、解锁），多线程的情况下使用
		 *   StringBuilder：线程不安全的（没有上锁、没有解锁），单线程的情况下使用，效率更高
		 */
		 StringBuffer底层源码
		 	class StringBuffer extends AbstractStringBuilder{
		 		//线程安全的方法 -- synchronized
		 	    public synchronized void append(String str){//上锁
					super.appen(str);
		 		}//解锁
		 	}
		 
		 // StringBuilder底层源码
		 	class StringBuilder extends AbstractStringBuilder{
		 		public void append(String str){
		  			super.appen(str);
		  		}
		  	}
	}
}

3.3深入String面试题

package com.qf.string_class;

public class Test04 {

	public static void main(String[] args) {
		
		//以下代码创建几个字符串对象？
		//1个
		String str1 = "abc";
		String str2 = "abc";
		System.out.println(str1 == str2);//true
		
		//以下代码创建几个字符串对象？
		//3个（“abc”、new了两个String）
		String str1 = new String("abc");
		String str2 = new String("abc");
		System.out.println(str1 == str2);//false

		//String底层的字符数组为什么使用final修饰？
		//String是一个不可变的字符串类型，既一个String对象创建成功后，包含在该对象中的字符串是不可变的
		String str = "abc";
		str = "abcd";
		
	}
}

3.3.1注意

常量池里的数据不允许重复

3.4深入String创建对象的问题

package com.qf.string_class;

public class Test05 {

	public static void main(String[] args) {

		String str1 = "abc";
		String str2 = "abc";
		System.out.println(str1 == str2);//true
		
		//两个常量在编译时直接拼接
		String str3 = "ab" + "c";//编译——> String str3 = "abc";
		System.out.println(str1 == str3);//true
		
		//两个常量在编译时直接拼接
		final String s1 = "ab";
		final String s2 = "c";
		String str4 = s1 + s2;//编译--> String str4 = "abc";
		System.out.println(str1 == str4);//true
		
		//两个变量在编译时会创建StringBuilder对象
		String s3 = "ab";
		String s4 = "c";
		String str5 = s3 + s4;//编译--> String str5 = new StringBuilder(s3).append(s4).toString()
		System.out.println(str1 == str5);//false
		
	}
}

3.5深入频繁拼接字符串使用StringBuilder或StringBuffer

package com.qf.string_class;

public class Test06 {

	public static void main(String[] args) {
		
		//慢的原因：循环一遍就newStringBuidler对象
		
		//获取自1970.1.1 0:0:0到现在的毫秒数
		long startTime = System.currentTimeMillis();	
		String str = "张三";
		for (int i = 0; i < 10000; i++) {
			str += "法外狂徒";
			//底层：str = str + "法外狂徒"
			//--> str = new StringBuidler(str).append("法外狂徒").toString();
		}
		long endTime = System.currentTimeMillis();	
		
		System.out.println("运行时常：" + (endTime-startTime));//310
		
		long startTime = System.currentTimeMillis();
		StringBuilder sb = new StringBuilder("张三");
		for (int i = 0; i < 10000; i++) {
			sb.append("法外狂徒");
		}
		long endTime = System.currentTimeMillis();	
		
		System.out.println("运行时常：" + (endTime-startTime));//5
	}
}

四、日期时间类

4.1Date()类

package com.qf.datetime_class;

import java.util.Date;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * Date：日期类
		 * SimpleDateFormat：格式化日期类
		 * Calendar：日历类
		 */
		
		Date date = new Date();
		
		//星期  月份    日期      时:分:秒	时区   年份
		//Sat May 07   15:29:07 CST 2022
		System.out.println(date);
	}
}

4.2SimpleDateFormat：格式化日期类

package com.qf.datetime_class;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点：日期时间类
		 * 
		 * Date：日期类
		 * SimpleDateFormat：格式化日期类
		 * Calendar：日历类
		 */
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		
		String str = sdf.format(new Date());
		
		System.out.println(str);
	}
}

4.3 Calendar：日历类

package com.qf.datetime_class;

import java.util.Calendar;

public class Test03 {

	public static void main(String[] args) {
		/**
		 * 知识点：日期时间类
		 * Calendar：日历类
		 * 
		 * 总结：
		 * 		Date + SimpleDateFormat 联合使用
		 * 		获取单个日期信息-->Calendar
		 */
		
		//获取日历类的对象
		Calendar c = Calendar.getInstance();
		
		int year = c.get(Calendar.YEAR);
		int month = c.get(Calendar.MONTH) + 1;//月份从0开始
		int day = c.get(Calendar.DAY_OF_MONTH);	
		int hour = c.get(Calendar.HOUR);	
		int minute = c.get(Calendar.MINUTE);	
		int second = c.get(Calendar.SECOND);	
		
		System.out.println(year);
		System.out.println(month);
		System.out.println(day);
		System.out.println(hour);
		System.out.println(minute);
		System.out.println(second);
		
	}
}

五、Math - 数学类

5.1知识点

Math 类提供了一序列基本数学运算和几何函数的方法。
Math类是final类，并且它的所有成员变量和成员方法都是静态的。(标准的工具类)

package com.qf.math_class;

public class Test01 {

	public static void main(String[] args) {
		
		System.out.println("求次方：" + Math.pow(3, 2));//9.0
		System.out.println("求平方根：" + Math.sqrt(9));//3.0
		System.out.println("求绝对值：" + Math.abs(-100));//100
		System.out.println("向下取整(地板)：" + Math.floor(1.9));//1.0
		System.out.println("向上取整(天花板)：" + Math.ceil(1.1));//2.0
		System.out.println("四舍五入：" + Math.round(1.4));
		System.out.println("求最大值：" + Math.max(10, 20));
		System.out.println("求最小值：" + Math.min(10, 20));
		System.out.println("求随机值0(包含)~1(不包含)：" + Math.random());
		
		//需求：随机出1~100的数组
		int num = (int)(Math.random()*100)+1;
		System.out.println("随机出1~100的数组：" + num);
	}
}

5.2 Math类面试题

package com.qf.math_class;

public class Test02 {

	public static void main(String[] args) {

		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
		
		//Math.abs可能会返回负数吗？
		System.out.println("求绝对值：" + Math.abs(Integer.MAX_VALUE+1));
		System.out.println("求绝对值：" + Math.abs(Integer.MIN_VALUE));
		
	}
}

5.3 静态导入

5.3.1缺点

//静态导入：将Math类所有的静态属性和方法都导入到本类中，变成本类自己的静态属性和方法

可读性不强

package com.qf.math_class;

import static java.lang.Math.*;

public class Test03 {

	public static void main(String[] args) {

		System.out.println("求次方：" + pow(3, 2));//9.0
		System.out.println("求平方根：" + sqrt(9));//3.0
		
		System.out.println("求绝对值：" + abs(-100));//-1234
	}
	
	public static int abs(int i){
		return -1234;
	}
}

六、正则表达式

6.1含义

用来描述或者匹配一系列符合某个语句规则的字符串

package com.qf.regex_class;

public class Test01 {

	public static void main(String[] args) {

		String str = "小红15111111234 小绿13922221234 张三22222222222";
		
		String regex = "(1\\d{2})(\\d{4})(\\d{4})";
		
		str = str.replaceAll(regex, "$1恭喜发财$3");
		
		System.out.println(str);
	}
}

6.1.1总结

可以依据正则表达式的规则对字符串进行替换

6.2需求

验证字符串是否符合QQ邮箱的规范

package com.qf.regex_class;

public class Test02 {

	public static void main(String[] args) {

		String str = "1445584980@qq.com";
		
		String regex = "\\d{6,11}@qq.com";
		
		boolean bool = str.matches(regex);
		System.out.println(bool);
		
	}
}

6.3分隔路径

package com.qf.regex_class;

public class Test03 {

	public static void main(String[] args) {

		String str = "c:\\资源\\日本\\波多野结衣.avi";
		
		String regex = ":?\\\\";// :\\ 或 \\
		
		String[] ss = str.split(regex);//依据正则表达式分隔字符串
		
		for (String s : ss) {
			System.out.println(s);
		}
		
		
	}
}

6.4找到前端代码中的图片资源

package com.qf.regex_class;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test04 {

	public static void main(String[] args) {
		
		String str = "<img src='hhy/aaa.jpg'/><div><div/> <input type='image' src='submit.gif' /><img src='bbb.jpg'/>";
	
		String regex = "<img\\b[^>]*\\bsrc\\b\\s*=\\s*('|\")?([^'\"\n\r\f>]+(\\.jpg|\\.bmp|\\.eps|\\.gif|\\.mif|\\.miff|\\.png|\\.tif|\\.tiff|\\.svg|\\.wmf|\\.jpe|\\.jpeg|\\.dib|\\.ico|\\.tga|\\.cut|\\.pic)\\b)[^>]*>";
	
		//获取正则表达式的对象
		Pattern pattern = Pattern.compile(regex);
		
		//获取正则表达式的匹配结果
		Matcher matcher = pattern.matcher(str);
		
		//遍历匹配结果
		while(matcher.find()){//判断是否有匹配的数据
			String group = matcher.group(2);//获取匹配结果中的第2组数据
			System.out.println(group);
		}
	}
}

7、总结

1.包装类
   出现原因
   手动装箱、手动拆箱
   自动装箱、自动拆箱
   面试题

2.字符串类
   String的使用
   StringBuffer的使用
   StringBuilder的使用
   StringBuffer vs StringBuilder
   String的面试题

3.正则表达式 -- 了解

4.日期时间类
   Date + SimpleDateFormat
   Calendar

5.Math
   静态导入

Hsu.Y

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java常用类（一）--------14

一、包装类1.1含义Java为每种基本数据类型分别匹配的类1.2出现原因 Java为纯面向对象语言，一切皆对象，8种基本数据类型不能创建对象，就破坏了Java为纯面向对象语言的特征，所以Java为8种基本数据类型都分别匹配了对应的类，这种类我们叫做包装类/封装类1.3包装类基本数据类型包装类继承关系 byte Byte Object.Number.Byte short Short Object.Number...
复制链接

扫一扫