017_常用API_String类和StringBuffer类

1.String类

　　(1)字符串对象

　　　　  ①字符串是一个特殊的对象，字符串一旦初始化就不可以被改变。

②字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享

③String类中的equals()方法复写了Object类中的内容，其实就是比较字符串内容，而不是比较对象引用。　

public class StringDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        stringDemo2();
        stringDemo1();
    }

    /**
     * 演示定义字符串的第二种方式
     */
    private static void stringDemo2() {
        // TODO Auto-generated method stub
        String s="abc";//创建一个字符串对象在常量池中

        String s1=new String("abc");//创建两个对象，一个new一个在堆内存中

        System.out.println(s==s1);

        System.out.println(s.equals(s));
    }

    /**
     * 演示定义字符串的第一种方式
     */
    private static void stringDemo1() {
        String s="abc";

        String s1="abc";

        System.out.println(s==s1);
    }
}

　　(2)构造函数

　　　　String(byte[] bytes)
　　　　　　通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

　　　　String(int[] codePoints, int offset, int count)
　　　　　　分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符

public class StringConstructorDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        stringConstructorDemo1();
    }

    private static void stringConstructorDemo1() {
        // TODO Auto-generated method stub
        char[] arr= {‘a‘,‘b‘,‘c‘,‘d‘};

        String s=new String(arr,1,3);
        System.out.println("s1="+s);
    }

    public static void stringConstructorDemo() {
        // TODO Auto-generated method stub
        String s=new String();//不等于String s=null;

        byte[] arr= {65,66,67};

        String s1=new String(arr);
        System.out.println("s1="+s1);
    }
}

　　(3)String类常用方法　　　　

　　　　①获取
　　　　　　1.1 获取字符串长度 int length()

　　　　　　1.2 根据位置获取字符 char charAt(int index)

　　　　　　1.3 根据字符获取第一次出现的位置
　　　　　　　　　　int indexOf(int ch)

　　　　　　　　从指定位置开始获取第一次出现的位置
　　　　　　　　　　int indexOf(int ch,int fromIndex)
　　　　　　　　返回指定子字符串在此字符串中第一次出现处的索引。 
　　　　　　　　　　indexOf(String str)
　　　　　　　　返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始 
　　　　　　　　　　int indexOf(String str, int fromIndex)

　　　　　　　　返回指定字符在此字符串中最后一次出现处的索引。

　　　　　　　　　　int lastIndexOf(int ch)

　　　　　　　　返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 
　　　　　　　　　　int lastIndexOf(int ch, int fromIndex)

　　　　　　　　返回指定子字符串在此字符串中最右边出现处的索引。
　　　　　　　　　　int lastIndexOf(String str)
　　　　　　　　返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
　　　　　　　　　　int lastIndexOf(String str, int fromIndex)

　　　　　　　　注意:可以根据-1判断字符或者字符串是否存在

　　　　　　1.4 获取字符串的子串
　　　　　　　　　　String substring(int beginIndex)
　　　　　　　　　　　　返回一个新的字符串，它是此字符串的一个子字符串。
　　　　　　　　　　String substring(int beginIndex, int endIndex)
　　　　　　　　　　　　返回一个新字符串，它是此字符串的一个子字符串。
　　　　②转换
　　　　　　2.1将字符串切割成字符串数组
　　　　　　　　String[] split(String regex)
　　　　　　　根据给定正则表达式的匹配拆分此字符串。
　　　　　　　　String[] split(String regex, int limit)
　　　　　　　根据匹配给定的正则表达式来拆分此字符串
　　　　　　2.2将字符串变成字符数组
　　　　　　　　char[] toCharArray()
　　　　　　2.3将字符串变成字节数组
　　　　　　　　byte[] getBytes()
　　　　　　2.4将字符串中的字母转换成大写
　　　　　　　　　String toUpperCase()

　　　　　　2.5将字符串中的内容进行替换
　　　　　　　　　String replace(char oldChar, char newChar)

　　　　　　2.6将字符串两端空格消除
　　　　　　　　　String trim();
　　　　　　2.7将字符串进行连接
　　　　　　　　　String concat();
　　　　③判断
　　　　　　3.1两个字符串内容是否相同？
　　　　　　　　boolean equals(Object anObject)
　　　　　　　 将此 String 与另一个 String 比较，不考虑大小写
　　　　　　　　boolean equalsIgnoreCase(String anotherString)
　　　　　　3.2字符串中是否包含某一字符串？
　　　　　　　　boolean contains(CharSequence s)
　　　　　　3.3字符串是否都以指定字符串开头或结尾
　　　　　　　　boolean startsWith(String prefix)
　　　　　　　　boolean endsWith(String suffix)
　　　　④比较
　　　　　　　　int compareTo(String anotherString)
　　　　　　　　　　按字典顺序比较两个字符串。
　　　　　　　　int compareToIgnoreCase(String str)
　　　　　　　　　　按字典顺序比较两个字符串，不考虑大小写

