Java的常用类（包装类，String类，StringBuffer 类 和 StringBuilder 类，日期时间类，Math类，Random类，System类，Runtime类，大数类）

Java常用的类：

包装类：

包装类：8种基本数据类型对应类

 

出现原因：
       Java为纯面向对象语言(万物皆对象)，8种基本数据类型不能new对象，就破坏Java为纯面向对应语言的特征，Java又为8种基本数据类型分别匹配了对应的类，这种类叫做包装类/封装类。

基本数据类型	包装类	继承关系
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

tips:
        1. int的包装类的写法为Integer, char的包装类的写法是：Character
        2.其余基本数据类型的包装类均是基本类型的首字母大写。

​  
 

装箱和拆箱：

装箱：基本数据类型 -----> 包装类

拆箱：包装类 -----> 基本数据类型

	//手动装箱：基本数据类型 -> 包装类
    int num = 100;
    Integer integer = Integer.valueOf(num);
    System.out.println(integer);	
	
	
	//手动拆箱：包装类 -> 基本数据类型
	Integer integer = new Integer(100);
	int num = integer.intValue();
	System.out.println(num);
	
	
	
	//JDK1.5开始的新特性：自动拆装箱
	
	//自动装箱：基本数据类型 -> 包装类
	int num = 100;
	Integer integer = num;//底层实现：Integer.valueOf(num);
	System.out.println(integer);
	
	//自动拆箱：包装类 -> 基本数据类型
	Integer integer = new Integer(100);
	int num = integer;//底层实现：integer.intValue();
	System.out.println(num);
	
	
	
	//将字符串转换为int值
	String str = "123";
	int num = Integer.parseInt(str);//解析
	System.out.println(num);

 

 

深入包装类：

面试题：描述下列代码的运行结果
		Integer integer1 = Integer.valueOf(100);
		Integer integer2 = Integer.valueOf(100);
		System.out.println(integer1 == integer2);//true，因为Integer包装类里面有一个缓存数组cache保存（-128~+127）之间的数。
		
		Integer integer3 = Integer.valueOf(200);
		Integer integer4 = Integer.valueOf(200);
		System.out.println(integer3 == integer4);//false

面试题：描述Integer的valueOf底层实现原理
	答：判断输入的int值是否在-128~127的区间内，如果在就从Integer的缓存类的缓存数组中获取对象，如果不在，就重新new Integer的对象。

//Integer包装类的底层原理：
package com.qf.package_class;

public class MyInteger {

	private int value;

	public MyInteger(int value) {
		this.value = value;
	}
	
	
	public int intValue(){
		return value;
	}
	
	
	public static MyInteger valueOf(int i){
		if(i>=MyIntegerCache.low && i<=MyIntegerCache.high){
			
			return MyIntegerCache.cache[i -MyIntegerCache.low];//偏移量为128
		}
		return new MyInteger(i);
	}
	
	@Override
	public String toString() {
		
		return String.valueOf(value);//valueOf：将int值转换为字符串
	}
	
	//缓存类
	private static class MyIntegerCache{
		
		private static final int low = -128;//低位
		private static final int high = 127;//高位
		private static final MyInteger[] cache;//缓存数组（-128~127的MyInteger的对象）
		
		
		
		static{//静态块
			//初始化缓存数组
			cache = new MyInteger[high - low + 1];//256
			int j = low;
			
			for (int i = 0; i < cache.length; i++) {
				cache[i] = new MyInteger(j++);
			}
		}
		
	}
}

 
 

String类

String类

String:

​ String 是不可变类, 即一旦一个 String 对象被创建, 包含在这个对象中的字符序列是不可改变的, 直至该对象被销毁。

tips:

​ 1. String 类是 final 类，不能有子类。

​ 2. String类为不可变类，是final类，其引用指代的对象地址是不能改变的，但是对象中的内容是可以改变的

 

String类的常用方法：

