震惊！BAT职场大牛仅用7000字总结就把Java常用类讲明白了

Object类

Object类的认识

• Object类位于java.lang包中的类，是根类、超类、顶级父类，是所有类的父类、直接父类或间接父类
• Object类型的引用可以存储任意类型的对象
• Object类中的方法是每一个类都具备的功能

Object类中常用的方法

getClass()

被final修饰的方法，不能被子类覆盖，获取引用中实际存储的对象类型

• 实际开发应用
  通常用于判断两个引用中实际存储的对象类型是否一致

  注意：引用名 instanceof 类名：用于判断前面引用中实际存储的对象类型是否为后面的一种类型，是true，否false

string toString()

没有被final修饰，允许子类覆盖，返回对象字符串表现形式

• toString方法覆盖的原则，通常将所有的属性拼接为一个String类型的结果作为返回值返回
  • toString方法：是为了方便编程人员打印对象属性信息而设置的一个方法。将所有的属性信息拼接为一个字符串。
  • get方法：是获取单个属性的信息，并且不会改变属性对应的数据类型。

int hashCode()

没有被 final修饰，允许被子类覆盖，返回一个对象的哈希码值。

• 对象的哈希码值：是由当前对象在堆空间中十六进制的地址转换为十进制的结果(无需编程人员转换)
  • 由于不同的对象在堆空间具有不同的地址，所有不同的对象具有不同哈希码值 (后期讲解集合会具体应用)

boolean equals(Object obj)

没有被final修饰，允许子类覆盖，用于比较两个对象的内容是否相同，内容相同-true，内容不同-false

• == 的应用如下：

  • 如果 == 两端连接的是基本数据类型的变量，则比较的是数据

  • 如果 == 两端连接的是引用，则比较引用中存储的地址是否相同，相同-true;不同-false

    注意：在实际开发时，通常利用 == 判断两个引用是否指向同一个对象

• equals方法的应用
  • Object类中equals方法的实现，依然比较的引用中存储的地址相同
  • 子类如果利用equals方法比较内容，需要覆盖(重写)equals方法
• 面试题目：== 和 equals的区别？
  (1) 如果 == 两端 是基本数据类型的变量，则比较数值
  如果 == 两端 是引用类型，则比较引用存储的地址是否相同
  (2) equals方法：用于判断两个对象内容是否相同

  ​注意
  Object类型中equals方法实现是 用== 进行比较，比较的是引用中的地址是否相同，所以实际开发时，如果利用 equals比较对象的内容，需要覆盖(重写) equals方法。

void finalize()

没有被final修饰，允许子类覆盖，垃圾回收器在回收垃圾对象时，jvm自动调用的方法。【提高性能-jvm】

1. 垃圾对象：如果没有任何引用指向的对象
2. 垃圾回收：jvm会在某些条件下，对内存垃圾进行清理回收
3. 垃圾回收的目的：清除垃圾对象，提高内存空间的利用率
4. 垃圾回收器：简称为 GC/gc，jvm用于回收垃圾对象

• GC回收垃圾对象的时机：
  • 自动回收
    当jvm内存被占用满时，jvm启动GC对内存垃圾对象进行回收，GC在回收垃圾对象时，调用finalize方法
  • 手动回收
    利用 System.gc()通知jvm启动垃圾回收器回收垃圾对象，如果GC空闲，则进行垃圾回收，如果GC繁忙则，暂不回收

    注意：在实际开发时，不要将代码定义在finalize中，忽略此方法。

包装类

简介

• 目的
  让 Object统一管理所有类型的数据
• 包装类概念
  基本数据类型对应的对象类型的类被称为基本数据类型的包装类

基本数据类型对应包装类型

• 包装类都是位于 java.lang中，无需导入包，包装类都被final修饰，没有子类
• 对应关系如下

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

数据类型之间的转换

• int 和 Integer 之间的转换
  • int —> Integer

int a = 12;
Integer i1 = new Integer(a);//利用构造方法
System.out.println(i1);//12：Integer类中覆盖类toString
Integer i2 = Integer.valueOf(a);//Integer类中静态方法

• Integer -> int

int n = i2.intValue();//Integer类中成员方法

• String 和 Integer之间的转换
  • String -> Integer

Integer i3 = new Integer("123");//利构造方法
Integer i4 =Integer.valueOf("123");//Integer类静态方法

• Integer -> String

String s1 = i4.toString();
String s2 = i4+""; //利用字符串拼接

• int 和 String 之间的转换
  • int --> String

int a2 = 32;
String s3 =a2+"";//利用字符串的拼接

• String --> int 【开发应用重点】

String a = 18;
int age = Integer.parseInt(a);//Integer类中静态方法

注意
String转换为 Integer/int时，要求 String中数据必须是纯数值类型，并且不能超过 Integer类型的数据范围，否则编译通过，但是运行报错，错误信息如下：
java.lang.NumberFormatException(数值格式转换异常)