2.StringBuffer类

　　StringBuffer：字符缓冲区，用于存储数据的容器

　　(1)特点

　　　　①长度可变
　　　　②可以存储不同类型的数据
　　　　③最终要转成字符串进行使用
　　　　④可以对字符串进行修改

　　(2)功能

　　　　①添加

　　　　　　StringBuffer append(data);
　　　　②插入
　　　　　　StringBuffer insert(index,data);
　　　　③删除
　　　　　　StringBuffer delete(start,end);//包含头，不包含尾
　　　　　　StringBuffer deleteCharAt(int index);
　　　　④查找
　　　　　　char charAt(index)
　　　　　　int indexOf(String)
　　　　　　int lastIndexOf(String)
　　　　⑤修改
　　　　　　StringBuffer replace(start,end,String)
　　　　　　void setCharAt(index,char)

3.StringBuilder类　　

　　　　(1)StringBuilder是线程不同步的。通常用于单线程，效率高。
　　　　(2)StringBuffer是线程同步的。通常用于多线程。

4.String类练习

/*1.给定一个字符串数组，按字典顺序进行从小到大的排序。
 *
 *2.一个子串在整串中出现的个数。
 *
 *3.两个字串中最大的相同子串。
 *
 *4.模拟一个trim功能一致的方法。
*/

public class StringTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //1.给定一个字符串数组，按字典顺序进行从小到大的排序。
        String[] arr= {"nba","abc","cba","zz","qq","haha"};
        sort(arr);

        //2.一个子串在整串中出现的个数。
        String str="nbaernbatynbauinbaopnba";
        String key="nba";
        System.out.println("count=="+getKeyStringCount(str,key));

        //3.两个字串中最大的相同子串。
        String maxSub=getMaxSubString("qwerabcdeyuion","qwerabcde");
        System.out.println("maxSub="+maxSub);

        //4.模拟一个trim功能一致的方法
        String s="    abc abc   ";
        System.out.println("trimSub="+myTrim(s));
    }

    public static void printArr(String[] arr) {
        // TODO Auto-generated method stub
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+",");
        }
    }

    public static void sort(String[] arr)
    {
        System.out.println("排序前:");
        printArr(arr);

        for(int i=0;i<arr.length-1;i++)
        {
            for(int j=i+1;j<arr.length;j++)
            {
                if(arr[i].compareTo(arr[j])>0)
                {
                    swap(i,j,arr);
                }
            }
        }

        System.out.println();
        System.out.println("排序后:");
        printArr(arr);
        System.out.println();
    }

    public static void swap(int i, int j, String[] arr) {
        // TODO Auto-generated method stub
        String temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

    public static int getKeyStringCount(String str,String key)
    {
        int count=0;
        int index=0;

        while((index=str.indexOf(key,index))!=-1)
        {
            index=index+key.length();
            count++;
        }
        return count;
    }

    public static String getMaxSubString(String s1,String s2)
    {
        String max=(s1.length()>s2.length())?s1:s2;
        String min=(max.equals(s1))?s2:s1;

        System.out.println("max="+max);
        System.out.println("min="+min);

        /*
         *abcdefg 7-0
         *abcdef bcdefg 7-1
         *abcde bcdef cdefg 7-2
         *.........................
        */
        for(int i=min.length();i>0;i--)
        {
            for(int j=0;j<=min.length()-i;j++)
            {

                String sub=min.substring(j, j+i);
                if(max.contains(sub))
                    return sub;
            }
        }
        return null;
    }

    public static String myTrim(String s)
    {
        int start=0,end=s.length()-1;

        while((start<s.length()-1)&&(s.charAt(start)==‘ ‘))
        {
            start++;
        }
        while(end>0&&s.charAt(end)==‘ ‘)
        {
            end--;
        }

        return s.substring(start, end+1);
    }
}

原文地址：https://www.cnblogs.com/lydbky/p/8322258.html

时间： 2024-10-29 19:42:02

017_常用API_String类和StringBuffer类的相关文章

JavaSE入门学习29：Java常用类之StringBuffer类和StringBuilder类

一StringBuilder类 (1)认识StringBuilder类 在Java中,除了可以使用String类来存储字符串,还可以使用StringBuilder类或 StringBuffer类存储字符串,在需 要频繁对字符串进行修改操作时使用StringBuilder的效率比String要高. String 类具有是不可变性.如: 运行结果: 从运行结果中我们可以看到,程序运行时会额外创建一个对象,保存 "helloworld".当频繁操作字符串时,就会额 外产生很多临时变量.使用S

