day16、常用类

一、Object类

Java中所有的类，都是以继承结构存在的。

Object类是所有类的直接或间接的父类。所以只要是Java中的类的对象，默认都可以执行Object类中的方法。

• 如果一个方法的参数为Object类型，实际可以传入任意的类对象。
• 如果一个方法的返回值是Object类型，实际上可以返回任意的类对象。

java.lang这个包下的类，在使用的时候，无需导入。
java.lang.Object
java.lang.String。。。

其他的包下的类，需要导包。
import java.util.Scanner;

1、getClass()–>Class，获取对象的所属的类。

2、hashCode()–>int，获取对象的哈希值

3、toString()–>String，获取对象的字符串描述

​ 子类重写：将对象的各个属性，拼接成一个字符串。

4、equals()方法–>boolean

• 默认实现（this == obj ）用于判断两个对象地址是否相等
• 也可以对equals()进行重写，比较对象的各个属性值即可

	public boolean equals(Object obj) {
		//1、判断是否为空
		if (obj != null) {
			//2.判断是否为本实例的obj
            //this指代调用对象，obj指代传入参数
			if (this == obj) {
				return true;
			}
			//3.判断类型
			if (obj instanceof Student) {
				Student s = (Student)obj;
				//4.按业务不同，这里使用学号和姓名相同即判定为同一人true
				if(s.getName().equals(this.name)&&s.getNo()==this.no){
					return true;
				}
			}
		}
		return false;
	}

5、finalize()

当对象被判断为垃圾对象时，由JVM自动调用次饭饭，用以标记垃圾对象，进入回收队列。

自动回收机制：JVM的内存耗尽，一次性回收所以垃圾

手动回收机制：使用System.gc();通知JVM执行垃圾回收。

二、包装类

1. 概念

基础数据类型所对应的引用数据类型

包装类的默认值是null

java.lang包下

Number类作为6种数值类型的包装类的直接父类。然后再继承Object类

基本数据类型	对应的包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

2、拆箱与装箱

自动装箱和拆箱：jdk1.5之后

1、将基本类型——>转为对象类型(装箱)
Integer i = Integer.valueOf(4);//基础转为包装类

2、将对象类型——>基本类型(拆箱)
Integer i2 = new Integer(5);
int b = i2.intValue();//包装类转为基础数据类型

3、将String类型——>基本类型
String s = "250";
int s1 = Integer.parseInt(s);
//注意:字符串转成基本数据类型时字符串内容必须是基本数据类型的字面值，否则编译虽然能通过，但运行时出现NumberFormatException

4、基本数据类型-->String
boolean b = true;
String str = b+"abc";//"trueabc"

三、String字符串类

能够表示字符串：String类，StringBuffer类，StringBuilder类。

String类：字符串内容不可以改变。

1、String类

1.1 常量池常量

字符串的数据是常量，存储在常量池中，字符串的数值是不能更改的。创建后不可改变

jdk1.7以后常量池转移到堆空间

public class Test1 {

	public static void main(String[] args) {

		String a = "a";
		//上面已经在常量池里面放了a这个字符串
		String b = "a";
		//同样也是值为a的变量，就不会重新创建，而是直接指引到已有的常量池中a字符串的位置
		System.out.println(a==b);//true
		
		//new 代表怎么样都会在堆中开辟一个空间
		//创建1个对象，在堆空间，又指向常量池里面已存在的"a"
		String c = new String("a");
		System.out.println(c==a);//false
		//创建2个对象，1个堆空间，1个在常量池
		String d = new String("b");
	}
}

1.2 方法

1、创建字符串：

//1.直接创建
String s1 = "abc";
//2.通过构造方法
String s2 = new String();//""

A：搜索类

indexOf()-->int//在字符串中，查找指定参数，返回值为该参数第一次出现的下标；如果没有，返回-1。

indexOf(字符 ,fromIndex)-->int//在字符串中，从下标fromIndex开始往后查找指定参数，找到就返回该参数第一次出现的下标；如果没有，返回-1。

lastIndexOf(字符)-->int//在字符串中，从后往前查找指定参数，找到就返回该参数第一次出现的下标；如果没有，返回-1。

lastIndexOf(字符,fromIndex)-->int//在字符串中，从fromIndex开始从后往前查找指定参数，找到就返回该参数第一次出现的下标；如果没有，返回-1。

