常用类之Object,Scanner,String,Integer,Character,Math,Random,Calendar,Date,System,BigDecimal的基本方法和实践

Object – 超类

getclass() – 表示当前正在运行的类

public final Class getClass():表示当前正在运行的类 
		返回值类型为class
Class类中有一个:getName():
 		public String getName():以字符串展示字节码文件对象所表示实体
 		
 获取一个类的字节码文件对象有几种方式?
 三种:
 	1) Object类中的getclass()方法  ----> class 包名.类名
 	2) java类型的clas属性   .class ----> class 包名.类名
 	3) Class类中的 forName() 方法  ----> class 包名.类名

// 代码实现举例: 
public class Test {
    public static void main(String[] args) {
        Class c1=null;
        try {
            c1=Class.forName("java.lang.String");//第一种
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        String s="abc";
        Class c2 = s.getClass();//第二种
        Class c3=String.class;//第三种
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
    }
}

clone() – 克隆方法: 创建对象并返回此对象的一个副本

protected Object clone() throws CloneNotSupportedException
	克隆方法: 创建对象并返回此对象的一个副本
	Object类中的clone()方法执行特定的复制操作
		如果此类的对象不能实现接口Cloneable,则会抛出 CloneNotSupportedException

/*
	代码实现: 对学生对象进行clone操作
*/
public class CloneTest {
	public static void main(String[] args) throws CloneNotSupportedException{
	//抛出异常(throws:表示抛出的一种可能性:这个程序可能出问题,如果有问题,jvm就会将异常信息打印在控制台上!)
	//创建一个学生对象
	//有参构造赋值
	  Student s = new Student("sss",50);
	  System.out.println(s.getName()+", "+s.getAge());
	//使用clone()之前
	  Student s2 = s;
	  System.out.println(s2.getName()+", "+s2.getAge());
	/*
	  使用clone()方法 
	  Student类实现了 Cloneable接口 重写了clone方法()
	  public class Student implements Cloneable{}
	  在Student类中重写clone()方法
	  需要在main方法中抛出异常
	  public static void main(String[] args) throws CloneNotSupportedException
	*/
	  Object obj = s.clone();
	  Student s3 = (Student) obj;
	  System.out.println(s3.getName()+", "+s3.getAge());
		
	}
	//学生类
	// 实现Cloneable接口
public class Student implements Cloneable{
	private String name ;
	private int age;
	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 Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	//重写clone() 方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}
}
*/

toString() – 返回该对象的字符串表示

public String toString()
  		返回该对象的字符串表示(以一个文本格式体现出来的简明易于读懂的信息表达式)
子类不重写Object类中的toString(),返回值为地址值
子类重写Object类中的toString(),返回的是内容

hashCode() – 返回该对象的哈希码值

//   代码实践: 
//定义学生类
public class Student {
}
public class Test {
	public static void main(String[] args) {
		//创建一个学生对象:
		Student s1 = new Student() ;
		System.out.println(s1); // 包名.类名@十六进制数据  bao2.Student@4d95d2a2
		System.out.println(s1.hashCode());//305808283 
		System.out.println("hello".hashCode());//99162322
		System.out.println("world".hashCode());//113318802
		System.out.println("中国".hashCode());//642672
	}
}

equals() – 表示其他对象当前obj对象是否 “相等”

public boolean equals(Object obj):表示其他对象当前obj对象是否 "相等"
面试题:
  	==和equals的区别?
  	