JAVA API(一)String类和StringBuffer类

1.String类和StringBuffer类 在程序中经常会用到字符串,所谓的字符串就是指一连串的字符,它是由多个单个字符连接而成的.字符串中可以包含任意字符,这些字符必须包含在一对双引号""之内,如"abc".在Java中定义了String和StringBuffer类来封装字符串,并提供了一系列操作字符串的方法,它们都位于java.lang包中,因此不需要导包就可以直接使用.下面将对String类和StringBuffer类详细讲解. 1.1String类的初始

(1)StringBuilder类和StringBuffer类 (2)日期相关的类 (3)集合框架 (4)List集合

1.StringBuilder类和StringBuffer类(查手册会用即可)1.1 基本概念 由于String类描述的字符串内容无法更改,若程序中出现大量类似的字符串时需要申请独立的内存空间单独保存,此时对内存空间的消耗比较大. 为了节省内存空间希望对字符串内容本身直接进行更改,则需要使用java.lang.StringBuilder类或者java.lang.StringBuffer类. 其中StringBuffer类是从jdk1.0开始存在,是一个线程安全的可变字符序列,效率比较低 其中St

一大波Java来袭（四）String类、StringBuilder类、StringBuffer类对比

本文主要介绍String类.StringBuffer类.StringBuilder类的区别  : 一.概述 (一)String 字符串常量,但是它具有不可变性,就是一旦创建,对它进行的任何修改操作都会创建一个新的字符串对象. (二)StringBuffer 字符串可变量,是线程安全的,和StringBuilder类提供的方法完全相同. 区别在于StringBuffer每个方法中前面添加了"synchronized",保证其是线程安全的. (三)StringBuilder 字符串可变量,

一大波Java来袭（四）String类、StringBuilder类、StringBuffer类对照

本文主要介绍String类.StringBuffer类.StringBuilder类的差别  : 一.概述 (一)String 字符串常量.可是它具有不可变性,就是一旦创建,对它进行的不论什么改动操作都会创建一个新的字符串对象. (二)StringBuffer 字符串可变量,是线程安全的,和StringBuilder类提供的方法全然同样. 差别在于StringBuffer每一个方法中前面加入了"synchronized",保证其是线程安全的. (三)StringBuilder 字符串可

新手学JAVA（二）----String类与StringBuffer类的区别

在Java中有两种字符串的操作:String类和StringBuffer类(缓冲字符串处理类). 下面先简单的说一下两者的区别. String类和StringBuffer类都提供了相应的方法实现字符串的操作,但二者略有不同. (1) String类 该类一旦产生一个字符串,其对象就不可变.String类的内容和长度是固定的.如果程序需要获得字符串的信息需要调用系统提供的各种字符串操作方法实现.虽然通过各种系统方法可以对字符串施加操作,但这并不改变对象实例本身,而是生成一个新的实例.系统为Stri

String类，StringBuffer类转字符数组

String不可变类型和StringBuffer可变类型 String类和StringBuffer类都是字符串表示类,区别在于String对象引用变量是不可变的,而StringBuffer类对象引用变量是可变的. 我当时学的时候也会很不理解这个可变不可变的区别,后面看了一篇博客才懂了这个意思(https://www.cnblogs.com/yumiaoxia/p/9010721.html#commentform). 方法传参,基本数据类型传的是常量值,而引用数据类型传的是地址值.但是String

JAVA学习第三十一课（常用对象API）- StringBuffer类&amp;&amp;StringBuilder类

StringBuffer类 字符串的组成原理就是通过该类实现的 StringBuffer可以对字符串内容进行增删 StringBuffer是一个容器 很多方法和String相同 一.特点 StringBuffer字符串缓冲区,用于存放数据的容器 1.可变长度的 2.可以存储不同的数据类型 3.最终要转成字符串进行使用 4.对字符串进行修改 容器的特点: 1.添加  append(data) insert(index,data); 2.删除 StringBuffer delete(int star

【java】String类和StringBuffer类常用操作

String类是字符串常量,是不可更改的常量.而StringBuffer是字符串变量,它的对象是可以扩充和修改的.StringBuffer在进行字符串处理时,不生成新的对象,在内存使用上要优于String类.所以在实际使用时,如果经常需要对一个字符串进行修改,例如插入.删除等操作,使用StringBuffer要更加适合一些. String类主要方法的使用一.创建并初始化字符串: String s = "hello!"; //使用字符串常量直接初始化 String(); //使用构造方法