9.常用类

常用类 jdk给提供出来的一些类。
为什么要学习？我们直接用，不用重复造轮子。
怎么学？
–如果静态的，类名.成员
–不是静态的，怎么创建实例对象，哪些属性，哪些方法（方法名，参数列表，返回值–功能）
–使用的层次----> 面向对象的思想

工具
javadoc注释----查看api帮助文档
IDE --提示，注释 

9.1 Object

Object是所有类的父类，如果一个类没有extends一个类，那它是继承了Object。
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

9.1.1 Object的equals方法与 == 的区别

== 比较对象的地址
public boolean equals(Object obj) {
return (this == obj);
}

功能：指示其他某个对象是否与此对象“相等”。其实是比较对象的地址的！！！
		注意：参数是Object 需要向下转型，之前需要判断数据类型是否属于当前类型
		允许子类自定义比较规则，通过子类重写
		重写的场景：如果容器存储多个对象，需要判断其中是否包含某个对象
		 	 int[] {1,2,34,5}
		 	 Student[] 

String类的equals(Object obj) :比较值是否相等
“abc” “abc”

 功能：返回的是对象所属类的字节码对象（类的完全限定名）
		 public final native Class<?> getClass();
		 native 本地的，修饰的方法，没有方法体，但是不代表没有实现，通常是由C/C++来实现的
		 jni 调用其它的语言
		 
		 Class  类 ：字节码文件的类型    也是对象   待后续学反射的时候会详细讲
		 System.out.println(stu3.getClass()==stu4.getClass());//判断不同对象的Class对象是否相同
		 返回结果是true，说明类只加载一次

public native int hashCode();

功能：返回对象的哈希值。默认返回对象的地址。允许子类重写。

  public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

	 功能：把当前对象转换成字符串形式，未重写时，返回   :类的完全限定名+@+哈希值的十六进制字符串
	 	可以继承，可以重写
	 	
	 为什么说toString()方法？我们向直接出生对象中的数据

  public static String valueOf(Object obj) {
        	return (obj == null) ? "null" : obj.toString();
    	  }
    	  
    	  generate toString()
    	  @Override
			public String toString() {
				return "Student [name=" + name + ", age=" + age + "]";
			}

	finalize() --- 临死前的遗言
     	 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
     	 垃圾回收器 GC  ,垃圾 --不存在对该对象的更多引用
     	 Student stu=new Student();
     	 stu=new Student();

9.2 StringBuffer类、StringBuilder类

AbstractStringBuilder 父类 char[] value  可变的 自动扩容
	StringBuffer类
		线程安全的可变字符序列。synchronized 同步锁 线程安全---适合多线程
		可变字符序列，一个类似于 String 的字符串缓冲区
		StringBuffer append(XXX)  往末尾添加
		StringBuffer insert(int offset, String str) 指定位置添加
		StringBuffer reverse() 反转
		String toString()
	StringBuilder类
		一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，
		但不保证同步 ,非线程安全---适合单线程
	
	
		
		
		
	String 类  其值在创建之后不能更改，可以共享  本质 是char value[]
		String str="abc";    内存的方法区有一个字符串常量池，先去判断常量池中是有"abc"
							如果没有，就创建一个，放在常量池中，把地址给str
							
		String str2="abc";  如果有，直接把地址赋值给str2
		str、str2共同指向同一个地址，这就叫共享。
		
		同时，带来了一个问题。
		str=str+"cba";  --- "cba" 、重写开辟区域，存储新的对象"abccba"
		str=str+",a";--- ",a"、、重写开辟区域，存储新的对象"abccba,a"
		"cba"、 ",a"中间对象，垃圾
		所以，在需要频繁地修改字符串的内容的时候，不适合使用String类
		String str=new String("abc");

9.3 基本数据类型与包装类

基本数据类型（8）
	数值型：byte、short、int、long、float、double
	字符型:char
	布尔型:boolean

基本数据类型都是存储栈中，栈中存储的就是值本身，赋值、参数传递的时候操作的也是值本身。
Java是面向对象的，对象都有属性和方法，基本数据类型只有值，没有方法，不遵循面向对象。Java为了完善，为了提供更多的方法去操作基本数据数据
就提供出来了包装类。

	包装类：
		byte--- Byte
		short---Short
		int 	Integer
		long	Long
		float	Float
		double	Double
		char	Character
		boolean Boolean
		除了int--Integer、char--Character，其它的都是首字母变大小

包装类的继承关系
Object
–Number(abstract父类)
–Byte、Short、Integer、Long、Float、Double
–Character
–Boolean

Integer以此为例

	public final class Integer extends Number implements Comparable<Integer>
	1、final 不能继承
	2、extends Number 未继承很多功能
	3、Comparable<Integer>  可比较的   Arrays.sort()
		 public int compareTo(T o);
		 返回值：负数：小于   正数：大于   0：等于
	
	属性  field
		MIN_VALUE -2147483648   -2^31
		MAX_VALUE 2147483647 
		TYPE 获取int类对象
		SIZE = 32;   int数据占32位
		BYTES = SIZE / Byte.SIZE  int数据占多少字节
		
		程序中使用的话，直接用常量，可以节约资源
		
		private final int value; 存储的就是Integer类的数据，本质上就是int value
		value一旦赋值，不能更改，靠什么达到像String对象的共享？---稍后

