常用类之包装类+字符串+正则表达式Pattern类+Date类+SimpleDateFormat类+Calendar类

怼烎@ 2024-04-09 02:46 52阅读 0赞

## 常用类之包装类+字符串+正则表达式Pattern类+Date类+SimpleDateFormat类+Calendar类 ##

### 一、包装类 ###

#### 含义：Java为纯面向对象语言，8种基本数据类型不能创建对象，破坏了Java为纯面向对象语言的特征，所以Java又为8种基本数据类型分别匹配了对应的类，这种类我们称之为包装类/封装类 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">基本数据类型</th> 
   <th align="center">引用数据类型</th> 
   <th align="center">继承关系</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">byte</td> 
   <td align="center">Byte</td> 
   <td align="center">Object.Number.Byte</td> 
  </tr> 
  <tr> 
   <td align="center">short</td> 
   <td align="center">Short</td> 
   <td align="center">Object.Number.Short</td> 
  </tr> 
  <tr> 
   <td align="center">int</td> 
   <td align="center">Integer</td> 
   <td align="center">Object.Number.Integer</td> 
  </tr> 
  <tr> 
   <td align="center">long</td> 
   <td align="center">Long</td> 
   <td align="center">Object.Number.Long</td> 
  </tr> 
  <tr> 
   <td align="center">float</td> 
   <td align="center">Float</td> 
   <td align="center">Object.Number.Float</td> 
  </tr> 
  <tr> 
   <td align="center">double</td> 
   <td align="center">Double</td> 
   <td align="center">Object.Number.Double</td> 
  </tr> 
  <tr> 
   <td align="center">char</td> 
   <td align="center">Character</td> 
   <td align="center">Object.Character</td> 
  </tr> 
  <tr> 
   <td align="center">boolean</td> 
   <td align="center">Boolean</td> 
   <td align="center">Object.Boolean</td> 
  </tr> 
 </tbody> 
</table>

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		//装箱：基本数据类型 -> 包装类
    //		int i = 100;
    //		Integer integer = Integer.valueOf(i);
    //		System.out.println(integer.toString());
    		
    		//拆箱：包装类 -> 基本数据类型
    //		Integer integer = new Integer(100);
    //		int i = integer.intValue();
    //		System.out.println(i);
    		
    		//JDK1.5版本开始的新特性：自动装箱、自动和拆箱
    		
    		//自动装箱：基本数据类型 -> 包装类
    //		int i = 100;
    //		Integer integer = i;
    //		System.out.println(integer.toString());
    		
    		//自动拆箱：包装类 -> 基本数据类型
    //		Integer integer = new Integer(100);
    //		int i = integer;
    //		System.out.println(i);
    		
    	}
    }

#### 1.包装类面试题 ####

##### 考点：Integer底层缓存数组的区间：-128~127 #####

public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		Integer integer1 = Integer.valueOf(100);
    		Integer integer2 = Integer.valueOf(100);
    		System.out.println(integer1 == integer2);//true
    		
    		Integer integer3 = Integer.valueOf(1000);
    		Integer integer4 = Integer.valueOf(1000);
    		System.out.println(integer3 == integer4);//false
    		
    		System.out.println(integer1.intValue());
    		System.out.println(integer2.intValue());
    		System.out.println(integer3.intValue());
    		System.out.println(integer4.intValue());
    		
    		System.out.println("----------------");
    		
    		MyInteger myInteger1 = MyInteger.valueOf(100);
    		MyInteger myInteger2 = MyInteger.valueOf(100);
    		System.out.println(myInteger1 == myInteger2);//true
    		
    		MyInteger myInteger3 = MyInteger.valueOf(1000);
    		MyInteger myInteger4 = MyInteger.valueOf(1000);
    		System.out.println(myInteger3 == myInteger4);//false
    		
    		System.out.println(myInteger1.intValue());
    		System.out.println(myInteger2.intValue());
    		System.out.println(myInteger3.intValue());
    		System.out.println(myInteger4.intValue());
    	}
    }