方法	具体介绍
String concat(String str)	在原有字符串的尾部添加参数字符串，返回一个新的字符串（总是堆内存中的对象）,如果 str 的长度为 0，则返回原字符串。str 不能为空。
String subString(int beginIndex)	获得从 beginIndex 开始到结束的子字符串。（ 包括 beginIndex 位置的字符）
String toLowerCase()	把字符串中的英文字符全部转换为小写字符，返回值为装换后的新的字符串。
String toUpperCase()	把字符串中的英文字符全部转换为大写字符，返回值为装换后的新的字符串
String trim()	把字符串中的首尾空白字符去掉
String replace(CharSequence target, CharSequence replacement)	使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串
String replace(char oldChar, char newChar)	返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replaceAll(String regex, String replacement)	使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
replaceFirst(String regex, String replacement)	使用给定的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
int length()	返回字符串字符的个数。
boolean equals(Object anObject)	将此字符串与指定的对象比较。注意此时比较的是内容是否相等(字符串类对此方法进行了覆写)。
boolean equalsIgnoreCase(String anotherString)	将此 String 与另一个 String比较，不考虑大小写。
int compareTo(String value)	按字典顺序比较两个字符串。如果两个字符串相等，则返回 0；如果字符串在参数值之前，则返回值小于 0；如果字符串在参数值之后，则返回值大于 0
int compareToIgnoreCase(String val)	按字典顺序比较两个字符串，不考虑大小写
boolean startsWith(String value)	检查一个字符串是否以参数字符串开始。
boolean endsWith(String value)	检查一个字符串是否以参数个字符串结束。
int indexOf(int ch)	返回指定字符ch在此字符串中第一次出现处的索引值；如果未出现该字符，则返回-1。
int indexOf ( String str)	返回第一次出现的指定字符串str在此字符串中的索引值；如果未出现该字符串，则返回-1。
int lastIndexOf(int ch)	返回最后一次出现的指定字符在此字符串中的索引值；如果未出现该字符，则返回-1。
int lastIndexOf(String str)	返回最后一次出现的指定字符串str在此字符串中的索引值；如果未出现该字符串，则返回-1。
char charAt(int index)	从指定索引 index 处提取单个字符，索引中的值必须为非负。
String valueOf( Object obj)	可以将基本类型数据、Object 类型转换为字符串。

 

常用方法的使用：

public static void main(String[] args) {
		
		String str = "123abc";//底层：new char[]{'1','2','3','a','b','c'};
    
		//拼接字符串，并返回新的字符串
		str = str.concat("DEF123");//123abcDEF123
    
    	//从开始下标处截取到末尾，并返回新的字符串
		str = str.substring(2);//3abcDEF123
    
    	//从开始下标处(包含)截取到结束下标处(排他)，并返回新的字符串
		str = str.substring(1, 7);//abcDEF
    
		//转大写，并返回新的字符串
		str = str.toUpperCase();//ABCDEF
    
    	//转小写，并返回新的字符串
		str = str.toLowerCase();//abcdef
		
		str = "   123  abc DEF   123         ";
		
    	//去除首尾空格，并返回新的字符串
		str = str.trim();//123  abc DEF   123
    
    	//替换字符，并返回新的字符串
		str = str.replace('a', 'A');//123  Abc DEF   123
    
    	//替换字符串，并返回新的字符串
		str = str.replace("Abc", "ABC");//123  ABC DEF   123
    
    	//替换字符串，并返回新的字符串
		str = str.replaceAll("ABC", "abc");//123  abc DEF   123
    
    	//替换第一次出现的字符串，并返回新的字符串
		str = str.replaceFirst("23", "66");//166  abc DEF   123
    
    	//去除空格（将空格字符串替换成空内容的字符串）
		str = str.replaceAll(" ", "");//166abcDEF123
		
    	//获取字符串的字符个数
		int len = str.length();//12
		
		
		//判断两个字符串内容是否相同（区分大小写）
    	str.equals("166abcDEF123"));//true
    
		//判断两个字符串内容是否相同（不区分大小写）
    	str.equalsIgnoreCase("166ABCdef123"));//true
    
    
		//判断字符串是否以某个字符串开头
    	str.startsWith("166a"));//true
    
    
		//判断字符串是否以某个字符串结尾
    	str.endsWith("DEF123"));//true
		
		//查找子字符串在此字符串第一次出现的下标
    	str.indexOf("1"));//0
    
		//查找子字符串在此字符串最后一次出现的下标
    	str.lastIndexOf("1"));//9
    
		//获取字符串中指定下标的字符
    	str.charAt(6));//D
		
		
		
		System.out.println("-------------------------");
		
		//把其他类型转换为String类型
		System.out.println(String.valueOf(10));//int -> String
		System.out.println(String.valueOf(11.11));//double -> String
		System.out.println(String.valueOf(true));//boolean -> String
		System.out.println(String.valueOf('A'));//char -> String
		
		System.out.println("-------------------------");
		
		//把其他类型转换为String类型
		System.out.println(10 + "");//int -> String
		System.out.println(11.11 + "");//double -> String
		System.out.println(true + "");//boolean -> String
		System.out.println('A' + "");//char -> String
		
		System.out.println("-------------------------");
}
		

 

