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

文章目录

一、内部类
- 1.成员内部类（非静态内部类）
- 2.局部内部类
- 3.静态内部类
二、Object 类
- 1、hashCode()
- 2、getClass() ，getName() ，toString()
- 3、equals()
三、包装类
四、数学类
五、日期时间类
- 1、时间戳
- 2、Date 类和 SimpleDateFormat 类
- 4、计算时间差
六、String类
- 1、String类的判断功能
- 2、String类的获取功能
- 3、String 的转换功能
- 4、String 的替换功能
- 5、将 String 两侧的空格去除
七、StringBuffer 类和 StringBuilder 类
- 1、StringBuffer 类的构造方法与获取方法
- 2、StringBuffer 类的添加方法
- 3、StringBuffer 类的删除方法
- 4、StringBuffer 类的替换方法
- 5、StringBuffer 类的反转功能
- 6、StringBuffer 类的截取功能
- 7、面试常问的问题

一、内部类

内部类简介：

概念：在一个类内部再定义一个完整的类。
一般情况下类与类之间是相互独立的，内部类的意思就是打破这种独立思想，让一个类成为另一个类的内部信息，和成员变量、成员方法同等级别。

内部类的好处：
- 采用内部类这种技术，可以隐藏实现细节和内部结构，封装性更好，让程序的结构更加合理！如果类很多且都暴露在外面，那么类与类之间的调用就会十分繁琐！

1.成员内部类（非静态内部类）

Demo 代码示例：

	// 外部类
	public  class OuterClass {
	
	    //成员变量
	    private String OuterName; // 没赋值，默认为null
	
	    //成员方法
	    public void OuterDisplay(){
	        System.out.println("这是外部类方法！");
	        System.out.println(OuterName);
	    }
	
	    //内部类，在外部类的里面定义
	    public class InnerClass{
	
	        //成员变量
	        private String InnerNme;
	
	        //构造方法
	        public InnerClass() {
	            InnerNme = "Inner Class";  // 给内部类成员变量赋值
	        }
	
	        //成员方法
	        public void InnerDisplay(){
	            System.out.println("这是内部类方法！");
	            System.out.println(InnerNme);
	
	        }
	    }
	
	    // 主方法
	    public static void main(String[] args) {
	
	        //创建外部类的类对象
	        OuterClass outerClass = new OuterClass();
	
	        //通过外部类类对象调用外部类的成员方法
	        outerClass.OuterDisplay();//这是外部类方法！ null
	
	        // 这个类是内部类，已经不是独立的类了，因此不能像外部类一样直接创建！
	        //InnerClass innerClass = new InnerClass(); 行不通
	        //外部类.内部类  内部类对象名 = 外部类对象.new 内部类构造方法();用外部类.内部类的形式创建对象便可以了
	        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
	        innerClass.InnerDisplay();// 这是内部类方法！  Inner Class
	    }
	}

输出结果：

		这是外部类方法！
		null
		这是内部类方法！
		Inner Class

总结：成员内部类（非静态内部类）的使用就是将内部类作为外部类的一个成员变量/成员方法来使用，所以必须依赖于外部类的对象才能调用，用法和成员变量/成员方法一致！

2.局部内部类

局部内部类：基本的内部类还可以在一个方法体中定义。

Demo 代码示例：

				public class OuterClass {
				    //成员变量
				    private String OuterName;
				    //成员方法
				    public void display(){
				        class InnerClass {
				            public void print(){
				                System.out.println("这是一个局部内部类方法！");
				            }
				        }
				        InnerClass innerClass = new InnerClass();
				        innerClass.print();
				    }
				
				    // 主方法
				    public static void main(String[] args) {
				        OuterClass outerClass = new OuterClass();
				        outerClass.display();
				    }
				}

3.静态内部类

静态内部类的构造不需要依赖于外部类对象，类中的静态组件都不需要依赖于任何对象，可以直接通过类本身进行构造。

Demo 代码示例：

			package NeiBuLei;
			
			public class OuterClass {
			    //成员变量
			    private String OuterName;
			    //成员方法
			    public void display(){
			        System.out.println("这是外部类方法！");
			        System.out.println(OuterName);
			    }
			    //静态内部类
			    public static class InnerClass{
			        private String InnerName;
			
			        public InnerClass() {
			            InnerName = "Inner Class";
			        }
			
			        //成员方法
			        public void display(){
			            System.out.println("这是静态内部类方法！");
			            System.out.println(InnerName);
			        }
			    }
	
				    // 主方法
				    public static void main(String[] args) {
				        OuterClass outerClass = new OuterClass();
				        outerClass.display();
				        // 静态内部类的构造不依赖与外部类，可以直接通过类本身进行构造！
				        InnerClass innerClass = new InnerClass();
				        innerClass.display();
				    }
				
				}

输出结果：

		这是外部类方法！
		null
		这是静态内部类方法！
		Inner Class

二、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"));
			   }
			}

运行结果：

三、包装类

1.基本数据类型以及对应的包装类：
- byte -> Byte
- short -> Short
- int -> Integer
- long -> Long
- float -> Float
- double -> Double
- char -> Character
- boolean -> Boolean

注：这些类都在java.lang包，且在此包下的类在使用时不需要引包，直接使用即可。

2.包装类的意义：
- 让基本数据类型有面向对象的特征
- 封装了字符串转化成基本数据类型的方法（重点）