//int类型的包装类
    public class MyInteger {
        
    	
    	private int value;
    
    	public MyInteger(int value) {
        
    		this.value = value;
    	}
    	
    	public int intValue(){
        
    		return value;
    	}
    	
    	public static MyInteger valueOf(int i){
        //-128
    		if(i >= MyIntegerCacher.low && i <= MyIntegerCacher.high){
        
    			return MyIntegerCacher.cacher[i + (-MyIntegerCacher.low)];
    		}
    		return new MyInteger(i);
    	}
    	
    	//MyInteger的缓存类
    	private static class MyIntegerCacher{
        
    		
    		public static final int low = -128;
    		public static final int high = 127;
    		public static final MyInteger[] cacher;//缓存数组
    		
    		static{
        
    			//初始化缓存数组
    			cacher = new MyInteger[high - low + 1];
    			int j = low;
    			for (int i = 0; i < cacher.length; i++) {
        
    				cacher[i] = new MyInteger(j++);
    			}
    		}	
    	}
    }

### 二、字符串的类 ###

#### 分类： ####

> #### String StringBuffer StringBuilder ####

#### 1.String的使用 ####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		String str = "123abc";
    		
    		//拼接字符串，并返回一个新的字符串
    		str = str.concat("DEF123");//123abcDEF123
    		
    		//从开始下标处截取到字符串末尾，并返回一个新的字符串
    		str = str.substring(3);//abcDEF123
    		
    		//从开始下标(包含)处截取到结束下标(不包含)处，并返回一个新的字符串
    		str = str.substring(2, 7);//cDEF1
    		
    		//转大写，并返回一个新的字符串
    		str = str.toUpperCase();//CDEF1
    		
    		//转小写，并返回一个新的字符串
    		str = str.toLowerCase();//cdef1
    		
    		
    		str = "  123   abc DEF     123         ";
    		
    		//去掉首尾空格，并返回一个新的字符串
    		str = str.trim();//123   abc DEF     123
    		
    		;//替换字符串第一次出现的子字符串，并返回一个新的字符串
    		str = str.replaceFirst("23", "99");//199   abc DEF     123
    		
    		//替换字符串出现的字符，并返回一个新的字符串
    		str = str.replace('1', '6');//699   abc DEF     623
    		
    		//替换字符串，并返回一个新的字符串
    		str =str.replaceAll("abc", "xxyyzz");//699   xxyyzz DEF     623
    		
    		//去空格
    		str = str.replaceAll(" ","");//699xxyyzzDEF623
    		
    		System.out.println("获取字符串字符的个数：" + str.length());//15
    		System.out.println("判断两个字符串内容是否相同(区分大小写)："  + str.equals("699xxyyzzDEF623"));//true
    		System.out.println("判断两个字符串内容是否相同(不区分大小写)：" + str.equalsIgnoreCase("699xxyyzzDEF623"));//true
    		System.out.println("判断字符串是否以某个字符串开头：" + str.startsWith("69"));//true
    		System.out.println("判断字符串是否以某个字符串结尾：" + str.endsWith("F623"));//true
    		System.out.println("获取子字符串在此字符串中第一次出现的下标：" + str.indexOf("6"));//0
    		System.out.println("获取子字符串在此字符串中最后一次出现的下标：" + str.lastIndexOf("6"));//12
    		System.out.println("获取到指定下标上的字符：" + str.charAt(5));//y
    		
    		System.out.println(str);//699xxyyzzDEF623
    		
    		System.out.println("---------------");
    		
    		//将其他类型转换为字符串
    		System.out.println(String.valueOf(11));//11
    		System.out.println(String.valueOf(1.45));//1.45
    		System.out.println(String.valueOf('c'));//c
    		System.out.println(String.valueOf(true));//true
    		System.out.println(String.valueOf(1.9));//1.9
    		
    		//将其他类型转换为字符串 之 简便方式
    		System.out.println(10 + "");//10
    		System.out.println(1.23 + "");//1.23
    		System.out.println('a' + "");//a
    		System.out.println(true + "");//true
    		System.out.println(1.9 + "");//1.9
    		
    		//总结：String类的方法记不住没关系，只要有印象就可以，忘记了就查API
    	}
    }

#### 2.StringBuffered ####

##### 1.含义：StringBuffer称为字符串缓冲区，StringBuffer代表可变的字符序列。 #####

##### 2.工作原理是： #####