String类的一个练习题

/**
		 * String练习题：
		 		练习：完成一个邮箱格式的校验 OYO@qq.com
				（1），“@”不能在第一位
				（2），“.”不能在最后一位
				（3），“@”和“.”中间应该有字符
				（4），***@***.***
		 */
		
		 String email = "OYO@qq.com";
		 
		 int indexOf1 = email.indexOf("@");
		 int indexOf2 = email.indexOf(".");
		 
		 if(indexOf1==0 || indexOf2==email.length()-1 || indexOf2-indexOf1<=1){
			 System.out.println("邮箱格式错误");
		 }else{
			 System.out.println("邮箱格式正确");
		 }
	}

 
 

深入了解String类

String类的常量池

常量池：

​ Java 运行时会维护一个常量池， 常量池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。

//面试题：描述下列代码会创建几个String对象？
	//答案：1个（常量池中的数据不允许重复）
		String str1 = "abc";
		String str2 = "abc";
		System.out.println(str1);
		System.out.println(str2);

//面试题：描述下列代码会创建几个String对象？
	//答案：3个（new了两个String对象 + "abc"[常量池中]）
		String str1 = new String("abc");
		String str2 = new String("abc");
		System.out.println(str1);
		System.out.println(str2);

 

String类的创建对象：

public static void main(String[] args) {
		
		String str1 = "abc";
		String str2 = "abc";
    	//常量池中的数据不允许重复，故只有一个对象，内存地址一样的
		System.out.println(str1 == str2);//true
		
		//注意：两个常量在编译时直接拼接
    	//"ab"和"c"是字面值常量（常量只在编译时起作用，编译成.class文件，就没有常量了）
		String str3 = "ab" + "c";//String str3 = "abc";
		System.out.println(str1 == str3);//true
		
		//注意：两个常量在编译时直接拼接
    	//s1和s2是final修饰的常量
		final String s1 = "ab";
		final String s2 = "c";
		String str4 = s1 + s2;//String str3 = "abc";
		System.out.println(str1 == str4);
		
		//注意：有变量参与字符串拼接的情况，底层会创建StringBuilder进行拼接
		String s3 = "ab";
		String s4 = "c";
		String str5 =s3+s4;
                       //把S3转换为String类型  末尾追加  转换为String类型的字符串
    //new StringBuilder(String.valueOf(s3)).append(s4).toString();
		System.out.println(str1 == str5);//false
	}

 
 

switch如何判断String类型：

底层原理:

​ 就是先判断hash值，然后再判断两个字符串内容是否相同(equals)。

//研究String的hash值是如何算出来的
String str = "abc";

public class String{
    
    final char[] value;//['a','b','c']
    
    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            
            char[] val = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }
    
}

//原代码
public static void main(String[] args) {
		
		
		switch ("abc") {
		case "abc":
			System.out.println("abc");
			break;
		case "def":
			System.out.println("def");
			break;
		case "zyx":
			System.out.println("xyz");
			break;
		}


	}





//反编译的代码
public class Test04{

	public static void main(String args[]){
		String s;
		switch ((s = "abc").hashCode()){//96354
	
		case 96354://"abc".hashCode();
                
			if (s.equals("abc"))
				System.out.println("abc");
			break;

		case 99333: //"def".hashCode();
                
			if (s.equals("def"))
				System.out.println("def");
			break;

		case 121113: //"zyx".hashCode();
			if (s.equals("zyx"))
				System.out.println("xyz");
			break;
		}
	}
}

//原代码
public static void main(String[] args) {
		
		
		System.out.println("Aa".hashCode());
		System.out.println("BB".hashCode());
		
		switch ("Aa") {
		case "BB":
			System.out.println("BB");
			break;
		case "Aa":
			System.out.println("Aa");
			break;
		case "zyx":
			System.out.println("xyz");
			break;
		}


	}



//反编译的代码
public class Test05{

	public static void main(String args[]){
		
		String s;
		switch ((s = "Aa").hashCode()){//2112
	
		case 2112: //"BB".hashCode() -- "Aa".hashCode()
                
			if (!s.equals("BB")){
				if (s.equals("Aa"))
					System.out.println("Aa");
			} else{
				System.out.println("BB");
			}
			break;

		case 121113: 
			if (s.equals("zyx"))
				System.out.println("xyz");
			break;
		}
	}
}

 
 
 

StringBuffer 类 和 StringBuilder 类

StringBuilder/StringBuffer代表可变的字符序列，StringBuilder/StringBuffer称为字符串缓冲区。
 
