JAVA基础总结（七）JAVA 常用类总结 （1）

文章目录

• 一、Object 类
• • 1、hashCode()
  • 2、getClass() ，getName() ，toString()
  • 3、equals()
• 二、String类
• • 1、String类的判断功能
  • 2、String类的获取功能
  • 3、String 的转换功能
  • 4、String 的替换功能
  • 5、将 String 两侧的空格去除
• 三、StringBuffer 类
• • 1、StringBuffer 类的构造方法与获取方法
  • 2、StringBuffer 类的添加方法
  • 3、StringBuffer 类的删除方法
  • 4、StringBuffer 类的替换方法
  • 5、StringBuffer 类的反转功能
  • 6、StringBuffer 类的截取功能
  • 7、面试常问的问题

一、Object 类

Object 类简介：

       Object 类是类层次结构的根类，是所有类的超类。在我们创建类的时候，如果不继承指定的类，就会默认继承 Object 类。

Object 类中常用的方法：

1、hashCode()

• public int hashCode()

  • 返回该对象的哈希码值。其值一般是该对象在内存上的地址。

  • 不同的对象在使用 hashCode() 时，返回的哈希码值一般都是不同的。但是，同一个对象使用 hashCode() 时，返回的哈希码值肯定相同。
    
    

  • Demo 代码示例：

    	public class HashCodeDemo {
    	
    	    public static void main(String[] args) {
    	
    	        HashCodeDemo  demo = new HashCodeDemo();
    	        
    	        //hashCode(),返回对象哈希码值
    			  System.out.println("hashCode:"+demo.hashCode());
    	   }
    	}
    

运行结果：

---

2、getClass() ，getName() ，toString()

• public final Class getClass()
  • 当对象调用此方法时，会返回当前对象的真实类（实体）的全名称。
• public String getName()，可以将对象的实体以 String 的形式返回。
  
  
• public String toString()

  • 将对象的返回值转换成字符串。

  • 直接使用对象调用此方法，它的值便等于：getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

  • 注意：直接输出一个对象的名称，其实就是调用该对象的toString()方法。

Demo 代码示例：

public class TestDemo {

    public static void main(String[] args) {

        TestDemo demo = new TestDemo();
        
           System.out.println("返回该对象实体的全名称："+demo.getClass().getName());
           System.out.println("返回该对象实体的全名称，并转换成字符串格式:"+demo.toString());
   }
}

运行结果：

---

3、equals()

• public boolean equals(Object obj)

  • 判断两个对象是否相等。

  • 判断对象的成员变量值是否相同。
    
    

  • Demo 代码示例：

    		public class EqualsDemo {
    		
    		    public static void main(String[] args) {
    		
    		        EqualsDemo demo = new EqualsDemo();
    		        
    		           System.out.println("引用类型的比较："+demo.equals(demo));
    		           System.out.println("基本类型的比较："+"name".equals("sds"));
    		   }
    		}
    

运行结果：

---

二、String类

• String 类简介

       String 类是一个字符串类，字符串是由多个字符组成的一串数据(字符序列)，也可以看成是字符数组。
       注意：字符串是常量，一旦被赋值，就不能被改变。

String类中常用的方法：

1、String类的判断功能

• String类的判断功能
  • boolean equals(Object obj) ：比较字符串的内容是否相同,区分大小写
  • boolean equalsIgnoreCase(String str)：比较字符串的内容是否相同,忽略大小写
  • boolean contains(String str)：判断大字符串中是否包含小字符串
  • boolean startsWith(String str)：判断字符串是否以某个指定的字符串开头
  • boolean endsWith(String str)：判断字符串是否以某个指定的字符串结尾
  • boolean isEmpty()：判断字符串是否为空

Demo代码示例：

public class StringDemo {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1 = "helloworld";
        String s2 = "helloworld";
        String s3 = "HelloWorld";

        // boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
        System.out.println("equals:" + s1.equals(s2));  //true
        System.out.println("equals:" + s1.equals(s3));  //false

        System.out.println("==================================================");  

        // boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        System.out.println("equals:" + s1.equalsIgnoreCase(s2));    //true
        System.out.println("equals:" + s1.equalsIgnoreCase(s3));    //true
        
        System.out.println("==================================================");  

        // boolean contains(String str):判断大字符串中是否包含小字符串
        System.out.println("contains:" + s1.contains("hello")); //true
        System.out.println("contains:" + s1.contains("hw"));    //false

        System.out.println("==================================================");  

        // boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
        System.out.println("startsWith:" + s1.startsWith("h"));     //true
        System.out.println("startsWith:" + s1.startsWith("hello")); //true
        System.out.println("startsWith:" + s1.startsWith("world")); //false

        System.out.println("==================================================");  