    ==:	连接如果是基本数据类型(类型一致),表示数据值是否相同
       	连接如果是两个引用数据类型(类型一致),比较的是两个对象的地址值是否相同
    equals: 默认比较的是地址值是否相同,但通常子类中会重写equals方法和hashCode()方法
    	当这两个方法被重写时,比较的是两个对象的内容是否相同

// 代码实现
// 定义学生类 name,age属性 提供有参/无参构造方法,get/set方法,重写hashCode和equals方法 
public class Student{
    ...
}
public class Test{
    public static void main(String[] args){
        Student s1 = new Student("亚索",12) ;
		Student s2 = new Student("亚索",12) ;
        //s1和s2:他们的成员信息是一直,是可以认为同一个人
		System.out.println(s1==s2); //false
        //重写了Object的equals()/hashCode()方法之后
		System.out.println(s1.equals(s2));//true
    }
} 

分析重写的hashCode()方法和equals()方法
    @Override
	public int hashCode() {  
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) { // s2    相当于:Object obj  = new Student() ;
		if (this == obj) // 判断如果 s1==s2
			return true;
		if (obj == null) //传递进来对象是否为null
			return false; 
		if (getClass() != obj.getClass())  //this.getClass !=s2.getClass() :比较两个对象的字节码文件不相同的
			return false;
		Student other = (Student) obj;  //向下转型子类的引用:  具体Student
		if (age != other.age)     //this.age  != s2.age
			return false; 
		if (name == null) {   //当前(s1)this.name 如果是null
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name)) // name--->String   比较两个对象姓名的内容是否相同
											//String类:里面重写了Object类中equals
			return false;
		return true;  //返回的结果:两个对象内容相同
	}

Scanner – 文本扫描器

java.util.Scanner

构造方法
public Scanner(InputStream source)
	形式参数:
		抽象类:java.io.InputStream:字节输入流(用来读取字节数)
	如果方法的形式参数是一个抽象类,那么需要传递该抽象类的子类对象	
	public static final InputStream in:成员变量 :标准输入流 
	public static final PrintStream out:标准输出流


Scanner类中提供了一些判断功能:
public boolean hasNextXXX():判断当前是否是执行XXX类型  int,short,float,double...
	public boolean	haxNextInt() :判断接收的类型是否是int类型
public XXX nextXXX() :接收指定XXX类型  
	public int nextInt()  : 接收指定的int类型的数据
	
Scanenr:键盘录入的细节问题:
	
先录入int类型,在录入String类型 (nextLine()) 出现问题: 回车符号本身就是字符串,会漏值
  	解决方案: 在下一次录入String类型前,再次创建一个Scanner类型对象
  	为了方便使用--> 全部使用String类型接收

String 字符串类

String 类代表字符串,Java 程序中的所有字符串字面值（如 `"abc"` ）都作为此类的实例实现。
	字符串是常量；它们的值在创建之后不能更改(常量的地址值)
String类是一个特殊的引用类型
	String类型如果作为参数传递,形式参的改变不会影响实际参数
数组中有没有length()方法,String类型有没有length()方法,集合中有没有length()?
 				数组中:length属性
 				String类型中有length方法():获取字符串长度
				集合中:size()	

面试题:以下s1和s2实际含义