它的工作原理是：
       预先申请一块内存(char[] value = new char[])，存放字符序列， 如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列(扩容机制：原来数组长度的两倍+2)。
 
StringBuilder/StringBuffer是可变对象：因为char[] value = new char[];

String是不可变的对象，因为final char[] value = new char[];

/*
关于：
StringBuilder/StringBuffer是可变对象：因为char[] value = new char[];
String是不可变的对象，因为final char[] value = new char[];
*/


		//底层有两个字符串：“abc”,"abcd"（在常量池中）
		String str = "abc";
		str = "abcd";
		
		
		//底层只有一个缓存数组
		StringBuilder sb = new StringBuilder();
		sb.append("abc");
		sb.append("d");
		

 

StringBuffer类的常用方法：

方法	具体介绍
StringBuffer append(String str)	将指定的字符串追加到子字符序列
StringBuffer insert(int offset,String str)	将字符串str插入此字符序列指定位置中
void setCharAt(int pos,char ch)	使用ch指定的新值设置pos指定位置上的字符
StringBuffer replace(int start,int end,String s)	此方法使用一组字符替换另一种字符。将用替换字符串从start指定的位置开始替换，直到end指定的位置结束。(下标为排他)
StringBuffer deleteCharAt(int pos)	此方法将删除pos指定的索引处的字符
StringBuffer delete(int start,int end)	此方法将删除调用对象中从start位置开始直到end指定的索引-1位置的字符序列（下标为排他）
StringBuffer reverse()	反转字符串
int length()	确定 StringBuffer 对象的长度
String toString()	转换为字符串形式

 

常用方法的使用：

public static void main(String[] args) {
		
		StringBuffer sb = new StringBuffer();
		
    	//在末尾追加字符串
		sb.append("123abc");//123abc
		sb.append("DEF123");//123abcDEF123
		
    	//将子字符串插入到此字符串指定下标的位置
		sb.insert(6, "xyz");//123abcxyzDEF123
    
    	//替换指定下标上的字符
		sb.setCharAt(6, 'X');//123abcXyzDEF123
    
    	//从开始下标处（包含）替换到结束下标处（排他）的字符串
		sb.replace(3, 9, "ABCABC");//123ABCABCDEF123
		
    	//删除指定下标上的字符
		sb.deleteCharAt(6);//123ABCBCDEF123
    
    	//从开始下标处（包含）删除到结束下标处（排他）的字符串
		sb.delete(3, 11);//123123
		
    	//反转字符串
		sb.reverse();//321321
		
    	//字符串长度
		int len = sb.length();
		
		
		
		System.out.println(sb.toString());
	}

 

StringBuilder 类的常用方法：

StringBuilder 类的常用方法和StringBuffer类的一样。

方法	具体介绍
StringBuilder append(String str)	将指定的字符串追加到子字符序列
StringBuilder insert(int offset,String str)	将字符串str插入此字符序列指定位置中
void setCharAt(int pos,char ch)	使用ch指定的新值设置pos指定位置上的字符
StringBuilder replace(int start,int end,String s)	此方法使用一组字符替换另一种字符。将用替换字符串从start指定的位置开始替换，直到end指定的位置结束。(下标为排他)
StringBuilder deleteCharAt(int pos)	此方法将删除pos指定的索引处的字符
StringBuilder delete(int start,int end)	此方法将删除调用对象中从start位置开始直到end指定的索引-1位置的字符序列（下标为排他）
StringBuilder reverse()	反转字符串
int length()	确定 StringBuilder 对象的长度
String toString()	转换为字符串形式

 

常用方法的使用：

public static void main(String[] args) {
		
		StringBuilder  sb = new StringBuilder ();
		
    	//在末尾追加字符串
		sb.append("123abc");//123abc
		sb.append("DEF123");//123abcDEF123
		
    	//将子字符串插入到此字符串指定下标的位置
		sb.insert(6, "xyz");//123abcxyzDEF123
    
    	//替换指定下标上的字符
		sb.setCharAt(6, 'X');//123abcXyzDEF123
    
    	//从开始下标处（包含）替换到结束下标处（排他）的字符串
		sb.replace(3, 9, "ABCABC");//123ABCABCDEF123
		
    	//删除指定下标上的字符
		sb.deleteCharAt(6);//123ABCBCDEF123
    
    	//从开始下标处（包含）删除到结束下标处（排他）的字符串
		sb.delete(3, 11);//123123
		
    	//反转字符串
		sb.reverse();//321321
		
    	//字符串长度
		int len = sb.length();
		
		
		
		System.out.println(sb.toString());
	}

 

 
 