B：判断类

contains()-->boolean，是否包含指定内容
equals()-->boolean，判断字符串的字面值，是否相等，重写Object类
equalsIgnoreCase()-->boolean，忽略大小写的比较
startsWith()-->boolean,是否以指定内容开头
endsWith()-->boolean，是否以指定内容结尾

C：获取新的字符串

concat()-->String，拼接，作用同+
subString(fromIndex)--->String，截取子串
subString(fromIndex,endIndex)-->String，截取子串包含fromIndex，不包含endIndex
replace(oldchar,newchar)-->String，替换
replace(CharSequence,CharSequence)-->String
trim()->String，忽略首尾空格
toLowerCase()-->String，转小写
toUpperCase()-->String，转大写

D：获取其他

length()-->int，获取长度
getBytes()-->byte[],获取字节数组
toCharArray()-->char[]，获取字符数组
charAt(index)-->char，根据下标获取指定的字符
split(切割符)-->String[]，切割

1.3 练习

public class Demo1 {

	public static void main(String[] args) {
		String a = "java is besat";
		//从前往后找，字符第一次对应下标
		int first = a.indexOf("a");
		//从后往后前，字符第一次出现对应下标
		int last = a.lastIndexOf("a");
		System.out.println(first);//1
		System.out.println(last);//11
		//将小写转为大写
		a = a.toUpperCase();
		System.out.println(a);//JAVA IS BESAT
		//将大写转为小写
		a = a.toLowerCase();
		System.out.println(a);//java is besat
		
		
		String b = "  s s s  ";
		//去首尾空格
		System.out.println(b.trim());//s s s
		//替换指定字符
		b = b.replace(" ", "*");
		System.out.println(b);//**s*s*s**
		
		a = "java is best";
		//字符串转为字符串数组
		String[] stringArrays = a.split(" ");
		
		String end = "";
		for (int i = 0; i < stringArrays.length; i++) {
			//字符串转为char数组
			char c[] = stringArrays[i].toCharArray();
			//使用char包装类的方法转首字母（下标0的位置）大写
			c[0] = Character.toUpperCase(c[0]);
			//在将char数组转为String，进行拼接
			end+=String.valueOf(c)+" ";
		}
		System.out.println(end);
	}
}

2、StringBuffer类

带了一块空间的字符串对象。默认的缓冲区大小16个字符

//1.添加
append(data)-->StringBuffer，末尾追加。生活中的排队，都是默认排在队伍末尾
insert(offset,data)-->StringBuffer，插入数据。生活中的插队，在哪插入。

//2.删除
delete(start,end)-->StringBuffer，删除，从start下标开始，删除到end下标之前。包含start，但是不包含end。
deleteCharAt(index)-->StringBuffer,删除指定下标对应的字符。

//3.更改
reverse()-->StringBuffer，翻转一个字符串。
setCharAt(index, char)-->void，设置指定下标对应的字符。字符替换。
setLength(newLength)-->void，设置StringBuffer的字符串的长度。截取/用空字符填充
replace(start,end, str)-->StringBuffer,替换指定区间的内容：[start,end)
toString()-->从StringBuffer类型，变为String类型。
                                                  
//4.同String类相同
length()-->int，获取长度
charAt(index)-->char，根据下标获取指定的字符
indexOf(String)//在字符串中，查找指定参数，返回值为该参数第一次出现的下标；如果没有，返回-1。
indexOf(String,fromIndex)
lastIndexOf(String)//在字符串中，从后往前查找指定参数，找到就返回该参数第一次出现的下标；如果没有，返回-1。
lastIndexOf(String,fromIndex)
substring(begin)
substring(begin,end)//截取子串包含begin，不包含end

3、StringBuilder类

StringBuilder类提供的方法，和StringBuffer功能相同。

• StringBuilder类：可变长字符串，JDK5.0提供，运行效率快、线程不安全
• StringBuffer类：可变长字符串，JDK1.0提供，运行效率慢、线程安全
• 运行速度StringBuilder>StringBuffer>String

4.练习