 String s1 = "hello" ;     //常量赋值
 String s2 = new String("hello") ;//堆内存中申请空间
 前者:创建的是一个对象   
 	将常量赋值的形式:直接在方法区中的常量池中 先查看是否存在常量"hello",如果存在"hello",将地址值赋值给它,如果不存在,在常量池中开辟空间!
后者:创建两个对象
   	new String():堆内存
  	"hello":常量池中

/*   == 和 equals ? 
public boolean equals(String otherString) 
 在String类型中:equals:比较是字符串的内容是否相同(底层已经重写了Object的equals方法)
*/   
     
public class StringTest {
	public static void main(String[] args) {	
		String s1 = new String("hello") ;
		String s2 = new String("hello") ;
		System.out.println(s1==s2);//false --- 地址值
		System.out.println(s1.equals(s2)); //true --- 内容
		System.out.println("-------------------------");
		String s3 = new String("hello");
		String s4 = "hello";
		System.out.println(s3==s4); //false --- 地址值
		System.out.println(s3.equals(s4)); //true  --- 内容
		System.out.println("-------------------------");
		String s5 = "hello";
		String s6 = "hello" ;
		System.out.println(s5==s6); //true  --- 地址值
		System.out.println(s5.equals(s6));//true --- 内容
        System.out.println("------------------------------");
 	 // 变量相加,先去开空间,再然后在相加,==(比较的地址值是否相同)
        String ss1 = "hello" ;
		String ss2 = "world" ;
		String ss3 = "helloworld" ;
		System.out.println((ss1+ss2)==ss3);//false ---地址值
		System.out.println((ss1+ss2).equals(ss3));//true ---内容
		System.out.println("------------------------------");
     // 常量相加:先相加,然后常量池看是否存在这个值,如果存在直接返回地址,如果不存在开辟空间
		System.out.println(ss3 == "hello"+"world");//true  ---地址值
		System.out.println(ss3.equals("hello"+"world"));//true  --- 内容
	}
}     
 

String类型的功能

String类型的判断功能

public boolean equals(Object anObject):比较两个字符串内容是否相同
public boolean equalsIgnoreCase(String anotherString):不区分大小写比较
public boolean startsWith(String prefix):判断是否以指定的子串开头
public boolean endsWith(String suffix):判断是否以指定的子串结尾
public boolean isEmpty():判断字符串是否为空

String类型的获取功能

int length():获取字符串长度
public char charAt(int index):获取指定索引处的字符
public String concat(String str):字符串拼接功能:使用当前字符串和指定str字符串进行拼接
public int indexOf(int ch):获取指定字符在此字符串中第一次出现索引值
public int indexOf(String str):获取指定字符串在此字符串中第一次出现索引值

String类的分割功能

public String[] split(String regex):通过指定的字符串进行分割,返回值字符串数组

String类转换功能

public char[] toCharArray():将字符串转换成字符数组
public byte[] getBytes() :将字符串----变成字节数组 (过程:编码)
public static String valueOf(XXX xx):可以将任何类型的数据转换成String
		举例:
	int i = 100 ;---->int  --- String
	String.valueOf(i) ;---->"100"
public String toUpperCase():将此字符串转换成大写
public String toLowerCase():将此字符串转换成小写

String类的截取功能

public String substring(int beginIndex):从指定位置开始截取,默认截取到末尾
public String substring(int beginIndex,int endIndex)
从指定位置开始截取,到指定位置结束,从beginIndex  到 endIndex-1 处

/*
	举例: 录入 "Helloworldjavaee"
	 输出结果:"hELLOWORLDJAVAEE"
	将字符串中的第一个字符转换成大写,后面的字符转换成小写(String类转换功能
	toUperCase()/toLowerCase()以及截取功能substring())
*/
public class Test{
	public static void main(String[] args) {
		String s = "Helloworldjavaee";
/*
    public String substring(int beginIndex,int endIndex)返回一个新字符串，
    它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，
    直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex
*/
		String s1 = s.substring(0,1);
		//public String substring(int beginIndex)返回一个新的字符串，
		//它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。
		String s2 = s.substring(1);
		String s3 = s1.toLowerCase();//将此字符串转换成小写
		String s4 = s2.toUpperCase();	//将此字符串转换成大写
		String result = s2.concat(s4);//使用concat拼接字符串
		System.out.println(result);

	}
}

String类的替换功能

public String replace(char oldChar,char newChar):将以前的字符用心的字符替换掉
public String replace(String oldStr,char newStr):将以前的字符用心的字符替换掉
public String trim()去除两端空格

compareTo – 按照字段顺序比较

public int compareTo(String anotherString)  
 		按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。
		String s1 = "abc";
		String s2 = "hello" ;
		//没有相同的字符, 'a' - 'h' = 97- 104 = -7
		int num = s1.compareTo(s2) ; 
		System.out.println("num:"+num); // -7  
		