###### 预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。StringBuffer是可变对象，这个是String最大的不同 ######

##### 3.继承关系： #####

###### class StringBuffered extends AbstractStringBuilder\{\} ######

##### 4.扩容机制： #####

###### 数组存满了就扩容，扩容的长度等于 当前数组的长度+要添加的字符串的长度 ######

public class Test02 {
        
    	public static void main(String[] args) {
        
    		
    		//创建StringBuffer的对象，默认缓冲区：16个字符
    		//StringBuffer sb = new StringBuffer();
    		
    		//创建StringBuffer的对象，自定义缓冲区：100个字符
    		//StringBuffer sb = new StringBuffer(100);
    		
    		//创建StringBuffer的对象，自定义缓冲区："123abc".length() + 16 个字符
    		StringBuffer sb = new StringBuffer("123abc");
    		
    		//在末尾追加内容
    		sb.append("DEF123");//123abcDEF123
    		
    		//在指定下标上插入字符串
    		sb.insert(6, "xyz");//123abcxyzDEF123
    		
    		//替换指定下标上的字符
    		sb.setCharAt(7, 'Y');//123abcxYzDEF123
    		
    		//从开始下标(包含)处替换到结束下标(不包含)处的字符串
    		sb.deleteCharAt(7);//123abcxzDEF123
    		
    		//从开始下标(包含)处删除到结束下标(不包含)处的字符串
    		sb.delete(3, 11);//123123
    		
    		//反转字符串
    		sb.reverse();
    		System.out.println(sb);//321321
    	}
    }

#### 3.StringBuilder ####

##### 1.含义：StringBuilder称为字符串缓冲区，StringBuilder代表可变的字符序列。 #####

##### 2.工作原理是： #####

###### 预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。StringBuilder是可变对象，这个是String最大的不同 ######

##### 3.继承关系： #####

###### class StringBuilder extends AbstractStringBuilder\{\} ######

public class Test03 {
        
    	public static void main(String[] args) {
        
    		
    		//创建StringBuilder的对象，默认缓冲区：16个字符
    		//StringBuilder sb = new StringBuilder();
    		
    		//创建StringBuilder的对象，自定义缓冲区：100个字符
    		//StringBuilder sb = new StringBuilder(100);
    		
    		//创建StringBuilder的对象，自定义缓冲区："123abc".length() + 16 个字符
    		StringBuilder sb = new StringBuilder("123abc");
    		
    		//在末尾追加内容
    		sb.append("DEF123");//123abcDEF123
    		
    		//在指定下标上插入字符串
    		sb.insert(6, "xyz");//123abcxyzDEF123
    		
    		//替换指定下标上的字符
    		sb.setCharAt(7, 'Y');//123abcxYzDEF123
    		
    		//从开始下标(包含)处替换到结束下标(不包含)处的字符串
    		sb.deleteCharAt(7);//123abcxzDEF123
    		
    		//从开始下标(包含)处删除到结束下标(不包含)处的字符串
    		sb.delete(3, 11);//123123
    		
    		//反转字符串
    		sb.reverse();
    		System.out.println(sb);//321321
    	}
    }

#### 4.String面试题 ####

##### 考点：字面值常量存储在常量池中，并且常量池中的字符串不允许重复 #####

public class Test04 {
        
    	
    	public static void main(String[] args) {
        
    		
    		//下列代码创建了多少个String对象
    		//答案：创建了1个String对象
        	//String str1 = "abc";//"abc"存储在常量池中，"abc"就是一个String对象
    		//String str2 = "abc";//系统会去查找常量池中是否有"abc"，如果有，就把地址赋值给str2
    		//System.out.println(str1 == str2);//true
    		
    		//下列代码创建了多少个String对象
    		//答案：创建了3个String对象（"abc"、new了两个）
    		String str1 = new String("abc");
    		String str2 = new String("abc");
    		System.out.println(str1 == str2);//false
    	}
    }