        // 练习：boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
        System.out.println("endsWith:" + s1.endsWith("o"));     //false
        System.out.println("endsWith:" + s1.endsWith("d"));     //true
      
        System.out.println("==================================================");  

        // boolean isEmpty():判断字符串是否为空。
        System.out.println("isEmpty:" + s1.isEmpty());  //false

        String s4 = "";
        String s5 = null;
        System.out.println("isEmpty:" + s4.isEmpty());//true
        System.out.println("isEmpty:" + s4.isEmpty(s5));//false
        // NullPointerException
        // s5对象都不存在，所以不能调用方法，空指针异常
        System.out.println("isEmpty:" + s5.isEmpty());
    }
}

---

2、String类的获取功能

• String类的获取功能
  • int length()：获取字符串的长度。
  • char charAt(int index):获取指定索引位置的字符
  • int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
  • int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
  • int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
  • int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
  • String substring(int start):从指定位置开始截取字符串,默认到末尾。
  • String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。

Demo代码示例：

public class StringDemo {
    public static void main(String[] args) {
        // 定义一个字符串对象
        String s = "helloworld";

        // int length():获取字符串的长度。
        System.out.println("s.length:" + s.length());//10

        // char charAt(int index):获取指定索引位置的字符
        System.out.println("charAt:" + s.charAt(7));//r

        // int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
        System.out.println("indexOf:" + s.indexOf('l'));    //2

        // int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
        System.out.println("indexOf:" + s.indexOf("owo"));  //4

        // int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
        System.out.println("indexOf:" + s.indexOf('l', 4));         //  8
        System.out.println("indexOf:" + s.indexOf('k', 4)); // -1
        System.out.println("indexOf:" + s.indexOf('l', 40)); // -1

        // int indexOf(String str,intfromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
        System.out.println("indexOf:" + s.indexOf('o', 1)); //4

        // String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
        System.out.println("substring:" + s.substring(5));//world
        System.out.println("substring:" + s.substring(0));//helloworld

        // String substring(int start,int
        // end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引
        System.out.println("substring:" + s.substring(3, 8)); //loworl
        System.out.println("substring:" + s.substring(0, s.length()));//helloworld
    }
}

3、String 的转换功能

• String 的转换功能
  • byte[] getBytes():把字符串转换为字节数组
  • char[] toCharArray():把字符串转换为字符数组
  • static String valueOf(char[] chs):把字符数组转成字符串
  • static String valueOf(int i):把int类型的数据转成字符串
  • String类的valueOf方法可以把任意类型的数据转成字符串
  • String toLowerCase():把字符串转成小写
  • String toUpperCase():把字符串转成大写
  • String concat(String str):把字符串拼接

Demo 代码示例：

public class StringDemo {
    public static void main(String[] args) {
        // 定义一个字符串对象
        String s = "JavaSE";

        // byte[] getBytes():把字符串转换为字节数组。
        byte[] bys = s.getBytes();
        for (int x = 0; x < bys.length; x++) {
            System.out.println(bys[x]);
        }
        System.out.println("----------------");

        // char[] toCharArray():把字符串转换为字符数组。
        char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }
        System.out.println("----------------");

        // static String valueOf(char[] chs):把字符数组转成字符串。
        String ss = String.valueOf(chs);
        System.out.println(ss);
        System.out.println("----------------");

        // static String valueOf(int i):把int类型的数据转成字符串。
        int i = 100;
        String sss = String.valueOf(i);
        System.out.println(sss);
        System.out.println("----------------");

        // String toLowerCase():把字符串转成小写。
        System.out.println("toLowerCase:" + s.toLowerCase());
        System.out.println("s:" + s);
        // System.out.println("----------------");
        // String toUpperCase():把字符串转成大写。
        System.out.println("toUpperCase:" + s.toUpperCase());
        System.out.println("----------------");

        // String concat(String str):把字符串拼接。
        String s1 = "hello";
        String s2 = "world";
        String s3 = s1 + s2;
        String s4 = s1.concat(s2);
        System.out.println("s3:"+s3);
        System.out.println("s4:"+s4);
    }
}

运行结果：

---

4、String 的替换功能

• 替换功能：
  • String replace(char old,char new):替换指定的单个字符
  • String replace(String old,String new)：替换指定的字符串

Demo代码示例：

public class StringDemo {
    public static void main(String[] args) {

 // 替换功能
        String s1 = "helloworld";
        String s2 = s1.replace('l', 'k');
        String s3 = s1.replace("owo", "ak47");
        System.out.println("s1:" + s1);//s1:helloworld
        System.out.println("s2:" + s2);//s2:hekkoworkd
        System.out.println("s3:" + s3);//s3:hellak47rld

	}
}

---

5、将 String 两侧的空格去除

