目录

1.API

•API(Application Programming Interface)应用程序编程接口

•是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明.

广义上,API就是java语言中提供的类,接口;

实际上,指的是使用的对类、接口功能的说明文档。

2.基础数据类型包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的;

设计类时为每个基本数据类型设计了一个对应的类进行代表;

在这里插入图片描述

以Integer类为例进行学习;

2.1 Integer类中的常用方法

(1)几个简单的方法;

在这里插入图片描述

        //最大值
        System.out.println(Integer.MAX_VALUE);//2147483647
        //最小值
        System.out.println(Integer.MIN_VALUE);//-2147483648
        //用于表示二进制补码二进制形式的 int值的字节数。
        System.out.println(Integer.BYTES);//4
        //用于表示二进制补码二进制形式的 int值的位数。
        System.out.println(Integer.SIZE);//32

构造方法:

  • Integer (int a)
  • Integer(String a)
        //将int值;包装到Integer类的对象中;
        Integer num1=new Integer(10);
        
        //把字符串转为int值
        Integer num2=new Integer("123");

(2)比较方法

  • static int compareTo(Integer a);
    判断两个Integer类对象中的两个int值的大小;返回的是一个int值;如果前面的比后面的小,返回-1,如果前面的比后面的大,返回1;如果两个相等返回0;
        Integer  num1=new Integer(22);
        Integer  num2=new Integer(33);
         //比较方法
        //static  int compareTo(Integer a);
        //判断两个Integer类对象中的两个int值的大小;
        //返回的是一个int值;
        // 如果前面的比后面的小,返回-1,如果前面的比后面的大,返回1;如果两个相等返回0;
        System.out.println(num1.compareTo(num2));//输出-1;
  • int max(int a,int b);
  • int min(int a,int b);

在这里插入图片描述

        //int max(int a,int b);返回两个int值中的较大值
        //int min(int a,int b);返回两个int值中的较小值
        System.out.println(Integer.max(10,30));//30
        System.out.println(Integer.min(10,30));//10
  • boolean equals(Object);
    比较的是两个对象中包含的值是否相等;
        Integer num3=new Integer(20);
        Integer num4=new Integer(20);
         //boolean equals(Object);
        //比较的是两个对象中包含的值是否相等;
        System.out.println(num3.equals(num4));//true
        //"=="用于引用类型的比较时,比较两个对象在内存中的地址是否相等;
        System.out.println(num3==num4);//false

(3)转换方法

  • static toBinaryString(int i);返回int变量的二进制表示的字符串;

  • static String toHexString(int i);返回int变量的十六进制表示的字符串;

  • static String toOctalString(int i);返回int变量的八进制表示的字符串;

        //Integer.toBinaryString();返回int变量的二进制表示的字符串;
        System.out.println(Integer.toBinaryString(12));//1100
        //Integer.toOctalString();返回int变量的八进制表示的字符串;
        System.out.println(Integer.toOctalString(20));//24
        //Integer.toHexString();返回int变量的十六进制表示的字符串;
        System.out.println(Integer.toHexString(17));//11
  • int intValue();
    取出对象中包含的具体值,转换为int值;
        Integer num5=new Integer("20");
        //int intValue();
        //取出对象中包含的具体值,转换为int值;
        int num6 =num5.intValue();
        System.out.println(num6);//20
  • static int parseInt(String s);
    传入一个字符串类型的数值,返回int值;
         //static int parseInt(String s);
        //传入一个字符串类型的数值,返回int值;
        int num7 =Integer.parseInt("789");
        System.out.println(num7);
  • 基本类型转为Integer类的;
    将int类型的数值包装为Integer类;
    static Integer valueOf(int i)
    将String类型的数值包装为Integer类;
    static Integer valueOf(String s)
        //基本类型转为Integer类的;
        //将int类型的数值包装为Integer类;
        //static Integer valueOf(int i)
        //将String类型的数值包装为Integer类;
        //static Integer valueOf(String s)
        Integer num8=Integer.valueOf(10);
        Integer num9=Integer.valueOf("10");
  • 转换为字符串;
    将对象转为String类型;
    String toString();
    将int数值转为String类型;
    static String toString(int i)
        //转换为字符串;
        //将对象转为String类型;
        //String toString();
        //将int数值转为String类型;
        //static String toString(int i)
        Integer num10=new Integer("20");
        num10.toString();
        
        System.out.println(Integer.toString(20));

