常用类

Java中的常用类

对前两天做个总结。感兴趣的伙伴可以看看哦

一、Object类

1. 概念：Object类是所有类的父类/基类/超类
2. 特点：
   1. Object类的引用中可以存储任何类型的对象 Object o = new …
   2. Object类中的方法被所有类默认继承
3. 常用方法：

   1. getClass()

      1. 返回：返回该对象运行时的实际类型
      2. 作用：判断对象的实际类型

      package com.baizhi.TestObject;
      
      public class TestObject {
      	public static void main(String[] args) {
      		Animal a1 = new Animal();
      		Animal a2 = new Animal();
              //判断a1和a2对象的实际类型是否一致
      		System.out.println(a1.getClass() == a2.getClass());
      	}
      }
      class Animal{}
      

   2. hashCode()

      1. 返回：返回该对象的十进制数值表达形式
      2. 作用：提高使用到hashCode方法的集合的运行效率

      package com.baizhi.TestObject;
      
      public class TestObject {
      	public static void main(String[] args) {
      		Animal a1 = new Animal();
      		System.out.println(a1.hashCode());
      	}
      }
      class Animal{}
      

   3. equals()

      1. 返回：返回一个布尔值

      2. 作用：对比两个对象的内容是否相同

      3. 注意：

         1. Object类中默认对比两个对象的地址是否相同

            package com.baizhi.TestObject;
            
            public class TestObject {
            	public static void main(String[] args) {
            		Person p1 = new Person("zhangs",30);
            		Person p2 = new Person("zhangs",30);
            		System.out.println(p1.equals(p2));//结果为false
            	}
            }
            class Person{
            	public String name;
            	public int age;
            	public Person(String name, int age) {
            		super();
            		this.name = name;
            		this.age = age;
            	}
            	public Person() {
            		super();
            	}
            }
            

         2. 子类需要覆盖本方法

      4. 覆盖原则：根据业务要求对对象中的属性进行对比

      5. 覆盖步骤：

         1. 对比两个对象是相同的对象
         2. 判断参数对象是否为null值
         3. 判断两个对象的实际类型是否一致
         4. 将参数对象强制类型转换为当前类型
         5. 根据业务需要进行属性的对比

         	@Override
         	public boolean equals(Object o) {
         //		1.对比两个对象是相同的对象
         		if(this == o) return true;
         //		2. 判断参数对象是否为null值
         		if(o == null) return false;
         //		3. 判断两个对象的实际类型是否一致
         		if(this.getClass() != o.getClass()) return false;
         //		4. 将参数对象强制类型转换为当前类型
         		Person p = (Person)o;
         //		5. 根据业务需要进行属性的对比
         		if(p.name.equals(this.name) && p.age == this.age) return true;
         		return false;
         	}
         

      6. equals和==的区别：

         1. ==号
            1. 基本数据类型：对比两端的数值是否一致
            2. 引用数据类型：对比两端的地址是否一致
         2. equals：只能应用于引用数据类型
            1. Object类中该方法用于对比两个对象的地址是否一致，作用和==一样
            2. 通常使用的时候会被子类覆盖，用于根据业务需要对比对象属性的值是否一致

   4. toString()

      1. 返回：返回该对象的字符串形式表达(String类型)

      2. 作用：用于展示对象的内容

      3. 注意：

         1. Object类中默认返回对象的地址信息，即全限定名和十六进制地址的形式
         2. 子类需要覆盖本方法

      4. 覆盖原则：根据业务需要将属性以字符拼接的形式进行返回

         @Override
         	public String toString() {
         		return "name=" + name + ", age=" + age;
         	}
         

   5. finalize()

      1. 作用：在对象被回收的时候被虚拟机调用
      2. 注意：
         1. 由于垃圾回收时机不确定，所以不建议将资源释放的代码写在finalize方法中
         2. System.gc();语句仅声明垃圾回收器的启动，并不能决定是否启动成功

      package com.baizhi.TestObject;
      
      public class TestObject {
      	public static void main(String[] args) {
      		while(true) {
      			new Person();
      		}
      	}
      }
      class Person{
      	public static int count = 0;
      
      	public Person() {
      		count++;
      		System.out.println("第" + count + "个对象被创建");
      	}
      
      	@Override
      	protected void finalize() throws Throwable {
      		System.out.println("第" + count + "个对象被回收");
      		count--;
      		super.finalize();
      	}
      }
      

二、String类

1. 特点：字符串是不可变的：字符串是常量，存储位置在方法区的运行时常量池中，也称串池

2. 重点区分：

   1. String s = “abc”; 只会产生一个对象
      1. 如果常量池中没有该对象，则创建一个对象放入常量池中
      2. 如果常量池中有这个对象，则直接引用这个对象
   2. String s = new String(“abc”); 会产生两个对象
      1. 先在常量池中创建该字符串对象
      2. 然后以这个对象作为参数，在堆内存中创建一个对象