#### 5.String创建对象的问题 ####

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";//编译成class文件时"ab"+"c"-> "abc"
    		System.out.println(str1 == str3);//true
    		
    		//两个常量直接拼接
    		final String s1 = "ab";
    		final String s2 = "c";
    		String str4 = s1 + s2;
    		System.out.println(str1 == str4);//true
    		
    		//有变量拼接时，底层会创建StringBuilder对象
    		String s3 ="ab";
    		String s4 = "c";
    		//String str5 = (new StringBuilder(String.valueOf(s3))).append(s4).toString();
    		String str5 = s3 + s4;
    		System.out.println(str1 == str5);//false
    	}
    }

#### 6.频繁的字符串拼接考虑使用StringBuilder或StringBuffered ####

public class Test06 {
        
    
    	public static void main(String[] args) {
        
    		
    		//实验一：计算出下列代码的运行时常
    		
    	//	long startTime = System.currentTimeMillis();//获取自1970.1.1 0:0:0到现在的毫秒数
    	//	String str = "貂蝉";
    	//	for (int i = 0; i <10000; i++) {
        
    	//		str +="小可爱，皇冠给你带~~";
    	//	}
    		//底层实现：
    		//str = str + "小可爱，皇冠给你带~~";
    		//str = (new StringBuider(String.valueOf(str))).append("小可爱，皇冠给你带~~").toString();
    	//	long endTime = System.currentTimeMillis();
    	//	System.out.println("消耗时间：" + (endTime-startTime));//551
    		
    		//实验二：计算出下列代码的运行时常
    		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));//1
    		
    	}
    }

### 三、正则表达式 ###

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

#### 小结：利用正则表达式替换数据 ####

#### 1.需求：替换字符串中的电话 ####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		String str = "小明13911122245 小花15122337841";
    		String regex = "(1\\d{2})(\\d{4})(\\d{4})";
    		
    		str = str.replaceAll(regex, "$1****$3");
    		System.out.println(str);
    	}
    }

#### 2.需求：验证QQ邮箱 ####

public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		String email = "148963214@qq.com";
    		String regex = "\\d{6,11}@qq.com";
    		
    		boolean matches = email.matches(regex);
    		System.out.println(matches);//true
    	}
    }

#### 3.需求：分隔路径 ####

public class Test03 {
        
    
    	public static void main(String[] args) {
        
    		String str = "C:\\资料\\学校\\马可波罗.avi";
    		String regex = ":?\\\\";// :\\ 或 \\
    		
    		String[] split = str.split(regex);
    		for (String string : split) {
        
    			System.out.println(string);
    		}
    	}
    }

#### 4.需求：获取前端代码中的图片资源 ####

public class Test04 {
        
    
    	public static void main(String[] args) {
        
    		
    		String str = "<img src='ooo/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);
    			System.out.println(group);		
    		}
    	}
    }

### 四、Date类 ###

#### Date（java.util.Date）：日期类 ####

import java.util.Date;
    public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		Date date = new Date();
    		
    		//星期  月份   日期 时:分:秒	     时区   年份
    		//Tue Oct 11 17:08:45 CST 2022
    		System.out.println(date);
    	}
    }

### 五、SimpleDateFormat：格式化日期类 ###

import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    public class Test02 {
        
    
    	public static void main(String[] args) throws ParseException {
        
    		
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    		
    		//将Date对象格式化成字符串
    		String format = sdf.format(new Date());
    		System.out.println(format);//2022年10月11日 17:16:08
    		
    		//将符合格式化的字符串解析成Date对象
    		Date date = sdf.parse("2022年10月11日 16:67:26");
    		System.out.println(date);//Tue Oct 11 17:07:26 CST 2022
    	}
    }

### 六、 Calendar：日历类 ###

import java.util.Calendar;
    public class Test03 {
        
    
    	public static void main(String[] args) {
        
    		Calendar calendar = Calendar.getInstance();
    		
    
    		int year = calendar.get(Calendar.YEAR);
    		int month = calendar.get(Calendar.MONTH)+ 1;
    		int day = calendar.get(Calendar.DAY_OF_MONTH);
    		int hour = calendar.get(Calendar.HOUR);
    		int minute = calendar.get(Calendar.MINUTE);
    		int second = calendar.get(Calendar.SECOND);
    		
    		System.out.println(year);//2022
    		System.out.println(month);//10
    		System.out.println(day);//11
    		System.out.println(hour);//5
    		System.out.println(minute);//24
    		System.out.println(second);//34
    	}
    }