java复习:”Sting类、StringBuffer类、StringBuilder类的应用

最新推荐文章于 2023-02-09 17:00:42 发布

西红柿鸡蛋面U

最新推荐文章于 2023-02-09 17:00:42 发布

阅读量901

点赞数

分类专栏： JAVA 文章标签： java string

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/YI_LI_A_E/article/details/49130467

版权

JAVA 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1、String类的基本概述

1.1 String对象一旦被初始化就不会被改变

public class StringDemo
{   
    public static void main(String[] args)
    {
        String s = "abc";
        s = "nba";
        System.out.println("s = " + s);
    }
}

这里写图片描述
结果分析:
“abc”字符串对象并没有被改变，只是引用变量s指向了新创建的字符串对象”nba”。

1.2 字符串常量池1

public class StringDemo
{
    public static void main(String[] args)
    {
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);
    }
}//true

结果分析：
字符串创建的时候，有一个字符串常量池，s1创建后，”abc”放入其中。s2创建的时候，”abc”已经存在于字符串常量池中，故引用变量s2直接指向了已经存在的”abc”字符串对象，故s1==s2。

1.3 字符创常量池2

class StringDemo
{
    public static void main(String[] args)
    {
        String s1="abc";
        String s2=new String("abc");
        System.out.println(s1==s2);
    }
}//false

结果分析：
s1创建后，是在字符串常量池中创建了一个”abc”字符串对象。而s2是在堆内存中创建了另外一个”abc”字符串对象。所以，两个对象不是同一个对象。

1.4 equals方法

public class StringDemo
{
    public static void main(String[] args)
    {
        String s1 = "abc";
        String s2 = new String("abc" );
        System.out.println(s1.equals(s2));
    }
}//true

原因分析：
String类复写了Object中的equals方法，建立了String类自己的判断字符串对象是否相同的依据。只是比较字符串内容不比较地址。

2、String类常用方法的介绍

2.1 常用方法

public int length()
返回此字符串的长度。长度等于字符串中 16 位 Unicode 字符数。
public char charAt(int index)
返回指定索引处的 char 值。
public int indexOf(int ch，int fromIndex)
public int indexOf(String str)
public int indexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引。

public static void method_get()
    {
        String str="abcdefb";
        Sop(str.length());
        Sop(str.charAt(4));
        Sop(str.indexOf('b',3));
        Sop(str.indexOf('b'));
        Sop(str.indexOf("bc"));
    }

这里写图片描述
public boolean startsWith(String prefix)
测试此字符串是否以指定的前缀开始。
public boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束。
public boolean contains(CharSequence s)
当且仅当此字符串包含 char 值的指定序列时，才返回 true。
public boolean equalsIgnoreCase(String anotherString)
将此 String 与另一个 String 进行比较，不考虑大小写。

public static void method_is()
    {
        String str1="ArrayDemo.java";
        Sop(str1.startsWith("Array"));
        Sop(str1.endsWith(".java"));
        Sop(str1.contains("Demo"));
Sop(str1.equalsIgnoreCase("arraydemo.java"));
    }

这里写图片描述
public String replace(char oldChar, char newChar)
public String replace(String str1,String str2)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 而生成的。

public static void method_replace()//替换
    {
        String s4="hello.java";
        Sop("method_replace="+s4.replace("java","C++"));
    }

这里写图片描述
public String[] split(String regex)
根据给定的正则表达式的匹配来拆分此字符串。

public static void method_split()//切割
    {
        String s5="Test,String,Demo";
        String[]arr=s5.split(",");
        for(int x=0;x<arr.length;x++)
        {
            Sop("method_split="+arr[x]);    
        }   
    }

这里写图片描述
public String toUpperCase(Locale locale)
使用给定的 Locale 规则将此 String 中的所有字符都转换为大写。
public String toLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
public String trim()
返回字符串的副本，忽略前导空白和尾部空白。