2.2自动拆箱、装箱

自动装箱:基本类型转为引用类型;
int a =20;
即自动调用valueOf()方法;
Integer a1=a;
自动拆箱:引用类型转为基本类型;
自动调用intValue()方法;
int b=a1;

在构造方法直接创建引用类型的对象时;与装箱调用valueOf( )方法的区别:

使用new构造方法创建对象时;这几个值不论是否相等;都会创建新的对象;这几个值指向的对象对应不同的地址;

注意,使用装箱调用valueOf( )方法在创建对象时;如果这几个值在-128~127之间;(Integer的缓冲区)那么这几个值指向的对象在内存中的同一个地址; 如果超出这个数值范围;那么就像构造方法中的创建对象一样;这几个值指向的对象对应不同的地址;

        //构造方法创建对象
        Integer a =new Integer(10);
        Integer b =new Integer(10);
        //使用equals()方法;比较的是两个对象中包含的值是否相等;
        System.out.println(a.equals(b));//true
        //使用"=="比较用于引用类型的比较时,比较两个对象在内存中的地址是否相等;
        System.out.println(a==b);//false

        //使用valueOf()方法创建对象
        Integer c=Integer.valueOf(10);
        Integer d=Integer.valueOf(10);
        //使用equals()方法;比较的是两个对象中包含的值是否相等;
        System.out.println(c.equals(d));//true

        //使用"=="比较用于引用类型的比较时,比较两个对象在内存中的地址是否相等;
        System.out.println(c==d);//true
        //注意,使用装箱调用valueOf()方法在创建对象时;如果这几个值在-128~127之间;
        //那么这几个值指向的对象在内存中的同一个地址;
        // 如果超出这个数值范围;那么就像构造方法中的创建对象一样;这几个值指向的对象对应不同的地址;

       //Integer缓冲区部分源码
       /* public static Integer valueOf(int i) {
            if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
                return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
            return new Integer(i);
        }*/

3.Object类

Object类是所有类的父类

这里主要讲两个方法:

  • toString( )方法:
    返回值为String类型的;
    每当将对象输出时,自动调用toString()方法;当类中没有定义toString()时,默认用父类Object的toString()方法;重写了toString()方法后;则就会使用重写后的方法;

使用到的Pet类

//Pet类;默认继承Object类
public class Pet {
    String  name;
    int     age;
    //有参构造
    public Pet(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //重写toString()方法;

    @Override
    public String toString() {
        return "["+"姓名"+name+",年龄"+age+"]";
    }
}

执行类:

public class Demo001 {
    public static void main(String[] args) {
        //创建Pet对象
        Pet p=new Pet("旺财",3);

        //每当将对象输出时,调用toString()方法;
        System.out.println(p);
        //当类中没有定义toString()时,默认用父类Object的toString()方法;
        //com.ff.javaCommonlyUsedClass.packageClass.objectClass01.Pet@1b6d3586
        //重写了toString()方法后;
        //[姓名旺财,年龄3]
    }
}
  • equals方法:
    public boolean equals(Object obj) {
    return (this == obj);
    }
    返回值为布尔值;仅判断是否指向同一个地址;
    默认为判断对象是否相等;如果是同一个对象的引用时返回 true ;否则返回 false;
        //创建对象
        Pet p1=new Pet("阿猫",10);
        Pet p2=new Pet("阿猫",10);
       //调用equals()方法
       //仅比较对象地址是否相等,等同于"=="
        System.out.println(p1.equals(p2));//false
        //"=="用于引用类型的比较时,比较两个对象在内存中的地址是否相等;
        System.out.println(p1==p2);//false

实际上,许多类在自己的内部对Object中的equals( )方法进行了重写;例如Integer类,String类;使得equals( )方法可以对这些对象中的所包含的值进行比较;且判断所用的对象是否为同一类对象;

Integer类:

        //Integer类
        Integer a=125;
        Integer b=125;
        System.out.println(a.equals(b));//true

Integer类重写的equals( )方法:

public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

String类:

        //String类
        String   s1="我";
        String   s2="我";
        System.out.println(s1.equals(s2));//true

String类重写的equals( )方法:

 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

自己也可以在类中对Object类中的equals( )方法进行重写;

4.String类

字符串是由多个字符组成的一串数据(字符序列),它是常量(值不能改变),java中所有字符串都是String类的实例.

两种创建对象方式
1. String s="abc";

每次创建对象时,首先会在字符串常量池检测有没有这个对象;没有就创建一个;
如果有;就直接使用,即直接指向这个内存空间中的地址;

        String  s1="abc";
        String  s2="abc";
        //这里引用变量s1与s2指向了相同的对象存储地址;
        System.out.println(s1==s2);//true

2. String s=new String( "abc"); 即使用 new + 构造方法()创建

直接在堆中创建对象

        //每new一次对象,就会创建一个新的对象存储地址出来;
        String s3=new String("abc");
        String s4=new String("abc");
        //这里引用变量s3与s4指向了不同的对象存储地址;
        System.out.println(s3==s4);//flase

字符串的值是常量,值不可以改变,一旦改变,那么就会直接在内存空间中创建一份新的对象;
我们查看它的底层代码;
private final char value[ ];
发现它的值存储方式为char数组,单个字符串去存储的;且被final修饰,值不能改变

构造方法

  • Public String ( )
    无参构造;
    例如: String str=new String( );
    即创建一个字符串对象;值为 " "

  • Public String(String str)
    有参构造
    例如: String str=new String( “abc”);
    创建一个字符串对象;值为" abc";

  • public String(byte[ ] bytes)
    byte数组转为字符串

  • public String(char[ ] value)
    char数组转为字符串

String类常用方法

判断功能

返回值类型都是布尔值

  • boolean equals(Object obj)
    比较两个对象中包含的值是否相等;
  • boolean equalsIgnoreCase(String str)
    不区分大小写的情况下比较两个对象中包含的值是否相等;
        String s1=new String("abc");
        String s2=new String("abc");
        String s3=new String("Abc");
        //boolean equals(Object obj)
        //比较两个对象中包含的值是否相等;
        System.out.println(s1.equals(s2));//true
        System.out.println(s1.equals(s3));//false
        //boolean equalsIgnoreCase(String str)
        //不区分大小写的情况下比较两个对象中包含的值是否相等;
        System.out.println(s1.equalsIgnoreCase(s2));//true
        System.out.println(s1.equalsIgnoreCase(s3));//true
  • boolean contains(String str)
    比较这个字符串中是否包含这个字符串
        String s1=new String("abc");
        //boolean contains(String str)
        //比较这个字符串中是否包含这个字符串
        System.out.println(s1.contains("ab"));//true
  • boolean isEmpty( )
    判断这个字符串是否为空;即是否为 " "
        String s1=new String("abc");
        //boolean isEmpty()
        //判断这个字符串是否为空;即是否为 " "
        System.out.println(s1.isEmpty());//false
  • boolean startsWith(String prefix)
    判断这个字符串是否以这段字符开头
  • boolean endsWith(String suffix)
    判断这个字符串是否以这段字符结尾
        String s4=new String("qwerty");
        // boolean startsWith(String prefix)
        //判断这个字符串是否以这段字符开头
        System.out.println(s4.startsWith("qwe"));//true
        // boolean endsWith(String suffix)
        //判断这个字符串是否以这段字符结尾
        System.out.println(s4.endsWith("y"));//true

获取功能