自动的装箱和拆箱

• JDK5.0版本提供了自动装箱和拆箱功能，即：基本数据类型和对应的包装类型之间可以相互转换
• 装箱和拆箱
  • 装箱
    将基本数据类型转换为 对应的包装类型
    Integer i1 = 12; // int ----> Integer
  • 拆箱
    包装类型转换为对应的基本数据类型

Integer i1 = 12;
int a = i1; // Integer ---> int

• 自动装箱的原理分析
  • 自动装箱 时，jvm默认调用 Integer类中的静态方法valueOf(int n)，实现对应 int–>Integer之间的转换
• valueOf方法实现的细节

public static Integer valueOf(int i) {
	if (i >= -128 && i <= 127){
		// 如果 i 在 -128~127之间 ，返回 一个结果
		return IntegerCache.cache[i + (-IntegerCache.low)];
	}
	// 如果 i 不在 -128~127之间
	return new Integer(i);
}
/*
valueOf方法实现的解释：
如果传递的要转换的value数据不在-128~127之间，则通过new Integer(value);方式完成转换；
但是如果 value在-128~127之间的数据，获取的结果来源如下：
*/
private static class IntegerCache {
	static final int low = -128;
	static final int high;
	static final Integer cache[];
	static {
		int h = 127;
		high = h;
		cache = new Integer[(high - low) +1];
		int j = low;
		for(int k = 0; k < cache.length;k++){
			cache[k] = new Integer(j++);
		}
	}
}

• 缓冲区的作用
  Integer对常用数据段 -128~127进行了预先包装处理，包装的结果存储在 常量池(也称为缓冲区)，为了提高 包装的效率，从而也提高jvm内存的空间利用率。
• 面试题目
  分析以下程序打印输出的结果

Integer i1 = 12;
Integer i2 = 12; // 从缓冲区中获取 12 的包装结果
System.out.println(i1==i2);// true
Integer i3 = 255;// new Integer(255)
Integer i4 = 255;// new Integer(255);
System.out.println(i3==i4);//false

包装类的实际开发应用

• 应用场景
  类中属性由 之前的基本数据类型，替换为 对应包装类型
• 应用场景的目的
  是为了区分有效数据和无效数据的，例如：0和null、0.0 和 null 等

String类

String类概述及方法

String类

位于 java.lang 包中，被 final修饰，不能被继 承，即没有子类。

获取字符串的两种方式：【面试题目】

• String s1 = “hello”;

  注意
  用 " "直接获取字符串的形式，直接在串池中查看是否有需要的字符串对象，如果有直接使用，如果没有，在串池中产生一个对象。所以这种获取字符串的方式，产生对象的个数为0~1个

  • String s2 = new String(“world”);

  注意
  使用**new String(“world”);**获取字符串的方式首先会在堆空间中产生一个字符串对象(不管堆空间中是否存包含world内容的字符串对象)；同时会查看串池中是否有此字符串对象，存在，则串池中不需要创建，如果没有，则还需要在串池中产生一个此字符串对象。所以利用这种获取字符串的方式，产生对象的个数：1~2个

  扩充
  String s2 = new String(“world”);
  s2默认指向堆空间中的字符串对象，如果s2.intern()；使用串池中的world字符串对象

String类中常用方法 【字符串的遍历

• char charAt(int index)
  根据下标获取字符串对应字符

注意
String底层 本质为char类型的数组 (char[] value)，所以字符串它的下标范围等价于数组下标范 围：0~> 字符串长度-1。如果指向的下标超出下标范 围，则编译通过，运行报错，错误信息为：
java.lang.StringIndexOutOfBoundsException( 字符 串下标越界)

• int length()
  获取字符串长度

注意
字符串中获取长度是方法：字符串引用名.length()
数组中获取长度：数组名.length

实际开发应用：字符串的遍历
String str = "hello";
for(int i=0;i<str.length();i++){
   char c = str.charAt(i);
   //利用 变量 对 字符串中字符进行操作
  ....
}

• boolean contains(String str)
  判断在当前字符串中是否包含str字符串，包含-true；不包含-false

开发实际应用：做查询时，可以作为过滤条件： String name = "张飞飞";
// 判断名字中是否包含 "飞飞"
if(name.contains("飞飞")){
  // ...
}

• char[] toCharArray()
  将当前字符串转换为char数 组

• boolean equals(Object obj)
  判断两个字符串内容是否相同，String类中完成了对 equals方法的覆盖，直接调 用即可

  注意
  开发时比较字符串的内容，严格使用equals方法比 较。

• boolean equalsIgnoreCase(String str)
  比较两个字 符内容是否相同，忽略大小写，相同-true；不同-false.

String str = "JavaSE";
System.out.println(str.equals("javase"));// false
System.out.println(str.equalsIgnoreCase("jav ase"));//true