• 去除字符串两空格
  • String trim()

Demo代码示例：

public class StringDemo {
    public static void main(String[] args) {

  // 去除字符串两空格
        String s4 = "  hello world  ";
        String s5 = s4.trim();
        System.out.println("s4:" + s4 + "---");//s4:  hello world  ---
        System.out.println("s5:" + s5 + "---");//s5:hello world---
	}
}

---

三、StringBuffer 类

StringBuffer 类简介：

        我们在日常开发中字符串可谓是随处可见，我们需要将字符串进行各种拼接，更改等操作，以此来获得我们所需要的字符串。但是字符串本身是不可改变的，所有在进行相关操作时，其实都会在原本字符串的基础之上重新创建字符串对象，这无疑会给内存造成更大的压力。而使用StringBuffer便可以很好的解决这个问题。

        还有一个类和 StringBuffer 的功能相同，这便是StringBuilder 类。这两个类的区别是 ： StringBuffer是同步的，数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高。StringBuilder类了解一些即可，通常都使用StringBuffer 来操作字符串

1、StringBuffer 类的构造方法与获取方法

• StringBuffer的构造方法：
  • public StringBuffer():无参构造方法
  • public StringBuffer(int capacity):指定字符串对象在缓存区的容量
  • public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
    
    
• StringBuffer 的获取方法
  • public int capacity()：获取字符串对象的容量。(如果不自定义设置字符串缓存区容量，初始化默认容量是便是 16)。
  • public int length():返回字符串长度。

Demo代码示例：

public class StringBufferDemo {

    public static void main(String[] args) {
    
        // public StringBuffer():无参构造方法	
        StringBuffer sb = new StringBuffer();
        System.out.println("sb:" + sb);     
        //capacity()，获取字符串对象的容量
        System.out.println("sb.capacity():" + sb.capacity());
        System.out.println("sb.length():" + sb.length());

        System.out.println("==============================================");

        // public StringBuffer(int capacity):指定容量的字符串缓冲区对象
        StringBuffer sb2 = new StringBuffer(50);
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.capacity():" + sb2.capacity());
        System.out.println("sb2.length():" + sb2.length());
       
        System.out.println("==============================================");

        // public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
        StringBuffer sb3 = new StringBuffer("hello");
        System.out.println("sb3:" + sb3);
        System.out.println("sb3.capacity():" + sb3.capacity());
        System.out.println("sb3.length():" + sb3.length());
    }
}

运行结果：

---

2、StringBuffer 类的添加方法

• 添加功能
  • public StringBuffer append(String str)：可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身
  • public StringBuffer insert(int offset,String str)：在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

Demo代码示例:

public class StringBufferDemo {
    public static void main(String[] args) {
        // 创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer();

        // 添加数据
        sb.append("hello");
        sb.append(true);
        sb.append(12);
        sb.append(34.56);

        // 上面的添加数据我们可以用链式编程开表示。你会发现结果是相同的
    //sb.append("hello").append(true).append(12).append(34.56);
        System.out.println("sb:" + sb);

        //在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
        sb.insert(5, "world");
        System.out.println("sb:" + sb);
    }
}

运行结果：

---

3、StringBuffer 类的删除方法

• public StringBuffer deleteCharAt(int index)：删除指定位置的字符，并以String的形式返回缓存区的字符串对象本身
• public StringBuffer delete(int start,int end)：删除从指定位置开始指定位置结束的内容，并以String的形式返回缓存区的字符串对象本身

注：在使用字符串删除方法之前，在字符串缓存区中必须得有字符串的存在（和数组下标类似，在执行删除方法时，找不到指定下标的字符或者指定下标范围的字符串，便会报错。）

Demo代码示例:

public class StringBufferDemo {

    public static void main(String[] args) {
    
 			   // 创建字符串缓冲区对象
                StringBuffer sb = new StringBuffer();
                // 先在字符串缓存区中添加一些数据
                sb.append("A");//下标：0
                sb.append("B");//下标：1
                sb.append("C");//下标：2
                sb.append("D");//下标：3
                sb.append("E");//下标：4
                sb.append("F");//下标：5
                sb.append("G");//下标：6
                System.out.println("sb1:" + sb); //打印结果：sb1:ABCDEFG

                // 删除指定下标的字符，并返还字符串本身
                sb.deleteCharAt(1);
                System.out.println("sb2:" + sb); //打印结果：sb2:ACDEFG
                // 我们要删除world这个字符串，肿么办?
                sb.delete(3, 5);
                System.out.println("sb3:" + sb); //打印结果：sb3:ACDG
                // 需求:我要删除所有的数据
                 sb.delete(0, sb.length());
                System.out.println("sb4:" + sb); //打印结果：sb4:
    }
}

---

4、StringBuffer 类的替换方法

