Java学习记录：常用类 总结

**Java SE学习总结：**常用类，内容不是很难，但是知识点偏多，老师讲完以后自己还不是很清楚，今天周四，自习。把作业做完了以后，结合老师的笔记，总结一下前天学的东西。 加油！

一、常用类

一、内部类

概念：在一个类的内部再定义一个完整的类
特点：
	编译之后可生成独立的字节码文件。
	内部类可直接访问外部类的私有成员，而不被破坏。
	可为外部类提供必要的内部功能组件。
优点：
	内部类与外部类可以方便的访问彼此的私有域（私有方法、私有属性）。
	内部类是另外一种封装，对外部的其他类隐藏。
	内部类可以实现Java的单继承局限
缺点：
	结构复杂

1.1、成员内部类

定义：在类的内部定义，与实例变量、实例方法同级别的类。

外部类的一个实例部分，在创建内部类对象时，必须依赖外部类对象。
	Outer out = new Outer();
	Inner in = out.new Inner();
	
当外部类、内部类存在重名属性时，内部类的方法会优先访问内部类属性。

成员内部类内部不允许存在任何static变量或方法 正如成员方法中不能有任何静态属性

2.1、静态内部类

用static修饰的成员内部类我们成为静态内部类

不依赖于外部对象，可直接创建或通过类名访问，且可声明静态成员；
静态内部类不可以使用任何外部类的非static类、方法、属性。访问实例成员需要实例化外部对象。
	Outer.Inner inner = new Outer.Inner();
	Outer.Inner.show();

3、局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。（可以看成局部变量）不能有public,protected,public修饰。

局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。

4.1、匿名内部类

匿名内部类是一个没有名字的局部内部类。因此局部内部类的特点它都有，它还有自己的特点。
必须继承一个父类或者实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
//例如
interface MyInterface {
    //接口中方法没有方法体
    void test();
}
class Outer{
    private int num = 5;
    public void dispaly(int temp)
    {
        //匿名内部类，匿名的实现了MyInterface接口
        //隐藏的class声明
        new MyInterface()
        {
            public void test()
            {
                System.out.println("匿名实现MyInterface接口");
                System.out.println(temp);
            }
        }.test();
    }
}
public class Test{
    public static void main(String[] args)
    {
        Outer out = new Outer();
        out.dispaly(3);
    }
}

二、Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层。

任何类如果没有书写阶乘extends显示继承某个类，都默认继承Object类，否则为间接继承。

Object类中所定义的方法，是所有对象都具备的方法。

Object类型可以存储任何对象。
 ·作为参数，可接受任何对象
 ·作为返回值，可返回任何对象

2.1、getClass()方法

public final Class<?> getClass(){}
返回引用中存储的实际对象类型。
应用：通常用于判断两个引用中存储的对象类型是否一致。

2.2、hashCode()方法

public int hashCode(){}
返回该对象的十六进制的哈希码值
哈希算法根据对象的地址或字符串或者数字计算出来int类型的值
哈希码并不唯一，可以保证相同对象返回相同哈希码，尽量保证不同对象返回不同哈希码。
重写/覆盖    //name  age  sex
public int hashCode(){
	return this.name.hashCode()+this.age+this.sex.hashCode();
}

2.3、equals()方法

public boolean equals(Object obj){}

默认的实现方法为（this == obj）,比较两个对象地址是否相同

可进行覆盖，比较两个对象的内容是否相同
例如  //三个变量 name,age,sex
	public boolean equals(Object obj){
		//1第一步：比较两个引用对象，如果地址相同，直接返回true
		if(this == obj) { return true; }
		//2第二步：如果obj为空或者如果两个对象的类型不是一个类型的
        if(obj == null || this.getClass()!= obj.getClass())  { return false; }
        //3第三步：强制类型转换
        Student stu = (Student) obj;
        //4第四步：以此比较各个属性值是否相同，如果相同，则返回ture，不同返回false
        if(stu.name.equals(this.name) && stu.age == age && stu.sex.equals(this.sex)) 	{ return true;}
        else { return false;}
	}

2.4、toString()方法

public String toString(){}
返回该对象的的字符串（变现形式）表示
可根据需求重写toString方法{}
例如  //三个变量 name,age,sex

public String toString() {
        return "Worker{" + "name='" + name + '\'' + ", age=" + age + ", sex=" + sex +'}';
    }

2.5、finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
垃圾对象：没有有效引用指向此对象了，被判定为垃圾对象
垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用System.gc();通知JVM执行垃圾回收。

三、包装类

基本数据类型所对应的数据引用数据类型。

Object可统一所有数据，包装类的默认值是null

3.1、八大基本数据类型

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

3.2、类型转换与装箱、拆箱

