第七章_初识API

一、object

所有类的顶级父类
存在于java.lang包中，这个包不需要手动导包

常用方法：

1.toString()
返回对象的字符串表示

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

3.equals(Object obj)
指示他某个对象是否与此对象相等

student s = new student("jeck",10); 	
System.out.println(s);//student@54bedef2
System.out.println(s.hashCode());//返回对象在内存中的哈希码值
student s2 = new student("jeck",10); 
System.out.println(s.equals(s2));//比较两个对象是否相等		

总结：
1、
打印对象时，返回的是一个地址值，因为底层的toString()方法是父类Object提供的,想要查看对象里面的属性值就需要重写toString()
2、
使用equals()比较两个对象时，底层会使用父类Object提供的等等比较，比较的是两个对象的地址值。想要比较两个对象的属性就需要重写equals()

二、String类的使用

String工具类
特点：
是一个封装char[]数组的对象
字符串不可变–它的值在创建后不可以更改

1、 创建String类对象

方式一
	char value[]= {'a','b','c'};//先定义一个char数组
	String s1=new String(value);
	
方式二
	String s2="abc";//底层也会new String() 

2、 常用方法

• 字符串对象名.charAt(下标); 获取下标为xxx的char字符

System.out.println(s2.charAt(1));//b  获取下标为1的char字符 

• 字符串对象名.concat(“字符串”); 在数组后面拼接字符串

System.out.println(s2.concat("opq")); 在abc后面拼接字符串opq 

• 字符串对象名.endsWith(“字符串”); 查看此数组以什么字符串结尾

System.out.println(s2.endsWith("pq"));//true查看字符串以什么结尾

• 字符串对象名.equals(字符串对象名); 比较两个字符串是否相等
  这里的equals()是重写后的，比较的是属性名。String里自动重写了

System.out.println(s2.equals(s1));//true  比较两个字符串是否相等

• 字符串对象名.getBytes(); 将字符串转成byte[]数组

System.out.println(s2.getBytes());//[B@2ff4acd0  将字符串转成byte[]数组

• 字符串对象名.indexOf(“字符串”); 获取此字符串出现第一次的下标

System.out.println(s2.indexOf("c"));//2 获取c出现的第一次 

• 字符串对象名.lastIndexOf(“字符串”); 获取此字符串出现最后一次的下标

s2=" abcac";
System.out.println(s2.lastIndexOf("c"));//4 指c出现的最后一次位置的索引

• 字符串对象名.length(); 获取此字符串的长度

System.out.println(s2.length());//5		获取字符串的长度

• 字符串对象名.split(“规则”); 把字符串按照一定的规则进行切割，形成String[]

s2="a,b,c,d,e,f";
System.out.println(s2.split(","));//[@54bedef2 把字符串按照规则进行切割

• 字符串对象名.startsWith(“a”); 判断字符串是否以a开始

System.out.println(s2.startsWith("a"));//true  判断字符串是否以a开始

• 字符串对象名.substring(开始下标，结束下标); 从开始下标截取到结束下标 含头不含尾

System.out.println(s2.substring(3,7));//  含头不含尾3456

• 字符串对象名.toLowerCase(); 将此字符串全转小写

System.out.println(s2.toLowerCase());//全转小写

• 字符串对象名.toUpperCase(); 将此字符串全转大写

System.out.println(s2.toUpperCase());//全转大写

• 字符串对象名.trim(); 去掉字符串的前后空格

s2="     abcdefg    ";
System.out.println(s2.trim());//去掉数据的前后空格

• 类名.valueOf(各种数据类型); 把指定的数据类型转成字符串类型

System.out.println(String.valueOf(10));//将10转成了字符串类型

• 字符串对象名.isEmpty(); 字符串是否为空

System.out.println(s2.isEmpty());

三、Stringbuilder/Stringbuffer工具类

用于优化字符串拼接效率

特点：
1.封装了一个 char[]数组
2.是可变的字符序列
3.提供了一组可以对字符内容修改的方法，
4.常用 append() 来代替字符串做字符串连接
5.内部字符数组默认初始容量是16，
6.如果大于 16 会尝试将其扩容，变成新数组大小的2倍+2，容量如
果还不够直接扩容到需要的容量大小

常用方法：
append()

案例：

	public static void method() {
		//1.定义字符串
		String str ="abc";
		//2.将指定的字符串拼接10000次
		String result="";
		//计时开始
		long s1 = System.currentTimeMillis();//获取系统的当前时间ms
		for (int i = 0; i < 10000; i++) {
			result=result+str;
		}
		//计时结束
		long s2 = System.currentTimeMillis();//获取系统的当前时间ms
		System.out.println(s2-s1); //3014ms
	}
	
--------------------------------------------------------------------	
	
	public static void method2() {
		//1.定义字符串
		String str ="abc";
		//2.将指定的字符串拼接10000次
		StringBuffer st=new StringBuffer();//先创建一个StringBuffer对象
				
		
		//计时开始
		long s1 = System.currentTimeMillis();//获取系统的当前时间ms
		for (int i = 0; i < 10000; i++) {
			st.append(str);因为创建了StringBuffer对象，可以使用里面的方法
		}//append(str)就是将str拼接
		//计时结束
		long s2 = System.currentTimeMillis();//获取系统的当前时间ms
		System.out.println(s2-s1); //4ms
	}
}