  • int length()
    获取字符串长度
        String s1=new String("qwerqyuiop");
        //int length()
        //获取字符串长度
        System.out.println(s1.length());//10
  • char charAt(int index)
    由输入的下标索引返回字符;(注意索引是从零开始的)
         String s1=new String("qwerqyuiop");
        //                     0123456789
        //char charAt(int index)
        //由输入的下标索引返回字符;(注意索引是从零开始的)
        System.out.println(s1.charAt(5));//y
  • int indexOf(String str)
    由前向后,由输入的字符,寻找它第一次出现的位置
  • int indexOf(String str,int fromIndex)
    由前向后,对于输入的字符,由输入的指定下标开始,寻找它第一次出现的位置
  • int LastIndexOf(String str)
    由后向前,由输入的字符,寻找它第一次出现的位置
  • int LastIndexOf(String str,int fromIndex)
    由后向前,对于输入的字符,由输入的指定下标开始,寻找它第一次出现的位置

注意,一旦找不到这个字符的位置,返回值输出为 -1

        String s1=new String("qwerqyuiop");
        //                    0123456789
        //int indexOf(String str)
        //由前向后,由输入的字符,寻找它第一次出现的位置
        System.out.println(s1.indexOf("q"));//0
        //int indexOf(String str,int fromIndex)
        //由前向后,对于输入的字符,由输入的指定下标开始,寻找它第一次出现的位置
        System.out.println(s1.indexOf("q",4));//4
        //int LastIndexOf(String str)
        //由后向前,由输入的字符,寻找它第一次出现的位置
        System.out.println(s1.lastIndexOf("q"));//4
        //int LastIndexOf(String str,int fromIndex)
        //由后向前,对于输入的字符,由输入的指定下标开始,寻找它第一次出现的位置
        System.out.println(s1.lastIndexOf("q",2));//0
  • String substring(int start)
    由这个输入的下标索引开始,截取一段字符串;
    注意这是从指定位置截取到结束,最终返回一个新的字符串,原来的字符串不变;
  • String substring(int start,int end)
    由这个输入的下标索引开始,到结束的下标索引前一个字符,截取一段字符串;
    这里的截取,最终返回一个新的字符串,原来的字符串不变;
        String s1=new String("qwerqyuiop");
        //                    0123456789
        //String substring(int start)
        //由这个输入的下标索引开始,截取一段字符串;
        //注意这是从指定位置截取到结束,最终返回一个新的字符串,原来的字符串不变;
        System.out.println(s1.substring(4));//qyuiop
        System.out.println(s1);//qwerqyuiop
        // String substring(int start,int end)
        //由这个输入的下标索引开始,到结束的下标索引前一个字符,截取一段字符串;
        //这里的截取,最终返回一个新的字符串,原来的字符串不变;
        System.out.println(s1.substring(4,8));//qyui
        System.out.println(s1);//qwerqyuiop

替换功能

  • String replace(char old,char new)
    用新字符替换旧的字符
  • String replace(String old,String new)
    用新字符串替换旧的字符串

注意,原来的字符串并不会改变;
正则表达式的基础用法

        String s1=new String("qwerABasic01");
        //String replace(char old,char new)
        //用新字符替换旧的字符
        System.out.println(s1.replace("c","C"));//qwerABasiC01
        //String replace(String old,String new)
        //用新字符串替换旧的字符串
        System.out.println(s1.replace("qwer","QWE"));//QWEABasic01
        System.out.println(s1);//qwerABasic01
  • replaceAll(String regex, String replacement)
    用正则表达式去匹配所有字符,进行替换;
  • replaceFirst(String regex, String replacement)
    用正则表达式去匹配第一个出现的对应字符,进行替换;
        String s2=new String("01qwerABasic01");
        //replaceAll(String regex, String replacement)
        //用正则表达式去匹配所有字符,进行替换;
        //regex;正则表达式;replacement;替换后的字符串
        //这个例子中的正则表达式匹配的是单个数字字符;即 \\d
        System.out.println(s2.replaceAll("\\d","A"));//AAqwerABasicAA
        //replaceFirst(String regex, String replacement)
        //用正则表达式去匹配第一个出现的对应字符,进行替换;
        System.out.println(s2.replaceFirst("\\d","L"));//L1qwerABasic01

去除字符串两边的空格

String trim( ) ;

        String s3=new String(" qwer ");
        System.out.println(s3.length());//6
        //String trim();
        //去除两边空格
        String s4=s3.trim();
        System.out.println(s4.length());//4

转换功能

