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

妖狐艹你老母 2023-10-07 12:21 2阅读 0赞

#### Java常用类 ####

*   *   *  Object类
         *   *  Object类的认识
             *  Object类中常用的方法
             *   *  getClass()
                 *  string toString()
                 *  int hashCode()
                 *  boolean equals(Object obj)
                 *  void finalize()
         *  包装类
         *   *  简介
             *  基本数据类型对应包装类型
             *  数据类型之间的转换
             *  自动的装箱和拆箱
             *  包装类的实际开发应用
         *  String类
         *   *  String类概述及方法
             *   *  String类
                 *  获取字符串的两种方式：【面试题目】
                 *  String类中常用方法 【字符串的遍历
                 *  String的不变性 【面试题目】
             *  可变长的字符串 【拼接时优选】
             *  BigDecimal 【开发需求决定是否应用-精确度的要求】

#### 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修饰，没有子类
 *  对应关系如下

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>包装类类名</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

##### 数据类型之间的转换 #####

*  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 包中，被 ﬁnal修饰，不能被继 承，即没有子类。

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

*  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**包)
    
     *  **StringBuﬀer**  
        jdk1.0版本， 线程安全，执行效率慢
     *  **StringBuilder**  
        jdk5.0版本，线程不安全，执行效率 快
 *  常用的构造方法
    
     *  **StringBuilder()**  
        无参数的构造方法
     *  **StringBuilder(String str)**  
        以str创建一个可变长的字符串
 *  常用的功能方法
    
     *  **append(String str)**  
        在StringBuilder内容基础上直接拼接str
        
        > 注意：通过 toString方法将 StringBuilder转换为String
 *  **面试题目：写出String、StringBuﬀer、StringBuilder的区别**
    
     *  **String**  
        不可变长的字符串，完成字符串拼接时，效率较低(线程安全)
     *  **StringBuﬀer**  
        线程安全，执行效率较低，可变长的字符串，完成字符串拼接时效率较高
     *  **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);
    	}
    }

--------------------