总结: 为什么+号拼接没有工具类拼接快？
原因：
1.字符串拼接时，由于字符串的特点是一旦定义值不可被修改。每次+都会产生新的字符串对象，浪费内存和时间
2.工具类快是因为StringBuffer是可变的数组，会把新的数据拼接在原有数据末尾处。无论拼接多少次，使用的都是同一个字符串对象，节省时间和内存

Stringbuilder------更追求效率，安全性偏低

Stringbuffer-------更追求安全，但效率低

四、正则表达式

正确的字符串格式规则，常用来判断用户输入的内容是否符合格式的要求，
严格区分大小写

String提供了正则表达式的方法
matches(regex)：字符串是否符合正则表达式的要求

案例：

//1.接受用户输入的身份证号
String input=new Scanner(System.in).nextLine();

String regex="[0-9]{17}[0-9xX]";//前17位是数字，最后一位是数字也可能是xX

//2.判断用户输入的身份证号的格式对吗？----正则
if (input.matches(regex)) {
	//matches是String类提供的功能，用来判断字符串是否符合正则表达式的要求
	System.out.println("ok....");
} else {
	System.out.println("no  ok....");

五、包装类

把基本类型进行包装，提供更完善的功能

Number:数字包装类的抽象父类，提供了各种获取值的方式

例如：
这里以Integer为例，其他基本类型和它一样

1.New Integer(5);利用构造方法，把一个基本类型的5包装成包装类型的5
2.Integer.valueOf(5),利用静态方法也可以将基本类型的5包装成包装类型的5

常见方法：
1、Static int parseInt(String s)

• parseInt()把字符串类型数字转成int类型

2、.valueOf(XXX)

• 哪种类型的点valueOf(XXX)，就把XXX转成哪种类型

public static void main(String[] args) {
		//1.创建对象
		Integer a= new Integer(5);//a的默认值是null,不再是0
		Integer b= Integer.valueOf(5);//在-128~127范围内，效率高，因为相同数据只会存一次
		Integer c= Integer.valueOf(5);
		System.out.println(a==b);//==比较的是两个对象的地址值
		System.out.println(b==c);//true相同数据不在开辟空间，效率高，只针对Integer里的valuaeOf高效
		//2.常用方法
		System.out.println(a.parseInt("8000")+10);//parseInt()把字符串类型数字转成int类型

六、自动装箱和自动拆箱

自动装箱：把基本类型自动包装成包装类型的过程
Integer a = 5;
Integer a= Integer.valueOf(5)
Integer a = 5;//a是引用类型，引用了包装对象的地址
编译会自动完成对象的自动装箱：Integer a= Integer.valueOf(5)

自动拆箱：从包装类型的值，自动变成基本类型的值
int i = a;
int i = a.intVaule();
int i = a;//a现在是包装类型，没办法给变量赋值，需要把5取出来
编译器会自动拆箱：int i = a.intVaule();

七、==和equals的区别

1、
当使用 == 比较时，
如果比较的是引用类型，那么比较的是两者的地址值，
如果比较的是数值类型，那么比较的是具体数值是否相等。

2、
当使用equals()方法进行比较时，
类中重写了equals()，是数值（属性）的比较，
而默认Object类实现中，equals()方法的底层是通过 == 来实现的。

八、BigDecimal / Biglnteger

BigDecimal：常用来解决精确的浮点数运算。
Biglnteger： 常用来解决超大的整数运算。

创建对象
BigDecimal big1 = new BigDecimal(需要参与计算的数值对象a+“”);
BigDecimal big2 = new BigDecimal(需要参与计算的数值对象b+“”);
细节，需要计算的数值对象后面加个空字符串

常用方法

add(BigDecimal bd)：做加法运算
substract(BigDecimal bd) 做减法运算
multiply(BigDecimal bd) 做乘法运算
divide(BigDecimal bd) 做除法运算


divide(BigDecimal bd,保留位数舍入方式)做除法运算
除不尽时使用setScale(保留位数，舍入方式)

pow(intn)：求数据的几次幂

代码案例：

	private static void method() {
		//1，接收用户输入的两个小数
		double a =new Scanner(System.in).nextDouble();
		double b =new Scanner(System.in).nextDouble();
		//2.创建工具类对象
		BigDecimal bd1=new BigDecimal(a+"");//最好使用String参数的构造方法
		BigDecimal bd2=new BigDecimal(b+"");
		//3.做运算
		BigDecimal bd3;
		bd3=bd1.add(bd2);//+
		System.out.println(bd3);
		bd3=bd1.subtract(bd2);//-
		System.out.println(bd3);
		bd3=bd1.multiply(bd2);//*
		System.out.println(bd3);
		
		//bd3=bd1.divide(bd2);//
		bd3=bd1.divide(bd2, 3,BigDecimal.ROUND_HALF_UP);四舍五入
		System.out.println(bd3);