		String s1 = "hello" ;
		String s2 = "hel" ;
		int num = s1.compareTo(s2) ; //有相同的字符,为 5-3
		System.out.println("num:"+num); //2 

String的拼接功能

public String concat(String str)
	将指定字符串连接到此字符串的结尾。 
	如果参数字符串的长度为 0，则返回此 String 对象。否则，创建一个新的 String 对象，用来表示由此 String 对象表示的字符序列和参数字符串表示的字符序列连接而成的字符序列。

StringBuffer:线程安全的可变字符序列<---->StringBuilder:线程不安全的可变的字符序列

public String(StringBuffer buffer)
	分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。该字符串缓冲区的内容已被复制，后续对它的修改不会影响新创建的字符串

public String(StringBuilder builder)
	分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。该字符串生成器的内容已被复制，后续对它的修改不会影响新创建的字符串。 
	提供此构造方法是为了简化到 StringBuilder 的迁移。通过 toString 方法从字符串生成器中获取字符串可能运行的更快，因此通常作为首选。 

StringBuffer的功能

StringBuffer两个获取功能
		int length():获取长度(缓冲区中字符数)
		public int capacity():获取缓冲区的容量大小
StringBuffer的构造方法:
    1)public StringBuffer():空参构造,初始容量为 16 个字符。
    2)public StringBuffer(String str):
        构造一个缓冲区,指定字符串内容到缓冲区中,容量大小等于16个+当前字符串的实际长度
    3)public StringBuffer(int capacity):指定容量大小,构造一个缓冲区	
StringBuffer的添加功能:
	public StringBuffer append(任何类型数据...):
		将任何类型的数据追加到缓冲区中(追加末尾)
	public StringBuffer insert(int offset,String str/任何类型数据):
		将某个元素插入到指定位置
StringBuffer的反转功能: 
	public StringBuffer reverse():将缓冲区中的字符进行反转!
StringBuffer的删除功能
    public StringBuffer deleteCharAt(int index):
        删除指定位置处的字符,返回缓冲区本身	
    public StringBuffer delete(int start,int end):
        删除从指定位置到指定位置结束(包前不包后,end-1位置)
StringBuffer的截取功能
 	public String substring(int start):从指定位置开始截取,默认截取到末尾
  	public String substring(int start, int end):从指定位置开始截取,截取到指定位置结束!
StringBuffer的替换功能
  public StringBuffer replace(int start,int end, String str)
 		从指定位置开始到指定位置结束(end-1处)使用str子串进行替换

代码实践-----StringBuffer <----->String (类型转换)

	//String---->StringBuffer
		String s = "world" ;
	//方式1:通过StringBuffer构造方法:StringBuffer(String str)
		StringBuffer sb = new StringBuffer(s) ;
	//方式2:StringBuffer()无参构造+append(String str):追加
		StringBuffer sb2 = new StringBuffer() ;
		sb2.append(s) ;


	//StringBuffer----->String
		StringBuffer buffer = new StringBuffer("hello") ;
	//方式1 通过public String(StringBuffer buffer):String类型的构造方法
		String str = new String(buffer) ;
	//方式2: StringBuffer的方法--->public String toString() 
		String str2 = buffer.toString() ;

代码实践-----StringBuffer的反转功能 reverse()

//StringBuffer的反转功能: 
	// 需求: 将字符串 "olleh" 进行逆序输出  结果为: "hello"
	//public StringBuffer reverse():将缓冲区中的字符进行反转!	
	public static void main(String[] args) {
		String s = "olleh";
		//String---->StringBuffer
		StringBuffer sb = new StringBuffer(s) ;
		//就可以使用StringBuffer反转功能
		sb.reverse() ;
		//StringBuffer--->String
		String result = sb.toString() ;
		System.out.println(result);
	}

代码实践-----StringBuffer的添加功能append()

 /* 需求:
  * 		已知数组:int[] arr = {11,22,33,44,55} ;
  * 将数组拼接字符串 "[元素1, 元素2, 元素3, ....]"
  */
public class Test {
	
	public static void main(String[] args) {
		//已知数组:
		int[] arr = {11,22,33,44,55} ;
		String result = arrayToString(arr);
		System.out.println(result);
	}
	//使用StringBuffer的append追加
	public static String arrayToString(int[] arr) {
		//创建一个StringBuffer对象
		StringBuffer sb = new StringBuffer() ;
		sb.append("[") ;
		//遍历数组
		for (int i = 0; i < arr.length; i++) {
			if(i==arr.length-1) {
				sb.append(arr[i]).append("]") ;
			}else {
				sb.append(arr[i]).append(", ") ;
			}
		}
		return sb.toString() ;
	}
}