StringBuffer 类和 StringBuilder 类的底层：

tips:

​ 1. StringBuffer和StringBuilder都是继承的AbstractStringBuilder

​ 2. StringBuffer和StringBuilder的核心功能都是由父类使用

​ 3. StringBuffer在方法中上锁、解锁 -----在多线程下使用

​ 4. StringBuffer和StringBuilder相比，因为有了上锁和解锁的步骤，所以效率没有StringBuilder高

//它们的父类

import java.util.Arrays;

abstract class MyAbstractStringBuilder {

	//缓存数组
	char[] value;
	
	//存储字符个数
	int count;
	
	MyAbstractStringBuilder() {
    }

	MyAbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
	
	//获取字符个数
    public int length() {
        return count;
    }
    
    public MyAbstractStringBuilder append(String str) {
    	
    	//如果添加的字符串为null
        if (str == null)
            return appendNull();
        
        
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }
    
    //添加字符串为null的情况
    private MyAbstractStringBuilder appendNull() {
        int c = count;
        
        //判断是否扩容的方法
        ensureCapacityInternal(c + 4);//4 - "null".length()
        
        final char[] value = this.value;
        value[c++] = 'n';
        value[c++] = 'u';
        value[c++] = 'l';
        value[c++] = 'l';
        count = c;
        return this;
    }
    
    //判断是否扩容
    private void ensureCapacityInternal(int minimumCapacity) {
        // 有溢出意识的代码（容量必须大于缓存数组的长度才扩容）
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,newCapacity(minimumCapacity));
        }
    }
    
    //计算新的长度
    private int newCapacity(int minCapacity) {
        // 扩容机制：原来的长度*2 + 2
        int newCapacity = (value.length << 1) + 2;//为什么+2的原因：怕用户设置初始化数组长度为0，0<<1还是0，就得不到扩容
        return newCapacity;
    }
    
}

 

StringBuffer 类的底层：

public class MyStringBuffered extends MyAbstractStringBuilder{

	public MyStringBuffered() {
        super(16);//默认缓冲数组长度为16
    }
	
	public MyStringBuffered(int capacity) {
        super(capacity);//自定义缓冲数组的长度
    }
	
	public MyStringBuffered(String str) {
        super(str.length() + 16);//自定义缓冲数组的长度：字符串长度+16
        append(str);//追加字符串
    }
	
	//synchronized - 线程安全的方法
	@Override
    public synchronized  MyStringBuffered append(String str) {//上锁
        super.append(str);//依赖于父类的append
        return this;
    }//解锁
}

 

StringBuilder 类的底层：

public class MyStringBuilder extends MyAbstractStringBuilder{

	public MyStringBuilder() {
        super(16);//默认缓冲数组长度为16
    }
	
	public MyStringBuilder(int capacity) {
        super(capacity);//自定义缓冲数组的长度
    }
	
	public MyStringBuilder(String str) {
        super(str.length() + 16);//自定义缓冲数组的长度：字符串长度+16
        append(str);//追加字符串
    }
	
	@Override
    public MyStringBuilder append(String str) {
        super.append(str);//依赖于父类的append
        return this;
    }
}

 

StringBuilder 和 StringBuffer的构造方法:

public static void main(String[] args) {
		
		//缓冲区默认长度：16个字符
		//StringBuffer sb = new StringBuffer();

		//自定义缓冲长度：100个字符
		//StringBuffer sb = new StringBuffer(100);
		
		//自定义缓冲长度："abc".length() + 16
//		StringBuffer sb = new StringBuffer("abc");
//		System.out.println(sb);
		
		System.out.println("-------------");
		
		//缓冲区默认长度：16个字符
		//StringBuilder sb = new StringBuilder();

		//自定义缓冲长度：100个字符
		//StringBuilder sb = new StringBuilder(100);
		
		//自定义缓冲长度："abc".length() + 16
//		StringBuilder sb = new StringBuilder("abc");
//		System.out.println(sb);
}

 

频繁拼接字符串优化方案：

频繁拼接字符串，使用StringBuilder/StringBuffer。