• String toUpperCase() ：小写转换为大写
  String toLowerCase()：大写转换为小写

• int indexOf(String str)
  获取str在当前字符串中第一次 出现的首字符的下标，如果没有出现则返回-1.

• int indexOf(String str,int fromIndex)
  从指定位置开始查找str是否在当前字符串中存在，存在则指定下标后面第一次出现的首字符的下标，没有出现，返回-1

• int lastIndexOf(String str)
  获取str在当前字符串中最后一次出现的首字母的下标，如果没有出现则返回-1

• boolean endsWith(String str)
  判断当前字符串是 否 以 str结尾

• String substring(int fromIndex,int toIndex)
  从当 前字符串中截取子串，从 formIndex下标开始截取，截取到toIndex-1下标(下标：包含指定的左下标，不包含右下 标)

• String trim()
  去除当前字符串的前后空格

//实际开发应用场景：结合 String --》 int类型的数据应 用,避免转换时报出：
java.lang.NumberFormatException异常
String str = "38 ";
int age = Integer.parseInt(str.trim());

• String[] split(String str)
  以 str对当前字符串进行拆分，将拆分的结果存储在String数组中，按照拆分的顺序 进行存储

String的不变性 【面试题目】

• S字符串字面值为常量，一旦创建不允许被改变，让其他字符串共享，如果在String字符串上进行操作，会在原文本的基础上拷贝一个副文本，在副文本的基础上完成操作(例如：字符串拼接)
• 由于String是不可变长的字符串，所以在完成拼接时效率较低，同时会造成一些空间的浪费

可变长的字符串 【拼接时优选】

• 常用的可变长字符串(位于java.lang包)

  • StringBuffer
    jdk1.0版本， 线程安全，执行效率慢
  • StringBuilder
    jdk5.0版本，线程不安全，执行效率 快

• 常用的构造方法

  • StringBuilder()
    无参数的构造方法

  • StringBuilder(String str)
    以str创建一个可变长的字符串

• 常用的功能方法

  • append(String str)
    在StringBuilder内容基础上直接拼接str

    注意：通过 toString方法将 StringBuilder转换为String

• 面试题目：写出String、StringBuffer、StringBuilder的区别

  • String
    不可变长的字符串，完成字符串拼接时，效率较低(线程安全)
  • StringBuffer
    线程安全，执行效率较低，可变长的字符串，完成字符串拼接时效率较高
  • StringBuilder
    线程不安全，执行效率高，可变长的字符串，完成字符串拼接时效率较高

public class TestStringBuilder2 {
	public static void main(String[] args) {
	// String str = "";
	// long start =System.currentTimeMillis();
	// for(int i=1;i<=30000;i++) {
	// str +=i;
	// }
	// long end =
	System.currentTimeMillis();
	// System.out.println(end-start);   //1043ms
		StringBuilder s = new
		StringBuilder();
		long start =
		System.currentTimeMillis();
		for(int i=1;i<=30000;i++) {
			s.append(i);
		}
		long end =
		System.currentTimeMillis();
		System.out.println(end-start);// 2ms 
	}
}

BigDecimal 【开发需求决定是否应用-精确度的要求】

• 位置
  java.math 包中
• 作用
  精确表示、计算浮点数
• 常用构造方法
  BigDecimal(String value)：以String形式构造 精准 BigDecimal对象
• 常用的功能方法：

  • BigDecimal r1 = bd1.add(bd2); // bd1+bd2

  • BigDecimal r2 = bd1.subtract(bd2);// bd1-bd2

  • BigDecimal r3 = bd1.multiply(bd2);// bd1*bd2

  • BigDecimal divide(BigDecimal bd1,int scal,RoundingMode mode)
    参数说明：
    第一个参数bd1，代表除数
    第二个参数scal，代表保留到小数点后第几位
    第三个参数mode,代表小数取舍模式，通常使用四舍五入

  • BigDecimal.ROUND_HALF_UP

public class TestBigDecimal {
	public static void main(String[] args) {
		BigDecimal bd1 = new
		BigDecimal("1.0");
		BigDecimal bd2 = new
		BigDecimal("0.9");
		BigDecimal r1 = bd1.add(bd2); // bd1+bd2
		System.out.println("1.0+0.9="+r1);
		
		BigDecimal r2 = bd1.subtract(bd2);// bd1-bd2
		System.out.println("1.0-0.9="+r2);
		
		BigDecimal r3 = bd1.multiply(bd2);// bd1*bd2
		System.out.println("1.0*0.9 = "+r3);
		
		BigDecimal r4 = bd1.divide(bd2,6, BigDecimal.ROUND_HALF_UP);
		System.out.println("1.0/0.9="+r4);
	}
}

---

整理不易，喜欢请点个赞！
编者微信：1014961803，添加时请备注"CSDN"