StringBuffer,StringBuilder和数组的区别

前两个都是字符串缓冲区,都支持可变的字符序列,有相同的api
	前者:它是一个线程安全的,-----同步的----->执行效率低(线程安全的类)
	后者:它是一个线程不安全的---不同步的---->执行效率高
		单线程程序---->考虑效率问题---->StringBuilder会将StringBuffer了替换掉!
		多线程程序--->最重要的安全问题---->StringBuffer了

两者和数组的区别:
	共同点: 
		都容器,都可以存储数据的!
	字符串缓冲区:
		存储数据最终以"字符序列"存储的(StringBuffer/StringBuilder)
		长度可变,可以不断追加:append(xxx)
		字符串遍历:length()+charAt(int index)
	数组:只能存储同一种类的元素
		长度是固定的,(也是数组的弊端)
		数组的遍历:length属性:获取数组长度

String,StringBuffer和StringBuilder三者之间的区别

 String类型和StringBuffer类型的区别:
	共同点:两者都是引用类型数据
	不同点:
        String: 作为参数进行传递时,形式参数的改变不会影响实际参数
        	String类作为形式参数,它的效果基本数据类型一样(String是最特殊的引用类型)
        	String是一个常量,一旦被赋值,其值不能被改变 
        StringBuffer:作为形式参数传递时,形式参数的改变会影响实际参数(和其他引用类型效果一样)
StringBuffer和StringBuilder类型的区别:
    共同点:两者是互相兼容的,功能相同(添加,构造方法,替换,删除,截取..)--可变的字符序列
    不同点: 
        StringBuffer 从线程角度看: 线程安全的-->同步的-->执行效率低
        StringBuilder 从线程角度: 不安全-->不同步-->执行效率高

Integer

Integer类的构造方法及常用方法

Integer类在对象中包装了一个基本类型 int的值。
Integer类型的对象包含一个int类型的字段。 
	此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。 

构造方法:
	public Integer(int value)构造一个新分配的 Integer 对象，它表示指定的 int 值。 
	public Integer(String s) throws NumberFormatException
		构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
	注意事项:
		String是一个数字字符串,否则出现异常!
成员变量(字段)
  	public static final int MIN_VALUE:最小值
  	public static final int MAX_VALUE:最大值
方法:
	public static String toBinaryString(int i)
		以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
	public static String toOctalString(int i)
		以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。	
	public static String toHexString(int i)
		以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
	public static String toString(int i)
		返回一个表示指定整数的 String 对象。
	public String toString()
		返回一个表示该 Integer 值的 String 对象。
		覆盖/重写：类 Object 中的 toString

int 类型 <----> String 类型转换-----代码实践

/*
 * String----->int	:Inerget.parseInt(String str)
 * String----->long :Long.parseLong(String str)
 * String----->double:Double.parseDouble(String str)
 * ...

 * int------>String: Integer.toString(int i)
 int-------> Integer        
  注意事项:  Integer中存在缓存区[-128,127]之间,如果在范围内直接赋值
  		如果不在范围内,直接重新堆内存中开辟空间
 * */
public class Test {

	public static void main(String[] args) {
		
		//有一个int类型变量
		int i = 100 ;
		//方式1:空串拼接
		String s = "" +i ;
		System.out.println(s);
		System.out.println("-----------------------");
        
		//方式2:int---->Integer	构造方法Integer(int value)
        // 注意事项:  Integer中存在缓存区[-128,127]之间,如果在范围内直接赋值
        //			如果不在范围内,直接重新堆内存中开辟空间
		Integer ii = new Integer(i) ;
		//Integer----->String 	/public String toString()
		String s1 = ii.toString() ;
		System.out.println(s1);
		System.out.println("----------------------");
        
		//方式3静态功能:public static String toString(int i)
		String s2 = Integer.toString(i) ;
		System.out.println(s2);
		
		
		System.out.println("--------------------------");
		
		//String----->int:通用方法
		String str = "50" ;//数字字符串
		//方式1:public static int parseInt(String s)
		int number = Integer.parseInt(str) ;
		System.out.println(number);
		System.out.println("----------------------");
		
		//方式2:public static Integer valueOf(String s):将String--->Integer
		Integer number2 = Integer.valueOf(str) ;
		//将Integer----int	public int intValue();
		int number3 = number2.intValue() ;
		System.out.println(number3);	
	}
}