public static void main(String[] args) {
		
		//获取自1970年1月1日0:0:0 到现在的毫秒数（1000毫秒 = 1秒）
		//long currentTimeMillis = System.currentTimeMillis();
		
//		long startTime = System.currentTimeMillis();
//		String str = "OYO";
//		for (int i = 1; i < 50000; i++) {
//			str += "小可爱，皇冠给你带";
			//底层实现：
			//	str = str + "小可爱，皇冠给你带";
			//	str = new StringBuidler(str).append("小可爱，皇冠给你带");
    		//循环多少次就创建多少次的StringBuidler对象。
//		}
//		long endTime = System.currentTimeMillis();
//		System.out.println("消耗时长：" + (endTime-startTime));//6640
		
		System.out.println("--------------------------------------------");
		
//		long startTime = System.currentTimeMillis();
//创建一次StringBuffer对象，在循环过程中拼接字符串，StringBuffer对象的vlue数组需要不断扩容。
//		StringBuffer sb = new StringBuffer("OYO");
//		for (int i = 1; i < 50000; i++) {
//			sb.append("小可爱，皇冠给你带");
//		}
//		long endTime = System.currentTimeMillis();
//		System.out.println("消耗时长：" + (endTime-startTime));//5
		
		System.out.println("--------------------------------------------");
		
		long startTime = System.currentTimeMillis();
    //优化方案：减少底层扩容次数，直接设置大的数组容量，减少扩容次数
		StringBuffer sb = new StringBuffer(450060);
		sb.append("OYO");
		for (int i = 1; i < 50000; i++) {
			sb.append("小可爱，皇冠给你带");
		}
		long endTime = System.currentTimeMillis();
		System.out.println("消耗时长：" + (endTime-startTime));//5
	}

 
 

正则表达式：

正则表达式：符合某个语句规范的字符串。

//案例：把一个字符串中带电话号码替换成130****1111（利用正则表达式做替换）
	
	 
	
	public static void main(String[] args) {
		
		String str = "小红13012341111 小绿15112342222 小黑13912343333";
		
		String regex = "(1\\d{2})(\\d{4})(\\d{4})";
		
		str = str.replaceAll(regex, "$1****$3");//$n保留第几组正则表达式里的数据
		System.out.println(str);
		
	}

//案例：校验QQ邮箱 （利用正则表达式做验证）
	 
	public static void main(String[] args) {
		
		String email = "1234567890@qq.com";
		
		String regex = "\\d{4,11}@qq.com";//数字4到11位
		
		boolean matches = email.matches(regex);
		System.out.println(matches);
		
	}

//分隔路径（利用正则表达式做字符串的分割）

	public static void main(String[] args) {
		
		String str = "C:\\资源\\工具\\Java";
		
		//:?表示冒号出现1次或0次
		String regex = ":?\\\\";//分割  :\\ 或 \\
		
		String[] split = str.split(regex);
		for (String string : split) {
			System.out.println(string);
		}
		
	}

//案例：Pattern+Matcher 找到前端代码中的图片路径（利用正则表达式做字符串的爬数据的工作）


	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)\\b)[^>]*>";
		
		//获取正则表达式对象（对象中有上面的正则表达式）
		Pattern pattern = Pattern.compile(regex);
		//获取匹配结果
		Matcher matcher = pattern.matcher(str);
		
		//循环遍历匹配结果
		while(matcher.find()){
			//获取匹配结果
			String group = matcher.group(2);
            //2表示第2组数据，上面的正则表达式的一个小括号为一组
			System.out.println(group);
		}
		
	}

 

 

日期时间类：

tips:

​        1. Date + SimpleDateFormat一起使用，获取我们想要的日期时间格式。

​        2. 获取单个日历信息，考虑使用Calendar。

 

Date 类：日期类

Date 类在java.util包下

public static void main(String[] args) {
		
		Date date = new Date();
		
		//星期 月份 日期 时:分:秒 时区 年份
		//Sat Jan  27  14:31:41  CST 2024
		System.out.println(date);
	}

 

SimpleDateFormat 类：格式化日期类

public static void main(String[] args) throws ParseException {
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
		//格式化日期
		//Date 转 String
		String datetime = sdf.format(new Date());
		System.out.println(datetime);
		
		//String 转 Date 
		Date date = sdf.parse("2024年01月27日 14时37分1秒");
		System.out.println(date);
	}

 

Calendar 类：日历类

public static void main(String[] args) {
		
		//获取当前系统的日历对象
		Calendar c = Calendar.getInstance();
	
		int year = c.get(Calendar.YEAR);
		int month = c.get(Calendar.MONTH)+1;//注意：月份0~11，0表示1月，所以加个1
		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类：

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

常用方法：

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.max(10, 20));//20
		System.out.println("求最小值：" + Math.min(10, 20));//10
		System.out.println("向下取整（地板）：" + Math.floor(1.9));//1.0
		System.out.println("向上取整（天花板）：" + Math.ceil(1.1));//2.0
		System.out.println("四舍五入：" + Math.round(1.5));//2
		System.out.println("获取随机值：" + Math.random());//注意：随机出0~1的数字，0包含，1排他
		
	

 