  • byte[ ] getBytes( )
    将字符串转化为byte 数组
    在这里插入图片描述
    在这里插入图片描述
    非中文字符串转换:
        String s1=new String("abc");
        //byte[] getBytes()
        //将字符串转化为byte 数组
        byte[] s2=s1.getBytes();//编码:  字符串转为字节
        System.out.println(Arrays.toString(s2));
        //[97, 98, 99]
        
        //想把这个byte数组转回字符串;用构造方法public String(byte[] bytes)
        String s3=new String(s2);//解码:  字节转为为字符
        System.out.println(s3);
        //abc

中文字符串转换:
这里的utf-8 和gbk 是中文字节码:

GBK即汉字内码扩展规范，K为扩展的汉语拼音中"扩"字的声母。英文全称Chinese Internal Code Specification。GBK编码标准兼容GB2312，共收录汉字21003个、符号883个，并提供1894个造字码位，简、繁体字融于一库。GB2312码是中华人民共和国国家汉字信息交换用编码，全称《信息交换用汉字编码字符集--基本集》，1980年由国家标准总局发布。基本集共收入汉字6763个和非汉字图形字符682个，通行于中国大陆。新加坡等地也使用此编码。GBK是对GB2312-80的扩展，也就是CP936字码表 (Code Page 936)的扩展(之前CP936和GB 2312-80一模一样)。

utf8_encode是PowerBuilder的函数，该函数将 data 字符串转换为 UTF-8 编码，并返回编码后的字符串。UTF-8 是一种用于将宽字符值转换为字节流的 Unicode 的标准机制。

utf-8是三个字节表示一个汉字,gbk是两个字节表示一个汉字.


import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class Demo006 {
    public static void main(String[] args) {
    
        String s4=new String("我爱学编程");
        //byte[] getBytes()
        //将字符串转化为byte 数组
        //这里需要捕获和处理异常信息
        try {
            //使用gbk也可以;但是要注意解码时,需要和编码时使用的字节码相同
            byte[] s5=s4.getBytes("utf-8");//编码
            System.out.println(Arrays.toString(s5));
            //[-26, -120, -111, -25, -120, -79, -27, -83, -90, -25, -68, -106, -25, -88, -117]

            //想把这个byte数组转回字符串;用构造方法public String(byte[] bytes)
            String s6=new String(s5,"utf-8");//解码
            System.out.println(s6);
            //我爱学编程
        }
        catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

    }
}
  • char[ ] toCharArray( )
    字符串转为char数组
        //char[] toCharArray()
        //字符串转为char数组
        String s7=new String("qwe");
        char[] s8=s7.toCharArray();//编码
        System.out.println(Arrays.toString(s8));
        //[q, w, e]

        //想把这个char数组转回字符串;用构造方法public String(char[] value)
        String s9=new String(s8);//解码
        System.out.println(s9);//qwe
  • static String valueOf( )
    将其他类型转化为字符串形式

在这里插入图片描述

byte数组以及char数组与字符串之间的转换练习:

import java.io.UnsupportedEncodingException;
import java.util.Arrays;
//学习String类的部分转换方法;
//有关byte[]数组以及char[]数组之间的转换;
//和对应的转换方法;
public class Demo05 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        System.out.println("====字符串与byte[]数组的转换====");
        //非中文字符:
        String s="qwer";
        //使用方法public byte[] getBytes();
        byte[] bytes0=s.getBytes();//编码:字符串转数组;
        System.out.println(Arrays.toString(bytes0));//[113, 119, 101, 114]
        String s1=new String(bytes0);//qwer
        System.out.println(s1);//解码:数组转字符串;

        System.out.println("=========");
        //中文字符
        String s2="我的";
        byte[] bytes1=s2.getBytes();//编码;
        //这里默认是utf-8的规则,
        //utf-8是3个字节的,gbk为2个字节;
        System.out.println(Arrays.toString(bytes1));//[-26, -120, -111, -25, -102, -124]
        String s3=new String(bytes1);//解码
        System.out.println(s3);//我的