Character

Character的构造方法以及常用方法

charCharacter 类在对象中包装一个基本类型 char 的值。
	Character 类型的对象包含类型为 char 的单个字段。 
	此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。 
构造方法
	public Character(char value)
	构造一个新分配的 Character 对象，用以表示指定的 char 值。 
判断功能:
    public static boolean isDigit(char ch):判断当前字符是否是数字字符
    public static boolean isLowerCase(char ch):判断当前字符是否是小写字母字符
    public static boolean isUpperCase(char ch):判断当前字符是否是大写字母字符

Character缓存区的问题

面试题
Integer i = 128 ;
Integer i2 = 128 ;
   i==i2 结果是什么.为什么
   false, 将常量直接赋值给Integer类型的变量:执行Integer.valueOf(i)
		判断i的值是否在IntegerCache(内部类中)的缓存区 low= -128  high = 127范围之内,
		在范围内,直接从缓存区中取数据;如果超出了范围,它会执行new Integer(i),地址值不一样,就是false

Character的判断功能的实战应用----代码实现

import java.util.Scanner;
/*
 * 键盘录入字符串,统计字符串中大写字母字符,小写字母字符,数字字符的个数(不考虑其他字符)
 *使用Character类的判断功能
 * */
public class Test {
	public static void main(String[] args) {
		//统计变量
		int a = 0 ;//大写
		int b = 0 ;//小写
		int c = 0 ;//数字
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		//提示并录入数据
		System.out.println("请输入字符串:");
		String line  = sc.nextLine() ;
		//将字符串内容:直接遍历
		for (int i = 0; i < line.length(); i++) {
			//将每一个字符串里面字符获取到
			char ch = line.charAt(i) ;
			//使用Character类的判断功能
			if(Character.isUpperCase(ch)) {
				a ++ ;
			}else if(Character.isLowerCase(ch)) {
				b++;
			}else if(Character.isDigit(ch)) {
				c++;
			}
		}
		System.out.println("大写字母字符有:"+a+"个");
		System.out.println("小写字母字符有:"+b+"个");
		System.out.println("数字字符有:"+c+"个");
	}
}

Math

Math类的常用方法

Math 类包含用于执行基本数学运算的方法，
public static final double PI
	比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。 
public static final double E
	比任何其他值都更接近 e（即自然对数的底数）的 double 值。 	
public static XXX abs(XXX a)
	返回XXX类型的绝对值
public static double pow(double a,double b)
	返回第一个参数的第二个参数次幂的值。
public static double sqrt(double a)
	返回正确舍入的 double 值的正平方根。

Random

Random类的常用方法

java.util.Random:随机数生成器

构造方法
    public Random() :(推荐),产生的随机数是变化的
    public Random(long seed):每次产生的随机数 是固定的!

成员方法:
    public int nextInt():获取的是int范围内的随机数
    public int nextInt(int n):获取0到n之间的随机数[0,n)

获取随机数两种方式:
    Math类的random()方法: 返回值double类型
    Random类空参构造+nextInt(int n):获取随机数

Calendar

Calendar类的常用方法

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法
Calendar不能直接实例化!	
    某一个类如果不能直接实例化:
    首先里面会存在一些静态功能,静态功能的返回值就是该类本身!
    public static Calendar getInstance()
    public int get(int field):获取的日历字段的值!
    参数:传递日历字段
    public abstract void add(int field,int amount)
    日历对象.add(Calendar.DATE,-5):当前日历时间的5天前
    设置当前年月日,日历时间
    public final void set(int year,int month, int date)

Calendar的案例实现 – 代码实践

package com.qianfeng.calendar_02;