public class Test {
	public static void main(String[] args) {
		//在默认长度下为16，超出*2+2进行扩容
		//StringBuilder和StringBuffer的初始长度和扩容规则一样
		StringBuffer sb = new StringBuffer("a");
		StringBuilder sb2 = new StringBuilder("q");
		sb.append("b").append("c");
		//倒叙输出字符串“abcdefg”
		System.out.println(sb);//abc
		sb2.append("abcdefg");
		System.out.println(sb2.reverse());//gfedcbaq
		//使用StringBuffer，把手机号中间4个换位****
		StringBuffer sb3= new StringBuffer("13488889999");
		System.out.println(sb3.replace(3, 7, "****"));
	}
}

四、BigDecimal类

位置：java.math包中

作业精确计算浮点数

public class Demo {

	public static void main(String[] args) {
		//做精确计算用 
		BigDecimal bd = new BigDecimal(1.0);
		BigDecimal bd2 = new BigDecimal("0.9");
		
		//加法add()
		BigDecimal res1 = bd.add(bd2);
		System.out.println(res1);//1.9
		
		//减法subtract()
		BigDecimal res2 = bd.subtract(bd2);
		System.out.println(res2);//0.1
		
		//乘法multiply()
		BigDecimal res3 = bd.multiply(bd2);
		System.out.println(res3);//0.9
		
		//除法(保留2位小数，四舍五入)
		//divide(BigDecimal divisor,int scale,int roundingMode)
		BigDecimal res4 = bd.divide(bd2, 2, BigDecimal.ROUND_HALF_UP);
		System.out.println(res4);//1.11
	}
}

五、Date类

java.util.Date类：(区别于java.sql.Date)

表示特定时间的Date对象：年月日时分秒时区

1、Calendar类

Calendar类是抽象的。

获取日期时间，也可以设置日期时间。

//创建Calendar类的对象。
Calendar calendar = new GregorianCalendar();//方式一
Calendar rightNow = Calendar.getInstance();//方式二

练习

import java.util.Calendar;
public class Demo6 {
	public static void main(String[] args) {
		
		Calendar c = Calendar.getInstance();		
		//获取年
		String year = c.get(Calendar.YEAR)+"年";
		//获取月
        //月份需要加1
		String mounth = (c.get(Calendar.MONTH)+1)+"月";
		//获取 日
		String dayOfMounth = c.get(Calendar.DAY_OF_MONTH)+"日";
		//获取时间
		String time = c.get(Calendar.HOUR_OF_DAY)+":"
			+c.get(Calendar.MINUTE)+":"+c.get(Calendar.SECOND);
	
		System.out.println(year+mounth+dayOfMounth+" "+time);	
	}
}

2 SimpleDateFormat类

专门用于日期和文本之间的转换。

表示日期时间的特殊字符：

字母	日期或时间
y	年
M	年中的月份
w	年中的周数
D	年中的天数
d	月份中的天数
a	am/pm
H	一天中的小时数（0-23）
h	am/pm中的小时数（1-12）
m	小时中的分钟数
s	分钟中秒数
S	毫秒数

/*
 * String-->Date：解析？就是将一个文本字符串，解析成一个Date对象。
 */
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test {
	public static void main(String[] args) {
		
		Date d = new Date();
		SimpleDateFormat sdf =  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String date = sdf.format(d);
		System.out.println(date);
	}
}

//Date-->String：日期格式化？就是将一个日期Date对象，按照指定的字符串格式去显示。
import java.text.SimpleDateFormat;
import java.util.Date;
public class GetDate {
	/**
	 * 默认模板20-8-1 上午10:36
	 */
	public static void getDate1(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat();
		String s1 = sdf.format(date);
		System.out.println(s1);
	}
	/**
	 * 自定义模板2020年08月01日 10:38:17
	 */
	public static void getDate2(Date date) {
		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		String s2 = sdf2.format(date);
		System.out.println(s2);
	}
	/**
	 * 自定义模板2020-08-01 10:40:25
	 */
	public static void getDate3(Date date) {
		SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String s3 = sdf3.format(date);
		System.out.println(s3);
	}
	/**
	 * 自定义模板2020/08/01 10:43:32
	 */
	public static void getDate4(Date date) {
		SimpleDateFormat sdf4 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
		String s4 = sdf4.format(date);
		System.out.println(s4);
	}
	
}
public class Test {
	public static void main(String[] args) {
		Date date = new Date();
		//静态的方法直接由类名调用
		GetDate.getDate1(date);
		GetDate.getDate2(date);
		GetDate.getDate3(date);
		GetDate.getDate4(date);	
	}
}