• public StringBuffer replace(int start,int end,String str)：根据下标去指定字符串范围，将该范围的字符串替换成所需的字符串。start 代表下标初始范围，end 代表下标结束范围，str 所指定的字符串会将 start 和 end 指定范围的的字符串进行替换。
  
  

Demo代码示例:

public class StringBufferDemo {

    public static void main(String[] args) {
    
 			   // 创建字符串缓冲区对象
                StringBuffer sb = new StringBuffer();
                // 先在字符串缓存区中添加一些数据
                sb.append("A");//下标：0
                sb.append("B");//下标：1
                sb.append("C");//下标：2
                sb.append("D");//下标：3
                sb.append("E");//下标：4
                sb.append("F");//下标：5
                sb.append("G");//下标：6
                System.out.println("sb1:" + sb); //打印结果：sb1:ABCDEFG

		       // 需求：我要把world这个数据替换为"洪荒之力"
		        sb.replace(1, 4, "bcd");
		        System.out.println("sb2:" + sb);
    }
}

---

5、StringBuffer 类的反转功能

• public StringBuffer reverse()

Demo代码示例:

public class StringBufferDemo {

    public static void main(String[] args) {
    
 			   // 创建字符串缓冲区对象
                StringBuffer sb = new StringBuffer();
                // 先在字符串缓存区中添加一些数据
                sb.append("A");//下标：0
                sb.append("B");//下标：1
                sb.append("C");//下标：2
                sb.append("D");//下标：3
                sb.append("E");//下标：4
                sb.append("F");//下标：5
                sb.append("G");//下标：6
                System.out.println("sb1:" + sb); //打印结果：sb1:ABCDEFG

		        // 两极反转！！！
                sb.reverse();
                System.out.println("sb2:" + sb);//sb2:GFEDBCA
    }
}

---

6、StringBuffer 类的截取功能

• public String substring(int start)：设置指定结束下标，默认从0下标开始截取，将指定下标往后的字符串保留，删除从 0 至结束下标范围的字符串。
  • public String substring(int start,int end)：start 代表开始下标范围，end 代表结束下标范围。只保留指定范围的字符串，其他下标范围字符全部清空。

Demo代码示例:

public class StringBufferDemo {

    public static void main(String[] args) {
    
 			  // 创建字符串缓冲区对象
                StringBuffer sb1 = new StringBuffer();

                // 在字符串缓存区中添加一些字符串
                sb1.append("A");//下标：0
                sb1.append("B");//下标：1
                sb1.append("C");//下标：2
                sb1.append("D");//下标：3
                sb1.append("E");//下标：4
                sb1.append("F");//下标：5
                sb1.append("G");//下标：6
                System.out.println("sb1:" + sb1);//sb1:ABCDEFG

                //设置指定结束下标，默认从0下标开始截取，将指定下标往后的字符串保留，删除从 0 至结束下标范围的字符串。
                String str1 = sb1.substring(1);
                System.out.println("str1:" + str1);//str1:BCDEFG

                      System.out.println("===========================");

                StringBuffer sb2 = new StringBuffer();

                // 在字符串缓存区中添加一些字符串
                sb2.append("A");//下标：0
                sb2.append("B");//下标：1
                sb2.append("C");//下标：2
                sb2.append("D");//下标：3
                sb2.append("E");//下标：4
                sb2.append("F");//下标：5
                sb2.append("G");//下标：6
                System.out.println("sb2:" + sb2);//sb1:ABCDEFG
                //start 代表开始下标范围，end 代表结束下标范围。只保留指定范围的字符串，其他下标范围字符全部清空。
                String str2 = sb1.substring(1,4);
                System.out.println("str2:" + str2);//str2:BCD

    }
}

运行结果：

---

7、面试常问的问题

• String 和 StringBuffer 之间的相互转换

public class StringBufferTest {
    public static void main(String[] args) {
        // String 转换 StringBuffer
        String s = "hello";
        // 注意：不能把字符串的值直接赋值给StringBuffer
        // StringBuffer sb = "hello";
        // StringBuffer sb = s;
        // 方式1:通过构造方法
        StringBuffer sb = new StringBuffer(s);
        // 方式2：通过append()方法
        StringBuffer sb2 = new StringBuffer();
        sb2.append(s);
        System.out.println("sb:" + sb);//sb:hello
        System.out.println("sb2:" + sb2);//sb2:hello

        // StringBuffer转换 String
        StringBuffer buffer = new StringBuffer("java");
        // String(StringBuffer buffer)
        // 方式1:通过构造方法
        String str = new String(buffer);
        // 方式2：通过toString()方法
        String str2 = buffer.toString();
        System.out.println("str:" + str);//str:java
        System.out.println("str2:" + str2);//str2:java
    }
}