import java.util.Calendar;
import java.util.Scanner;
/*
 * 键盘录入年份,求出年份的2月份有多少天!
 * 	Calendar对象.set(year,2,1) ;
 				---->实际应该当前年份的3月1日 (month:从0-11)
 * 给月中某一天设置偏移量
 * 		add(Calendar.DATE,-1)
 * 
 * 输出:Calendar对象.get(Calendar.DATE);
 * */
public class Test {	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in) ;
		System.out.println("请您输入年份值:");
		int year = sc.nextInt() ;
		//创建日历类对象
		Calendar c = Calendar.getInstance() ;
		//设置日历时间
		c.set(year, 2,1); //实际应该3月1日  month+1
		//再次设置对DATE字段(月中某一天)设置偏移量
		c.add(Calendar.DATE, -1); //算出:2月份的最后一天(得到具体的天数) 3月1日-1天
		System.out.println("当前年份有:"+c.get(Calendar.DATE)+"天");
	}
}

Date

Date类的常用方法

java.util.Date类		特定的瞬间，精确到毫秒。
 构造方法:
	public Date() 无参构造

成员方法:
	public long getTime() :返回1970 年 1 月 1 日所表示的时间毫秒	
java.util.Date 应用场景  
	String:文本格式  和Date格式的相互转换
	Date  --->  String
	java.text.DateFormat:可以将日期和文本相互转换
	DateFormat继承自Format类:都是抽象类,不能直接实例化!
		java.text.SimpleDateFormat extends DateFormat
	它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）
	SimpleDateFormat的构造方法
		public SimpleDateFormat(String pattern)
		创建一个SimpleDateFormat对象:
		参数:指定一个模式 要遵循一定的规则(jdk对它规定了)
   		y年	------2020		"yyyy"
    	M年中月份----10/03   "MM"
  		d月中的天数----05/21  'dd'
  		h:表示上午/下午的小时数  hh
  		H:一天中的小时数		  HH
  		m:分钟数				  mm
  		s:秒数				  ss
  	模式"yyyy-MM-dd HH:mm:ss"  --->   "yyyy年MM月dd日 HH时mm分ss秒" 
  		

String文本格式 和Date日期格式相互转换

/*
Date---->String
  格式化的步骤:
  1)存在Date对象
  2)创建SimpleDateFormat(String pattern)
  3)public final String format(Date date):格式化方法
   
   
String----->Date 
  步骤:
  1)存在String  "日期文本"   "2020-10-21"
  2)创建SimpleDateFormat(String pattern)
  3)public Date parse(String source)  throws ParseException
  
  注意事项
  	SimpleDateFormat中的参数模式:必须和String 日期文本格式一致,
  		否则出现解析异常(ParseException)
*/
public static void main(String[] args) throws ParseException {
    	//  Date---->String
		//1)创建一个日期对象
		Date date = new Date() ;
		//2)创建SimpleDateFormat:格式化的桥梁
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;//年-月-日
		//3)格式化操作
		String dateStr = sdf.format(date) ;
		System.out.println(dateStr);
		
		System.out.println("------------------------");
		//String----->Date 
		//日期文本
		String source = "2022-6-30 20:00:30" ;
		//创建SimpleDateFormat对象	必须和String 日期文本格式一致
		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
		//解析:抛出一个异常
		Date d = sdf2.parse(source) ;
		System.out.println(d);//Thu Jun 30 20:00:30 CST 2022
	}

String文本格式 和Date日期格式相互转换–工具类

package com.qianfeng.date_04;

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

/*
 * 定义一个工具类,将格式化和解析封装起来
 * 构造方法私有化,目的:外界不能直接创建对象
 * 提供一些静态功能
 * 		格式化
 * 		解析
 * */