深入math类的相关方法：

//需求：随机出1~100的数字
	int num = (int)(Math.random()*100)+1;
	System.out.println("获取随机值：" + num);
}

public static void main(String[] args) {
		
		//获取int类型的最大值 -> 2147483647 -- 2的31次方-1
		System.out.println(Integer.MAX_VALUE);
		//获取int类型的最小值 -> -2147483648 - -2的31次方
		System.out.println(Integer.MIN_VALUE);
		
		//面试题：Math.abs会出现负数吗？
		//会出现负数 --> -2147483648
		System.out.println(Math.abs(-2147483648));
	}

 
 

静态导入：

静态导入：

​        将类中所有的静态属性和方法都导入到本类来，作为本来自己的静态属性和方法。

 

缺点：

​        如果类中的方法和静态导入类中的方法重名了，会调用本类自己的静态方法，所以可读性差，不建议使用。
​

//静态导入
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
	}
	
	public static int sqrt(int i){
		return 123456;
	}
}

 
 

Random类：随机类

public static void main(String[] args) {
		
		Random ran = new Random();
		
		System.out.println("随机出int取值范围里的数值：" + ran.nextInt());
		System.out.println("随机出0~9的int数值：" + ran.nextInt(10));
		System.out.println("随机出double取值范围里的数值：" + ran.nextDouble());
		System.out.println("随机出boolean取值范围里的数值：" + ran.nextBoolean());
	}

 

深入Random类：

​ seed叫做种子数，种子数一旦固定随机出的数字就是固定的。

简版MyRandom:

public class MyRandom {
	
	//种子数
	private long seed;
	
	public MyRandom() {
		
		this(seedUniquifier() ^ System.nanoTime());
		
	}
	
    //相对随机的一个数
	private static long seedUniquifier() {
        for (;;) {
            long current = System.currentTimeMillis();
            long next = current * 181783497276652981L;
            if (next%3==0 || next%12==0 || next%17==0){
                return next;
            }
        }
    }

	public MyRandom(long seed) {
		this.seed = seed;
	}
	
	public int nextInt(){
		return (int) seed;
	}
	
	public int nextInt(int bound){
		return Math.abs((int) seed)%bound;
	}
}

 

 

System类：

1. System类提供了一些静态属性和方法，允许通过类名直接调用。

2. System类提供了代表标准输入、标准输出、错误输出的类属性。

3. System类提供了一些静态方法用于访问环境变量、系统属性的方法。

 

System类的属性：

err :“标准”错误输出流。

out :“标准”输出流。

in :“标准”输入流。

public static void main(String[] args) {
		
		//获取系统标准的输入流 - 方向：控制台->程序
		InputStream in = System.in;
		
		Scanner scan = new Scanner(in);
		System.out.println("请输入int值：");
		int num = scan.nextInt();
		
		//获取系统标准的输出流 - 方向：程序 -> 控制台
//		PrintStream out = System.out;
//		out.println(num);
		
		//获取系统标准的错误输出流 - 方向：程序 -> 控制台
		PrintStream err = System.err;
		err.println(num);
		
		scan.close();
	}

 

System类的方法：

​ 1. public static void exit(int status) 退出当前虚拟机
 
​ 2. public static long currentTimeMillis() 获得当前系统的毫秒值(与1970 年 1 月 1 日午夜之间的时间差)–测试程序的消耗时间
 
​ 3. public static Properties getProperties() 获得当前的所有系统属性
 
​ 4. public static String getProperty(String key) 获得指定键的系统属性
 
​ 5. public static void setIn(InputStream in) 输入重定向
 
​ 6. public static void setOut(PrintStream out) 输出重定向
 
​ 7. public static void setErr(PrintStream err) 错误重定向
 
​ 8. public static void arraycopy(Object src,int srcPos, Object dest, int destPos, int length) 拷贝数组