        System.out.println("=========");
        //选择gkb格式
        String s4="我的";
        byte[] bytes2=s4.getBytes("GBK");//编码;
        //这里需要抛出异常;
        //这里默认是utf-8的规则,
        //utf-8是3个字节表示一个汉字,gbk为2个字节表示一个汉字;
        System.out.println(Arrays.toString(bytes2));//[-50, -46, -75, -60]
        String s5=new String(bytes2,"GBK");//解码
        //!!!注意;解码时和编码时使用的转换格式要一致;
        //否则会出现乱码!!!;
        System.out.println(s5);//我的
        //在解码时也可以使用方法;来解码部分区间的字符;
        String s6=new String(bytes2,0,2,"GBK");
        System.out.println(s6);//我

        System.out.println("====字符串与char[]数组的转换====");

        String s7="qaq";
        //使用public char[] toCharArray()方法;
        //将字符串类型转换为char[]数组类型的
        char[] chars0=s7.toCharArray();
        System.out.println(Arrays.toString(chars0));//[q, a, q]
        //方式1:使用构造方法public String(char[] value);
        //将数组类型转为字符串类型的;
        String s8=new String(chars0);
        System.out.println(s8);//qaq
        //方式2:使用方法:public static String valueOf(char[] data);
        //实际上这个方法的底层应用了char[]类型的构造方法;
        //将数组类型转为字符串类型的;
        String s9=String.valueOf(chars0);
        System.out.println(s9);//qaq

    }
}
  • String toLowerCase( )
    将所有字母变为小写显示
  • String toUpperCase( )
    将所有字母变为大写显示
        String s10=new String("ABcdefGh");
        //String toLowerCase()
        //将所有字母变为小写显示
        System.out.println(s10.toLowerCase());//abcdefgh
        //String toUpperCase()
        //将所有字母变为大写显示
        System.out.println(s10.toUpperCase());//ABCDEFGH
  • String concat(String str)
    向字符串的尾部拼接一个字符串,并返回一个新的字符串;
        String s11="ssa";
        String s12="AAABBB";
        //String concat(String str)
        //向字符串的尾部拼接一个字符串,并返回一个新的字符串;
        System.out.println(s11.concat(s12));//ssaAAABBB
  • Stirng[ ] split(String regex);
    将字符串按照指定的正则表达式匹配的模式进行分割为字符串数组
        String s13="A23BcDE527XI";
        //Stirng[] split(String regex);
        //将字符串按照指定的正则表达式匹配的模式进行分割为字符串数组
        //这里的 \\D 匹配一个非数字字符。等价于[^0-9]。grep要加上-P，perl正则支持
        String[] s14=s13.split("\\D");
        System.out.println(Arrays.toString(s14));
        //[, 23, , , , 527]

5.StringBuffer类

StringBuffer类:线程安全的可变字符序列.
StringBuffer是线程安全的,值可变的字符串(指的是底层char[ ]的值在变).

构造方法:

  • public StringBuffer( )
    无参构造
    构造一个没有字符的字符串缓冲区，初始容量为16个字符。
    底层默认创建一个长度为16的char数组.
       //无参构造;底层默认创建长度为16的char数组;
       StringBuffer s1=new StringBuffer();
       //底层是char数组,不是final修饰的,即可变
       //char[] value;

  • public StringBuffer(int capacity)
    构造一个没有字符的字符串缓冲区和指定的初始容量。
    底层创建给定的长度char数组
    例:StringBuffer s2=new StringBuffer(20);

  • public StringBuffer(String str)
    有参构造
    构造一个初始化为指定字符串内容的字符串缓冲区。
    底层创建的数组长度为字符串长度＋16.

添加功能

  • public StringBuffer append(String str)
    添加字符串
    注意,这里的参数可用这些:

在这里插入图片描述

注意:并没有创建新对象;返回的还是原来的对象;所以它比String类的拼接功能效率快;

     StringBuffer s1=new StringBuffer();
     char[] q={'a','b','c'};
     //public StringBuffer append(xxxxxx)
        // 添加其他类型的字符
     s1.append(5);
     s1.append(true);
     s1.append("abc");
     s1.append("我");
     s1.append(q);
        System.out.println(s1);
        //5trueabc我abc
  • public StringBuffer insert(int offset,String str)
    向指定位置插入字符串
    注意,这里的参数可用这些:

在这里插入图片描述

注意:并没有创建新对象;返回的还是原来的对象;

        StringBuffer s2=new StringBuffer("asdfgh");
        //public StringBuffer insert(int offset,String str)
        //向指定位置插入字符串
        //offset:指定的位置
        //注意:并没有创建新对象;返回的还是原来的对象;所以它比String类的拼接功能效率快;
        s2.insert(1,"23");
        s2.insert(6,123);
        System.out.println(s2);
        //a23sdf123gh

删除功能

  • public StringBuffer deleteCharAt(int index)
    删除指定个下标索引位置的字符
    注意:并没有创建新对象;返回的还是原来的对象;
        StringBuffer s1=new StringBuffer("asdfghjkl123");
        //public StringBuffer deleteCharAt(int index)
        //删除指定个下标索引位置的字符
        //注意:并没有创建新对象;返回的还是原来的对象;
        s1.deleteCharAt(3);
        s1.deleteCharAt(10);
        System.out.println(s1);//asdghjkl12
  • public StringBuffer delete(int start,int end)
    start:开始位置;end:结束位置
    删除(start–(end-1))区间的字符
    注意:并没有创建新对象;返回的还是原来的对象;
        StringBuffer s2=new StringBuffer("qwertyuiop0123");
        //public StringBuffer delete(int start,int end)
        //start:开始位置;end:结束位置
        //删除(start--(end-1))区间的字符
        //注意:并没有创建新对象;返回的还是原来的对象;
        s2.delete(0,5);
        System.out.println(s2);//yuiop0123

替换功能

public StringBuffer replace(int start,int end,String str)
在指定的区间内替换字符串

        StringBuffer s1=new StringBuffer("qwerasdf");
        //public StringBuffer replace(int start,int end,String str)
         //在指定的区间内替换字符串
        s1.replace(0,5,"lllL");
        System.out.println(s1);//lllLsdf

反转功能

public StringBuffer reverse( )
反转输出字符串

        StringBuffer s2=new StringBuffer("zxcvbnm01");
        //public StringBuffer reverse()
        //反转输出字符串
        s2.reverse();
        System.out.println(s2);//10mnbvcxz

截取功能

注意:截取功能和前面几个功能的不同;
返回值类型是String类型，本身没有发生改变;即创建了一个新的对象;

  • public String substring(int start)
    从开始位置全部截取字符串
        StringBuffer s1=new StringBuffer("12asdfg");
        //public String substring(int start)
        //从开始位置全部截取字符串
        String s2=s1.substring(2);
        System.out.println(s2);//asdfg
        System.out.println(s1);//12asdfg
  • public String substring(int start,int end)
    在指定的区间内截取字符串
        StringBuffer s3=new StringBuffer("qwertyuio");
        //public String substring(int start,int end)
        //在指定的区间内截取字符串
        String s4=s3.substring(0,5);
        System.out.println(s4);//qwert
        System.out.println(s3);//qwertyuio

StringBuffer类,StringBuilder类,String类区别

  • StringBuffer类:值可变字符序列;底层是char [ ] value ;继承 AbstractStringBuilder;添加synchronized 同步锁 ;多线程安全.

  • StringBuilder类:值可变字符序列;底层是char [ ] value 继承 AbstractStringBuilder;没有添加同步锁; 多线程不安全.

  • String类:值不可变的字符串序列;底层是final char [ ] value; 一旦需要改变值,必须重新创建一个String.

StringBuilder类功能和StringBuffer类功能完全一致, StringBuffer类是线程安全的;

6.常用类(2)(3)

常用类总结

常用类总结笔记

# java # 编程语言
Logo
CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

cover

玩转 AIGC 工具，早点下班！

avatar CSDN学习社区
cover

用 OpenAI Assistants 做大模型应用开发

avatar CSDN学习社区
cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区