public static void method_toUpperCase()//全部改为大写
    {
        String s6="StringDemo.java";
        Sop("method_toUpperCase="+s6.toUpperCase());
        Sop("method_toLowerCase="+s6.toLowerCase());
        Sop("method_trim="+s6.trim());

    }

这里写图片描述
public String substring(int beginIndex, int endIndex)
public String substring(ing beginIndex)
返回一个新字符串，它是此字符串的一个子字符串。

    public static void method_substring()//替换
    {
        String s10="StringDemo";
        Sop(s10.substring(2));
    }

这里写图片描述

public int compareTo(String anotherString)
按字典顺序比较两个字符串。

    public static void method_compareTo()//两个字符串进行自然顺序的比较
    {
        String s8="abc";
        String s9="aaa";
        Sop("method_compareTo="+s8.compareTo(s9));
    }

这里写图片描述

2.2 数据类型间的转换

（1）字符数组装换为字符串
public static String copyValueOf(char[] data)
返回指定数组中表示该字符序列的字符串。
String(char[] value)
分配一个新的 String，它表示当前字符数组参数中包含的字符序列。
String(char[] value, int offset, int count)
分配一个新的 String，它包含来自该字符数组参数的一个子数组的字符。

public static void method_trans1()//
    {
        char[] arr={'a','b','c','d','e','g','f'};
        String s=new String(arr);
        String s1=new String(arr,1,3);
        String s2=String.copyValueOf(arr);
//      String s3=String.ValueOf(true);
        Sop("s（原数组）="+s);
        Sop("s1（字符数组部分转换为字符串）="+s1);
        Sop("s2（字符数组全部转换为字符串）="+s2);
    }

这里写图片描述
（2）字符串转换成字符数组
public char[] toCharArray()
将此字符串转换为一个新的字符数组。

    public static void method_trans2()
    {
        String s3="zxcvbnm";
        char[] chs=s3.toCharArray();
        for(int x=0;x<chs.length;x++)
        {
            Sop("ch(字符数组)="+chs[x]);
        }
    }

这里写图片描述
（3）字符串转换成字节数组
public byte[] getBytes()
使用平台默认的字符集将此 String 解码为字节序列，并将结果存储到一个新的字节数组中。

    public static void method_trans3()
    {
        String s3="zxcvbnm";
        byte[] chs=s3.getBytes();
        for(int x=0;x<chs.length;x++)
        {
            Sop("ch（字符数组）="+chs[x]);
        }
    }

这里写图片描述

3 常用方法的应用

3.1 需求：自己定义函数去除字符串两边的空格

/*
思路：String类中的charAt()方法
*/
class  Demo
{
  public static String trim1(String str)
  {
    int start=0,end=str.length()-1;
    while (start<=end&&str.charAt(start)==' ')
    start++;
    while (start<=end&&str.charAt(end)==' ')
    end--;
    return str.substring(start,end+1);
  }
    public static void main(String[] args) 
    {
        String str1="   两边有空格   ";
        System.out.println(str1);
        System.out.println(trim1(str1));
    }
}

这里写图片描述

3.2 将一个字符串反转

/*  
方法一、二思路：
      1、将字符串转换为字符数组 
      2、将数组反转 
      3、将字符数组转换为字符串 
方法三：StringBuffer类中的反转方法-->
   public StringBuffer reverse()将此字符序列用其反转形式取代。
*/  
    public static void method_reverse()//反转
    {
        String s2="StringTestDemo";
        System.out.println("               "+s2);
        System.out.println("method_reverse1="+reverse1(s2));
        System.out.println("method_reverse2="+reverse2(s2));
        System.out.println("method_reverse3="+reverse3(s2));
    }
/**********************************************************/
    public static String reverse1(String str)
    {
        char[] arr=str.toCharArray();//将字符串转换为字符数组
        for( int start=0,end=str.length()-1;start<end;start++,end--)
        {   
            char temp=arr[start];
            arr[start]=arr[end];
            arr[end]=temp;
        }
        return new String (arr);
    }