3.包装类常用方法：
- Integer.parseInt() : 将 String 类型的数字转换成 int 类型
- Long.paseLong()：将字符串类型转换成 Long 类型
- Double.parseDouble()：将字符串类型转换成 double 类型

Demo代码示例：

	public class Test {
	    public static void main(String[] args) {
	       
	        String a = "12";
	        String b = "34";
	        System.out.println(a+b); // 1234
	    // 转型:parseInt() 
	        // 字符串转成int的唯一方案
	        int c = Integer.parseInt(a);
	        int d = Integer.parseInt(b);
	        System.out.println(c+d); // 46
	        
	        // 字符串转成double类型：paseLong()
	        String e = "1.25";
	        double f = Double.parseDouble(e);
	        System.out.println(f*6); // 7.5
	
	        // 转成long类型：paseLong()
	        long l = Long.parseLong("1234567");
	        System.out.println(l);
	    }
	}

四、数学类

数学类的方法都是静态方法，可以直接引用——Math.方法();
- 常用数学类方法：

方法说明

方法	说明
abs(数字类型 a)	返回 a 的绝对值
max(数字类型 x,数字类型 y)	返回 x 和 y 中的最大值
min(数字类型 x,数字类型 y)	返回 x 和 y 中的最小值
pow(数字类型 a,数字类型 b)	求次幂
round()	四舍五入
sqrt()	求平方根

五、日期时间类 1、时间戳

时间戳：当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
- java.lang.System 类：此方法适于计算时间差
  - 这个类我们用的最多的就是 currentTimeMillis() 方法，返回值是long型，获取系统当前时间的时间戳。

Demo代码示例：

		long timeMillis = System.currentTimeMillis();
		      System.out.println(timeMillis);

2、Date 类和 SimpleDateFormat 类

java.util.Date类：表示特定的瞬间，精确到毫秒
- 构造方法
  - 1）Date() 使用无参构造器创建的对象可以获取本地当前时间
  - 2）Date(long date) 传入时间戳，获取指定时间戳对应的 Date 对象
- 成员方法
  - 1）getTime() 返回当前时间的时间戳
  - 2）toString() 把Date对象转换为以下形式的String：dow mon dd hh:mm:ss zzz yyy （dow是一周中的某一天 Sun、Mon、Tue、Wed、Thu、Fri、Sat；zzz是时间标准）。
java.text.SimpleDateFormat类格式化时间类
- 成员方法
  - format(Date) 帮我们把时间转成字符串，字符串的格式为SimpleDateFormat类定义对象时设置的时间格式
  - parse(String) 帮我们把字符串转化成时间

Demo代码示例：

public class Test {
    public static void main(String[] args) {
      //时间类Date获取系统当前时间的方法
        Date date = new Date();

		// getTime()方法返回的是时间戳
		long time = date.getTime();
		
		        System.out.println("时间戳------>"+time );

		
    		    System.out.println("当前的日期是------>"+date);
		        // 当前的日期是------>Tue Jun 28 16:49:29 CST 2022
		        //系统时间格式，与我们实际使用的时间格式不一致，需要将其转换成实际使用的时间格式。

        SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

			//把时间转换成字符串
        	System.out.println("格式化后的时间------->"+format.format(date));
     
        //把字符串转换成时间
        Date d =  sdf.parse(s); 
        
     		   System.out.println(d);
          
    }
}

注：由于用户输入的字符串不一定是我们要求的格式，可能是任何东西，想把它们转成时间是不可能的，你不可能把一个人转成时间对吧，因此存在着很大的风险未处理(异常: java.text.ParseException)，为此我们需要处理异常。

4、计算时间差

计算思路：
- 格式化时间
- 先将字符串转化成long类型时间
- 计算毫秒级别时间差，取绝对值
- 毫秒级别时间差转成秒级别
- 秒级别时间差转成分钟级别
- 分钟级别时间差转化显示成xx小时xx分钟

Demo代码示例：

package Simple;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDiff {
    public static void main(String[] args) throws ParseException {

        String s1 = "2021-08-12 12:00:00"; // 开始时间
        String s2 = "2021-08-12 14:35:00"; // 结束时间

        //格式化时间
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");

        //将字符串转成时间形式
        Date d1 = sdf.parse(s1);
        Date d2 = sdf.parse(s2);

        //计算时间差:先要获取时间毫秒形式（long类型） 再做差
        long long1 = d1.getTime();
        long long2 = d2.getTime();
        long diffTime = Math.abs(long1 - long2);

        // 秒级别时间差
        long diffSec = diffTime / 1000;

        // 分级别时间差
        long diffMin = diffSec / 60;

        //显示 xx小时xx分钟
        long displayHours = diffMin / 60; // 小时
        long displayMin = diffMin % 60; //分钟

        System.out.println("您学习的时长为："+displayHours+"小时"+displayMin+"分钟");

    }
}

六、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 类和 StringBuilder 类

StringBuffer 类简介：

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

还有一个类和 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
    }
}

2、String和StringBuff和StringBuilder区别？
- String：不可变序列
- StringBuffer：可变序列，多线程，安全
- StringBuilder：可变序列，单线程，不安全
3、StringBuffer和数组的区别？
- 都是容器，可以用来存数据但是数组只能存一种数据，但是StringBuffer可以存很多种类型数据，不过最终结果都是字符串数据

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

Java相关栏目本月热门文章