8种包装类提供不同类型间的转换方式：
	Number父类中提供6个共性方法
	parseXXX()静态方法。
	valueOf()静态方法。

拆箱：将包装类型数据转换成基本类型数据

装箱：将基本类型数据包装成包装类型数据

3.2.1、装箱：使用包装类中的构造方法，或者静态valueOf方法

int i = 5;
Integer in = new Integer(5);
//或
double d = 5.5;
Double do = Double.valueOf(d)

3.2.2、拆箱：使用包装类的xxValue()方法

		Integer i = new Integer(5);
		int a = i.intValue();

JDK 5.0之后，自动装箱和拆箱

int a = 5;
Integer i = a;

Integer i = 5;
int a = i;

3.3、基本数据类型和字符串之间的相互转换

基本类型转字符串

字符串连接符：

1.字符串连接符：任何基本数据类型与字符串连接都变成字符串形式	
		int a = 5;
		String str = a + " ";
2.String类中的ValueOf方法：
		boolean boo = true;
		String str = String.valuOf(boo);

字符串转基本类型：

 包装类中的parseXXX方法：
 String num = "123";
 double a = Double.parseDouble(num);

​ i 字符串不能直接转成字符类型，需要使用String类中的charAt()方法取字符串中的每一个字符

​ ii. 若字符串转数值类型时，若字符串中存在不能表示数值的字符时，抛出

​ java.lang.NumberFormatException异常

​ iii. 字符串转布尔类型时，当且仅当字符串是“true”时，结果为true，否则其他任意字符串转布尔类型结

​ 果都是false

四、String字符串

4.1、概念

字符串数据是常量，存储在常量池中，常量池中不允许存储相同的数据，字符串可以直接将数据赋值给对象引用。
数据共享

4.2、字符串创建对象

String s = new String("abc");

4.3、字符串常用方法

public int length(); //返回字符串的长度
String s = new String("ABCDEF")；
int len = s.length(); //5


public char charAt(int index) //获取指定下标的字符
String s = new String("abcdef");
char c = s.charAt(3);  // 返回索引位置为3的字符 d


public String concat(String str) //在原来字符串后面拼接str
String s1 = "abc";
String s2 = "def";
String s3 = s1.conact(s2);
System.out.println(s3); //abcdef


public boolean endWith(String suffix) //判断是否为指定后缀
boolean b = s.endWith("OK"); //判断s字符串


public boolean startsWith(String prefix) //判断是否为指定开头
boolean b = s.startsWith("OK");//判断s字符串是否以OK开头


public boolean equalsIgnoreCase(String anotherString) //忽略大小写比较
String s1 = "abc";
String s2 = "ABC";
boolean  b = s1.equalsIgnoreCase(s2);//两个字符串长度相同，内容相同，忽略大小写，true


public int indexOf(int ch, int fromIndex) //从fromIndex开始查询ch首次出现的下标
    /*
		int indexOf(int ch)   
		返回指定字符在此字符串中第一次出现处的索引。 
		 int indexOf(int ch, int fromIndex) 
		返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 
		 int indexOf(String str)	  
		返回指定子字符串在此字符串中第一次出现处的索引。 
		 int indexOf(String str, int fromIndex) 
 		返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 
 		*/
int index = s1.indexOf('a');//获取a在s1字符串中首次出现的位置
int index2 = s1.indexOf('a',3);//获取'a'字符在s1字符串中从索引为3开始第一次出现的索引
//注意：查找字符串时，返回的是第一个字母的下标
int index3 = s.indexOf("abc");//获取"abc"字符串在s字符串中第一次出现的索引
//注意：查询没有结果时则返回-1
int index4 = s.indexOf("abc",4);//获取"abc"字符串在s字符串中从索引为4开始第一次出现的索引


public int lastIndexOf(int ch) //查询ch最后一次出现的下标
int index = s1.lastIndexOf('a');//查询字符a在s1字符串中最后一次出现的位置


public boolean isEmpty() //判断是否为空串
/*
		 boolean isEmpty()           当且仅当 字符串的length() 为 0 时返回 true。 
*/
boolean b2 = s.isEmpty();//判断s字符串是否是空字符串    


public String replace(char oldChar, char newChar) //替换
/*
		 String replace(char oldChar, char newChar) 
 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 
		String replace(CharSequence target, CharSequence replacement) 
 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。 
		*/
		String s = "hello java";
		//注意：会替换原字符串中所有的指定字符
		String s1 = s.replace('a','k');
		System.out.println(s1);

		//注意：将要替换的字符串可以和被替换的字符串长度不相等，当做一个整体被替换掉
		String s2 = s.replace("java","php");
		System.out.println(s2);    
    