/**********************************************************/
    public static String reverse2(String str)
    {
        char[] arr=str.toCharArray();
        for (int x=0;x<str.length()/2 ;x++ )
        {
            char temp=arr[str.length()-x-1];
            arr[str.length()-x-1]=arr[x];
            arr[x]=temp;
        }
        return new String(arr);
    }
/**********************************************************/
    public static String reverse3(String str)
    {
        return new StringBuffer(str).reverse().toString();
    }

这里写图片描述

3.3 获取一个字符串在另一个字符串中出现的次数例如”abkkcdkkefkkskk”

/*
思路：1、定义一计数器
      2、获得字符串第一次在另个字符中出现的位置
      3、从第一次出现的位置后剩余的字符串中继续获取字符串出现的次数，每出现一次，计数器就加一次
      3、当获取不到时候，计数停止
*/
    public static void method_getCount()
    {
        String s1="abkkcdkkefkkskk";
        System.out.println(getCount(s1,"kk"));
    }
    public static int getCount(String str,String key)
    {
        int count=0;
        int index=0;
        while((index=str.indexOf(key))!=-1)
        {   
            str=str.substring(index+key.length());
            count++;
            System.out.println(index);
        }
        return count;
    }
/**************************************************/
    public static void method_getCount2()
    {
        String s2="abkkcdkkefkkskk";
        System.out.println("count="+getCount2(s2,"kk"));
    }
    public static int getCount2(String str,String key)
    {
        int count=0;//定义计数器
        int index=0;//定义索引项FromIndex
        while ((index=str.indexOf(key,index))!=-1)//当遇到字符串key时
        {
            index=index+key.length();
            count++;
        }
        return count;
    }

这里写图片描述

3.4 获取两个字符串中最大相同子串

/*
思路：1、将短的一个字符串与长的进行比较，如果没有，则将短串的字串按长度递减的方式获取
      2、将每次获取的子串，去长串中判断是否包含，包含即找到。
*/
    public static void method_getMaxSubstring()
    {
        String s1="HelloafsfWorldcgagb!";
        String s2="fWorldafdffsfsfsfsfdc";
        sop(getMaxSubstring(s1,s2));
    }

    public static String getMaxSubstring(String s1,String s2)
    {
        String max,min;
        max=(s1.length()>s2.length())?s1:s2;//判断出大字符串
        min=(max==s1)?s2:s1;//判断出小字符串

        for (int x=0;x<min.length() ;x++ )//外循环，控制在最短字串长度内
        {
            for (int y=0,z=min.length()-x;z<min.length()+1; y++,z++)//依次递减短字符串子串
            {
                String temp=min.substring(y,z);//获取短字符串子串
                if(max.contains(temp))//如果长串包含，则表示找到
                    return temp;
            }
        }
        return "没有相同的字符串";
    }
    public static void sop(Object obj)  //打印输出
    {
        System.out.println(obj);
    }
}

这里写图片描述

3.5 对字符串数组进行比较排序

/*
①对数组排序，可以用选择，冒泡排序
②for嵌套，比较以及换位
③使用String类中提供的用于字符串比较的功能进行比较
*/
class  Demo{
public static void main(String[] args) {
String[] arr={"afd","ndf","lkm","and","spsp"};
     sortString(arr);
     printpoll(arr);    
    }
    //使用for循环嵌套对数组中字符串进行比较
 public static void sortString(String[] arr1){
       for (int i=0;i<arr1.length;i++ ){
       for (int j=i+1;j<arr1.length-1 ;j++ ){
            if(arr1[i].compareTo(arr1[j])>0){
                    swap(arr1,i,j);
                }
            }
        }
    }
    //自定义打印方法，使其按照[***,**,***,***]显示
   public static void printpoll(String[] arr){
        System.out.print("[");
        for (int n=0;n<arr.length ;n++ ){
            if (n!=arr.length-1)
                System.out.print(arr[n]+",");
            else
                System.out.print(arr[n]+"]");
        }
    }
    //字符串的调换方法
    public static void swap(String[] arr,int i,int j){
        String str=arr[i];
        arr[i]=arr[j];
        arr[j]=str;
    }
}