public class DateUtils {
	private DateUtils() {	
	}
	/**
	 * 这个方法是将Date日期格式转换成日期文本格式
	 * @param date  当前日期对象
	 * @param pattern 指定模式 yyyy-MM-dd(年月日)
	 * @return 返回的结果表示是当前日期文本
	 */
	public static String date2String(Date date,String pattern) {
		//分步走
		//创建SipleDateFormat对象
		/*
		SimpleDateFormat sdf = new SimpleDateFormat(pattern) ;
		//格式化
		String dateStr = sdf.format(date) ;
		return dateStr ;
		*/
		return new SimpleDateFormat(pattern).format(date) ;
	}
	/**
	 * 这个方法是将日期文本转换成日期格式
	 * @param source  已知存在的日期文本
	 * @param pattern  指定模式 yyyy-MM-dd(年月日)
	 * @return 返回的结果是日期格式Date
	 * @throws ParseException 
	 */
	public static Date string2Date(String source,String pattern) 
										throws ParseException {
		//创建SimpleDateFormat对象
		/*
		SimpleDateFormat sdf = new SimpleDateFormat(pattern) ;
		Date date = sdf.parse(source) ;
		return date ;
		*/
		return new SimpleDateFormat(pattern).parse(source) ;
	}
}

String文本格式 和Date日期格式相互转换案例实践— 代码实现

// 1.键盘录入出生的年月日，算一下你来到这个世界多少天? （提示：Date日期和String文本转换）
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
	public class Test1 {
	public static void main(String[] args) throws ParseException {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入出生日期-- 格式为 2020-1-1: ");
		String s = sc.nextLine();
		//使用方法stringDate将String文本类型转换为Date日期类型
		Date d = stringDate(s, "yyyy-MM-dd");
		//获取输入的日期和1970年1月1日之间所产生的毫秒
		long time = d.getTime();
		//获取当前日期和1970年1月1日之间所产生的毫秒
		long now = new Date().getTime();
		//计算差值
		long day = now - time ;
		//通过毫秒计算出天数
		System.out.println(day/1000/3600/24);
	}
	//String类型转换为Date类型
	public static Date stringDate(String s,String pattern) 
        								throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		Date d =sdf.parse(s);
		return d;
	}
}		

System

System类的常用方法

System 类包含一些有用的类字段和方法。它不能被实例化。
字段:
    public static final InputStream in  :标准的"输入流"
    public static final PrintStream out :标准的"输出流"

键盘录入:	
	Scanner(InputStream in) ---->Scanner(System.in)

输出语句:
	System.out.println("xxx")----->System.out--->PrintStream ps (字节打印流)
	ps.println("x") : 字节打印流调用方法名println(String str)

成员方法:
	public static void gc() 运行垃圾回收器(手动开启)
	实际开发中,开发者不需要开启
	运行垃圾回收器,它会调用Obejct类finalize(),回收没有更多引用的对象

public static void exit(int status):参数状态为0时	表示正常终止jvm
public static long currentTimeMillis():获取当前系统时间的毫秒值

在System中手动开启垃圾回收器 – 重写finalize

//定义一个类, 
public class Person {
	String name ;
	int age ;
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	//重写Object类中finalize()方法
	@Override
	protected void finalize() throws Throwable {
		System.out.println("垃圾回收器将回收这个对象"+this);
		super.finalize();
	}	
}
public class Test {
	public static void main(String[] args) {
		//public static void gc() 运行垃圾回收器(手动开启):
		//回收不用的对象
		//创建一个Person对象
		Person p = new Person("高圆圆",41) ;
		System.out.println(p);//Person [name=高圆圆, age=41]
		//重写赋值
		p = null ;
		//手动开启垃圾回收器
		System.gc();
		//垃圾回收器将回收这个对象Person [name=高圆圆, age=41]
	}
}

BigDecimal

BigDecimal类的常用方法

java.math.BigDecimal
	描述:对浮点类型的数据进行精确计算的!
构造方法:
	public BigDecimal(String val) :字符串"数字字符串"  
        "1.0"
        "0.01.."

成员方法:
    public BigDecimal add(BigDecimal augend) :求和
    public BigDecimal subtract(BigDecimal subtrahend):减法
    public BigDecimal multiply(BigDecimal multiplicand):乘法
    public BigDecimal divide(BigDecimal divisor)除法