3. 常用方法：

   1. public char charAt(int index):返回对应下标位置的字符

      String s = "zhangs";
      char c = s.charAt(1);//返回下标为1的字符，即'h'
      

   2. public int compareTo(String anotherString)：字符串的字典排序

      String s1 = "zhangs";
      String s2 = "zhnags";
      System.out.println(s1.compareTo(s2));
      

   3. public boolean contains(String s):检查字符串中是否包含某个子串

      String s1 = "zhangs";
      String s2 = "ha";
      System.out.println(s1.concat(s2));//true
      

   4. public boolean startsWith(String prefix) 和 public boolean endsWith(String suffix)：检查字符串是否以某个子串为开头或者结尾

      String s1 = "com.zhangs.avi";
      System.out.println(s1.startsWith("com"));//true
      System.out.println(s1.endsWith(".avi"));//true
      

   5. public boolean equals(Object anObject)：对比参数对象与字符串是否相同，通常用来对比两个字符串的内容是否完全一致，此处会区分大小写

      String s1 = "zhangs";
      String s2 = "zhangs";
      System.out.println(s1.equals(s2));
      

   6. public int indexOf(int ch)：返回参数字符或者子串第一次出现在字符串中的下标位置，如果没有则返回-1

      String s1 = "zhangs";
      System.out.println(s1.indexOf('a'));//2
      

   7. public int lastIndexOf(int ch)：返回参数字符或者子串最后一次出现在字符串中的下标位置，如果没有则返回-1

      String s1 = "zhangsa";
      System.out.println(s1.lastIndexOf('a'));//6
      

   8. public int length()：返回字符串的长度

      String s1 = "zhangs";
      System.out.println(s1.length());//6
      

   9. public String replace(char oldChar, char newChar)：将字符串中所有的旧字符替换为新字符

      String s1 = "zhangs";
      String s2 = s1.replace('a', 'b');
      System.out.println(s2);//zhbngs
      

   10. public String[] split(String regex)：将字符串按照某个子串进行分割，分割之后移除这个子串

       String s1 = "zhangs";
       String[] ss = s1.split("a");
       for (int i = 0; i < ss.length; i++) {
       	System.out.println(ss[i]);
       }
       //zh
       //ngs
       

   11. public String substring(int beginIndex,int endIndex)：根据下标获取字符串的子串，包含起点下标，不包含终点下标

       String s1 = "zhangs";
       String s2 = s1.substring(2, 4);
       System.out.println(s2);//an
       

   12. public char[] toCharArray()：返回字符串的字符数组形式

       String s1 = "zhangs";
       char[] cs = s1.toCharArray();
       

   13. public String toUpperCase() 和 public String toLowerCase()：返回字符串的纯大写或者纯小写格式

       String s1 = "ZhAngs";
       String s2 = s1.toUpperCase();//ZHANGS
       String s3 = s2.toLowerCase();//zhangs
       

   14. public String trim()：返回字符串删除过前后空格的子串，不会删除字符串中间的空格

       String s1 = "     zhangs    ";
       String s2 = s1.trim();//zhangs
       

4. 可变长字符串

   1. StringBuffer：JDK1.0版本，线程安全，效率低

   2. StringBuilder:JDK1.2版本，线程不安全，效率高

   3. 常用方法：

      1. append():在可变长字符串的结尾追加
      2. toString()：将可变长字符串转换为字符串

      package com.baizhi.test;
      
      public class TestString {
      	public static void main(String[] args) {
      		String s = "zhangs";
      //		创建可变长字符串
      //		StringBuilder sb = new StringBuilder();
      		StringBuffer sb = new StringBuffer(s);
      //		向结尾追加
      		sb.append("250");
      //		将可变长字符串转换为字符串
      		String ss = sb.toString();
      		System.out.println(ss);
      	}
      }
      

三、包装类

1. 概念：基本数据类型对应的引用数据类型

2. 作用：可以将数据交由Object进行统一管理

3. 对应关系

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

4. 基本数据类型与包装类之间的转换

   1. 基本数据 ----> 包装对象

      //使用构造方法创建
      Integer i1 = new Integer(10);
      //使用静态方法创建
      Integer i2 = Integer.valueOf(10);
      

   2. 包装对象 ----> 基本数据

      Integer i1 = new Integer(10);
      //使用包装类中的成员方法
      int i2 = i1.intValue();
      

   3. 基本数据 ----> 字符串

      //使用字符串拼接(拼接空串)
      String s1 = 10 + "";
      //使用String的静态方法
      String s2 = String.valueOf(10);
      

   4. 字符串 ----> 基本数据

      //使用包装类中的静态方法
      int i = Integer.parseInt("10");
      

      注意：要求该字符串必须是由纯数字构成，否则会出现“数字格式转换异常”(java.lang.NumberFormatException)

   5. 包装对象 ----> 字符串

      //使用字符串拼接(拼接空串)
      String s = 14 + "";
      

   6. 字符串 ----> 包装对象

      //使用构造方法创建
      Integer i1 = new Integer("10");
      //使用静态方法创建
      Integer i2 = Integer.valueOf("10");
      

5. 自动的装箱、拆箱

   1. 将基本的数据类型转换成包装类型的过程称为装箱
   2. 将包装类型转换成基本的数据类型的过程称为拆箱
   3. JDK1.5之后： 包装类型和基本数据类型之间自动转换，称为自动装箱、拆箱。

6. 缓存区

   Java为了提高效率，将Integer类型 -128~127 之间的数据做了包装，放在常量池中

   package com.baizhi.test;
   
   public class Test {
   	public static void main(String[] args) {
   		Integer i1 = 100;
   		Integer i2 = 100;
   		System.out.println(i1 == i2);//true
   		
   		Integer i3 = new Integer(100);
   		Integer i4 = new Integer(100);
   		System.out.println(i3 == i4);//false
   	}
   }