public String[] split(String regex) //依据regex拆分
String s1="a,b,c,d,e,f";
String[] ss = s1.split(',');//根据,符号将字符串拆分成一个数组


public String substring(int beginIndex, int endIndex) //截取子串
    		/*
		 String substring(int beginIndex) 
 返回一个新的字符串，它是此字符串的一个子字符串。 
		String substring(int beginIndex, int endIndex) 
 返回一个新字符串，它是此字符串的一个子字符串。 
		*/
		//从指定的下标开始截取后半部分
		String str2 = str1.substring(3);
		System.out.println(str2);

		//包头不包尾：截取指定区间的子字符串
		String str3 = str1.substring(3,9);
		System.out.println(str3);



public String toLowerCase() //转小写
String s1 = "ABC";
System.out.println(s1.toLowerCase());//abc


public String toUpperCase() //转大写
String s1 = "abc";
System.out.println(s1.toUpperCase());//ABC



public String trim() //去掉前后空格
String s1 = " abcdef ";
System.out.println(s1.trim());//打印abcdef  前后空格消失

五、可变字符串

StringBuffer:可变长字符串，JDK1.0提供，运行效率慢，线程安全
StringBuilder:可变长字符串，JDK5.0提供，运行效率快，线程不安全

5.1、StringBuffer

5.1.1、增加

/*
		StringBuffer append(String str) 追加
        StringBuffer insert(int offset, String str)  插入
		*/
		StringBuffer sb2  = sb1.append("hello");

		//区别于String类：面盆理论
		System.out.println(sb1);
		System.out.println(sb2);
		System.out.println(sb1 == sb2);

		sb1.append("java");
		System.out.println(sb1);
		System.out.println(sb2);

		//方法链
										 		
		sb1.append("java").append("java").append("java").append("java");
		System.out.println(sb1);
		System.out.println(sb2);

		//插入
		sb1.insert(2,"hhhhhhhh");
		System.out.println(sb1);

5.1.2、删除

/*
		 StringBuffer delete(int start, int end) 
		StringBuffer deleteCharAt(int index) 
		*/

		//删除指定区间的字符串
		sb1.delete(2,3);
		System.out.println(sb1);

		//删除指定位置上的字符
		sb1.deleteCharAt(0);
		System.out.println(sb1);

5.1.3、修改

	/*
		 StringBuffer replace(int start, int end, String str) 
		 void setCharAt(int index, char ch) 
		*/
		//替换指定区间的字符串
		sb1.replace(2,5,"nnnnnn");
		System.out.println(sb1);

		//替换指定位置上的字符
		sb1.setCharAt(0,'x');
		System.out.println(sb1);

5.1.4、获取

		//和String类中的用法相同
		/*
		indexOf
		lastIndexOf
		charAt
		length
		substring
		*/

5.1.5、反转（倒序、颠倒）

		// StringBuffer reverse() 
		StringBuffer sb3 = new StringBuffer("my name is zhansan");
		sb3.reverse();
		System.out.println(sb3);

5.2、StringBuilder

StringBuilder类也是字符串缓冲区，类中的方法与StringBuffer类中的方法使用方法一样，区别在于StringBuilder类中的方法都是非线程安全的，而StringBuffer类中的方法都是线程安全的

六、BigDecimal

public static void main(String[] args){
    double d1 = 1.0;
    double d2 = 0.9;
    System.out.println(d1-d2); //得到的结果是近似值
}

很多时候需要精确计算，而double存的却是近似值，这时候就需要BigDecimal

6.1、BigDecimal

位置：java.lang包下

作用：精确的计算浮点数

创建方式：BigDecimal bd = new BigDecimal("1.0");

方法：

	BigDecimal add(BigDecimal bd); //加

	BigDecimal subStract(BigDecimal bd); //减

	BigDecimal multiply(BigDecimal bd); //乘

	BigDecimal divide(BigDecimal bd); //除

代码实现：

public static void main(String[] args){
	BigDecimal bd1 = new BigDecimal("1.0");
    BigDecimal bd2 = new BigDecimal("0.9");
    BigDecimal result1 = bd1.add(bd2);//1.9
    System.out.println(result1);
    BigDecimal result2 = bd1.subStract(bd2);//0.1
    System.out.println(result2);
    BigDecimal result3 = bd1.multiply(bd2);//0.90
    System.out.println(result3);
    BigDecimal result4 = bd1.divide(bd2);//这里出错，当进行除法运算时，需要指定保留的位数和取舍方式
    System.out.println(result4);
}	
使用BigDecimal(BigDecimal bd,int scal,RoundingMode mode);  
参数scal:指定精确到小数点后几位
参数mode:指定小数部分的取舍模式，通常采用四舍五入
		BigDecimal.ROUND_HALF_UP;