构造

	Integer(int value) 
	Integer(String s)---要求s必须能转换成int，否则NumberFormatException: For input string: "a25"

方法
static int parseInt(String s)
static int parseInt(String s, int radix) 就是把字符串转换成int ,radix进制可选
不支持Integer.parseInt(“0x10”,16) 但是Integer.parseInt(“10”,16)
------------------------------------------------------------------
static Integer valueOf(String s) 、
static Integer valueOf(int i)
valueOf系列方法，把其它数据类型转换成当前类型

public static Integer valueOf(int i) {
	        if (i >= IntegerCache.low && i <= IntegerCache.high)
	            return IntegerCache.cache[i + (-IntegerCache.low)];
	        return new Integer(i);
	    }

 以上方法意思就是，如果传入的整数是-128-high之间的数，直接从缓存中返回对象。否则新创建
     原来，Integer类中有一个静态内部类  IntegerCache，内部类中有一个cache,当Integer加载的时候，就会初始化此类，缓存
  -128-high（一般就是127）之间的数。
  
  如果你需要Integer类型的对象，优先使用valueOf,而不是构造方法

其它包装类？
public static Float valueOf(float f) {
return new Float(f);
}
Float、Double类的valueOf（）没有缓存。为什么不呢？[-128-127] 整数数量是固定的，小数是无穷的。

  Boolean类
  public static final Boolean TRUE = new Boolean(true);
  public static final Boolean FALSE = new Boolean(false);
  
  总结：
  1、Byte、Short、Integer、Long的valueOf方法都有缓存，【-128，127】
  2、Float、Double的valueOf方法没有缓存，每次都会新创建对象
 3、Character 的valueOf方法 有缓存，【0，127】
 4、Boolean 的valueOf方法 有缓存，有静态的常量true，false，直接返回

xxx（基本数据类型） xxxValue() 获取包装类中的基本数据类型的值 value

进制间转换 把10进制的数转换成其它进制
static String toHexString(int i) --16进制
static String toOctalString(int i) --8进制
static String toBinaryString(int i)–2进制

------
static int reverse(int i) 反转 不是这样的效果123---321

总结：1、数据类型转换

	int--String
		1)a+""
		2)String.valueOf()
		3)Interger:String toString(int i)
	String--int
		1)Integer.parse(String)
	
	Integer-String
		1)toString()
		
	String--Integer
		1)Integer valueOf(String s, int radix)
		2)Integer(String s)
	
	int--Integer
		1)Integer(int i)
		2)Integer valueOf(int i)
	Integer--int
		1)int intValue()

2、进制转换

	装箱：基本数据类型--->包装类型  自动转换
	本质：Integer.valueOf()
	Integer i=12;
	Integer i2=Integer.valueOf(12);
	以上代码效果相同
	
	---
	Integer num1=12;
	Integer num2=12;
	System.out.println(num1==num2);//true
	说明num1和num2地址相同,因为num1和num2都是从缓存中取的同一个地址
	
	--
	Integer num1=129;
	Integer num2=129;
	System.out.println(num1==num2);//false
	129没有缓存，每次都需要重写创建，所以num1和num2地址不同
	--
	Double num1=12d;
	Double num2=12d;
	System.out.println(num1==num2);//false
	因为Double 没有缓存

拆箱：包装类型–基本类型 自动转换
本质：Integer.intValue()
int num=i;//拆箱

注意：如果可以的话，不要频繁地装拆箱

	什么时候装箱、拆箱？
	Integer num1=400;
	int num2=400;
	System.out.println(num1==num2);//true
	返回true就可以说明num1发生了拆箱操作。换一句话来说，==链接包装类和基本数据类型的时候，就拆箱
	
	Integer num1=400;
	int num2=400;
	System.out.println(num1.equals(num2));//true
	返回true就可以说明num2进行了拆箱  
	
	Long num1=400l;
	int num2=400;
	System.out.println(num1.equals(num2));//false
	原因：long类型的equals方法要求类型相同且值相同才返回true，而num2自身装箱成了Integer类型
	
	Integer num1=400;
	int num2=400;
	System.out.println(num1*num2);
	当+、-、*、/、%链接包装类和基本数据类型的时候，是拆箱
	
	
	拆箱的时候注意避免空指针异常
	Integer num1=null;
	int num2=num1;//java.lang.NullPointerException
	就是拆箱实际在执行intValue()
	

Character
	System.out.println(Character.isDigit('a'));
	System.out.println(Character.isLetter('a'));
	System.out.println(Character.isWhitespace(' '));
	System.out.println(Character.isUpperCase('A'));
	System.out.println(Character.isLowerCase('b'));
	System.out.println(Character.toLowerCase('U'));
	

BigInteger
	做权限控制
	BigInteger setBit(int n)  bi+2^n
	boolean testBit(int n)
BigDecimal