public static void main(String[] args) {
		
		long currentTimeMillis = System.currentTimeMillis();
		System.out.println("获取自1970年1月1日到现在的毫秒数：" + currentTimeMillis);
		
		//获取系统参数
		Properties properties = System.getProperties();
		System.out.println(properties);
		
		//通过具体Key获取对应的Value
		String property = System.getProperty("os.name");
		System.out.println("通过具体Key获取对应的Value：" + property);
		
		//拷贝数组
		int[] arr = {1,2,3,4,5,6,7,8,9,10};
		int[] newArr = new int[4];
		System.arraycopy(arr, 3, newArr, 0, 4);//(源数组，开始下标，目标数组，开始下标，拷贝长度)
		for (int num : newArr) {
			System.out.println(num);
		}
		
		//利用System.arraycopy做数组的删除功能
		String[] names = {"aaa","bbb","ccc","ddd","eee","fff",null,null,null};	
		System.arraycopy(names, 2, names, 1, 4);
		names[5] = null;
		for (String str : names) {
			System.out.println(str);
		}
		
		//退出当前虚拟机，0表示正常退出
		System.exit(0);
	}

 
 

Runtime类:

Runtime表示运行时系统(JVM)。

public static void main(String[] args) {
		
		//获取运行时系统对象
		Runtime run = Runtime.getRuntime();
		
		System.out.println("获取最大操作数：" + run.availableProcessors());//8
		System.out.println("获取最大内存数(byte)：" + run.maxMemory());
		System.out.println("获取闲置内存数(byte)：" + run.freeMemory());
		
	}

 
 

判断效率：程序的效率（时间、内存）

//程序的效率（时间、内存）

	public static void main(String[] args) {
		
//		Runtime run = Runtime.getRuntime();
//		long startTime = System.currentTimeMillis();
//		long startMemory = run.freeMemory();
//		String str = "OYO";
//		for (int i = 1; i < 50000; i++) {
//			str += "小可爱，皇冠给你带";
//		}
//		long endMemory = run.freeMemory();
//		long endTime = System.currentTimeMillis();
//		System.out.println("消耗时长：" + (endTime-startTime));//6640
//		System.out.println("消耗内存：" + (startMemory-endMemory));
		
		System.out.println("--------------------------------------------");
		
//		Runtime run = Runtime.getRuntime();
//		long startTime = System.currentTimeMillis();
//		long startMemory = run.freeMemory();
//		StringBuffer sb = new StringBuffer("OYO");
//		for (int i = 1; i < 50000; i++) {
//			sb.append("小可爱，皇冠给你带");
//		}
//		long endMemory = run.freeMemory();
//		long endTime = System.currentTimeMillis();
//		System.out.println("消耗时长：" + (endTime-startTime));//5
//		System.out.println("消耗内存：" + (startMemory-endMemory));//2293808
		
		System.out.println("--------------------------------------------");
		
		Runtime run = Runtime.getRuntime();
		long startTime = System.currentTimeMillis();
		long startMemory = run.freeMemory();
		StringBuffer sb = new StringBuffer(450060);//优化方案：减少底层扩容次数
		sb.append("OYO");
		for (int i = 1; i < 50000; i++) {
			sb.append("小可爱，皇冠给你带");
		}
		long endMemory = run.freeMemory();
		long endTime = System.currentTimeMillis();
		System.out.println("消耗时长：" + (endTime-startTime));//5
		System.out.println("消耗内存：" + (startMemory-endMemory));//900136
	}

 
 

大数类：

BigInteger类：整数大数值运算类

public static void main(String[] args) {
		
		BigInteger big1 = new BigInteger("2100000000");
		BigInteger big2 = new BigInteger("2100000000");
		
		BigInteger add = big1.add(big2);
		System.out.println("加法：" + add);
		
		BigInteger subtract = big1.subtract(big2);
		System.out.println("减法：" + subtract);
		
		BigInteger multiply = big1.multiply(big2);
		System.out.println("乘法：" + multiply);
		
		BigInteger divide = big1.divide(big2);
		System.out.println("除法：" + divide);
	}

 

BigDecemal类：小数大数值运算类

tips:

1. 小数做运算会失去精度，所以小数做运算都要生成大数值的运算类。
2. 构造方法里的值使用字符串。

public static void main(String[] args) {
		
		BigDecimal big1 = new BigDecimal("0.5");
		BigDecimal big2 = new BigDecimal("0.4");
		
		BigDecimal add = big1.add(big2);
		System.out.println("加法：" + add);
		
		BigDecimal subtract = big1.subtract(big2);
		System.out.println("减法：" + subtract);
		
		BigDecimal multiply = big1.multiply(big2);
		System.out.println("乘法：" + multiply);
		
	
	}

//除法
public static void main(String[] args) {
		
		BigDecimal big1 = new BigDecimal("10");
		BigDecimal big2 = new BigDecimal("3");
		//                                保留几位小数       四舍五入
  		BigDecimal divide = big1.divide(big2, 3, BigDecimal.ROUND_HALF_UP);
		System.out.println("除法：" + divide);
	}