这里写图片描述

3.6 对一个字符串中的字符进行自然排序

/*
思路：1、将字符串转换为字符数组。
      2、对字符数组进行选择、冒泡排序
      3、将排好序的字符数组转换为字符串
*/
class  RaturalSortString
{
  public static void main(String[] args)
  {
    String s="vcz1bdaA+cs";
    sop(s);//打印原字符串
    sop(raturalSortString(s));//排序后的字符串
    sop(getLowerCaseString(raturalSortString(s)));//打印排序后的小写字母部分
   }
    //取出有序字符串中的小写字母部分
    public static String getLowerCaseString(String s)
    {
        int[] arr=lowerCaseIndex(s);
        return s.substring(arr[0],arr[1]);
    }
    //对字符串中的小写字母进行自然排序的方法
    public static String raturalSortString(String s)
    {
        //将字符串转换为字符数组
        char[] arr = s.toCharArray();
        //将字符数组进行排序
        selectSortArray(arr);       
        //将排序好的字符数组转换为字符串返回
        return new String(arr);
    }
    //对数组进行选择排序
    private static void selectSortArray(char[] arr)
    {
        for (int x=0; x<arr.length-1; x++)
        {
            for (int y=x+1;y<arr.length ; y++)
            {
                if(arr[x]>arr[y])
                    swap(arr,x,y);
            }
        }
    }   
    //交换数组两元素
    private static void swap(char[] arr ,int x,int y )
    {
        arr[x]=(char)(arr[x]^arr[y]);
        arr[y]=(char)(arr[x]^arr[y]);
        arr[x]=(char)(arr[x]^arr[y]);
    }
    //判断小写字母部分在有序字符串中的位置，并将第一个的位置和最后一个的位置存在一个数组中，返回数组
    private static int[] lowerCaseIndex(String s)
    {           
        //将字符串转换为字符数组
        char[] arr = s.toCharArray();
        int x=0;
        while (arr[x]<'a')
        x++;
        int y=arr.length-1;
        while (arr[y]>'z')
        y++;
        int[] a = {x,y+1};
        return a;
    }
    //打印
    private static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

这里写图片描述

4 StringBuffer、StringBuilder 类

StringBuffer是字符串缓冲区，用于存储数据的容器，不是固定的。
特点：
1、长度是可变的。
2、可以存储不同的类型数据。
3、最终要装换为字符串进行使用。

4.1 功能：
（1）添加

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。
Stringbuffer append()将指定参数数据添加到已有的数据中
Stringbuffer insert(index，数据)将指定参数数据插入到指定的index位置

    public static void main(String[] args)
    {
        StringBuffer sb=new StringBuffer();//建立字符串缓冲区
        sb.append("abc").append("true").append(34);
        Sop("append="+sb.toString());
        sb.insert(1,"flase");
        Sop("insert="+sb.toString());
     }

这里写图片描述

（2）删除

StringBuffer delete(int start,int end)删除包含头不包括尾
StringBuffer deleteCharAt(index)删除指定的位置字符

 class Demo
 {
     public static void main(String[] args)
     {
       StringBuffer sb=new StringBuffer("afalsebctrue34");
       sb.delete(1,6);
       Sop("delete="+sb.toString());//结果：abctrue34
     }
}

这里写图片描述

（3）修改

StringBuffer replace(int start,int end,String str)修改
StringBuffer setCharAt(int index,char ch)修改一个字符

public static void main(String[] args)
{
     StringBuffer sb=new StringBuffer("abctrue34");
     sb.replace(0,3,"hello");
     Sop("replace="+sb.toString());
}

这里写图片描述

（4）查找

void getChars(int srcBegin,int srcEnd,char[]，dst)
将字符从此字符串复制到目标字符数组。
要复制的第一个字符在索引 srcBegin 处；要复制的最后一个字符在索引 srcEnd-1 处（因此要复制的字符总数是 srcEnd-srcBegin）。要复制到 dst 子数组的字符从索引 dstBegin 处开始，并结束于索引：
dstbegin + (srcEnd-srcBegin) - 1
参数：
srcBegin - 字符串中要复制的第一个字符的索引。
srcEnd - 字符串中要复制的最后一个字符之后的索引。
dst - 目标数组。
dstBegin - 目标数组中的起始偏移量。

public static void main(String[] args)
{
       StringBuffer sb=new StingBuffer("abcdef");
       char[] chs=new char[4];
       sb.getChars(1,4,chs,1);
        for(int x=0;x<chs.length;x++)
        {
            Sop(chs[x]);
        }
 }

这里写图片描述

4.2 StringBuilder类
一个可变的字符序列。此类提供了一个与StringBuffer兼容的API。但是不保证同步。此类设计用作StringBuffer类的一个简易替换。

StringBuffer类与StringBuilder类的区别？
StringBuilder类是不安全的，但是单线程情况下，效率高。
而StringBuffer类是线程安全的可变字符序列。

5 常用对象

5.1 基本数据类型对象包装类
（1）基本特性
byte–>Byte float–>Float short–>Short double–>Double int–>Interger char–>Character long–>Long boolean–Boolean
例如：获取整数类型的最大值：System.out.println(Interger.Max_VALUE)
（2）基本数据类型对象包装类的新特性

class StringBuilderDemo
{
    public static void main(String[] args)
    {
        Integer x=new Integer("123");
        Integer y=new Integer(123);
        System.out.println("x==y="+(x==y));
        System.out.println("x.equals(y)="+x.equals(y));//
/************************************************************
JDK1.5升级后
例如：Integer z=123;   z=z+2;
首先自动装箱，x=2进行自动拆箱，变成了int类型。和2进行加法运算，再将和进行装箱赋给了x，拆箱的原理是用x.intValue()，注意的是Integer x=null；x无法调用intValue（）方法，编译 会出现NullPointerException的错误。
************************************************************/
        Integer m=128;
        Integer n=128;
        System.out.println("m==n="+(m==n));//

        Integer a=127;
        Integer b=127;
        System.out.println("a==b="+(a==b));//  
    }
}

这里写图片描述
结果分析：
x==y为false是因为创建了两个不同的对象。
x.equals(y)=true是因为Integer复写了Object类中的equals()方法，比较的是数值是否相同。
m==n=false;a==b=true;是因为ab指向同一个Integer对象，当数值在byte的范围内时，对于新特性，就不会开辟新的空间

5.2 数据类型间转换
（1）基本数据类型–>字符串
格式：基本数据类型.toString(基本数据类型值)
例如：Integer.toString(34) //整数34转换为”34”
（2）字符串–>基本数据类型
第一：（基本数据类型）a=.parse***(String);
例如：
int a=Interger.parseInt(“123”);
double b=Double.parseDouble(“12.23”);
boolean b=Boolean.parseBoolean(“true”);
第二：静态转换模式–>先将字符串封装为Integer封装为Integer对象,[Integer(int value)][Interger(String s)],然后用int intValue()返回int值
例如：Integer i=new Integer(“123”);
（3）十进制转换为其他进制
toBinaryString();二进制
toHexString();十进制
toOctalString();十六进制
（4）其他进制转换为十进制
格式：parseInt(String s,int radix)
int x=Integer.parseInt(“3c”,16);
int x=Inter.parseInt(“110”,2);