String 类概述及使用；附 StringBuilder 和 StringBuffer 类

最新推荐文章于 2023-04-02 15:22:07 发布

算前言，总轻负

最新推荐文章于 2023-04-02 15:22:07 发布

阅读量262

点赞数 1

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_36549593/article/details/98496905

版权

Java基础专栏收录该内容

22 篇文章 1 订阅

订阅专栏

1.String概述

String 变量名= “到底是什么？”

想必大家对String 变量名= “ ”；已经使用的非常熟练了，除了知道它是字符串以外，还知道它的那些信息呢？可是字符串又是个什么东西？以下便是对String的认识：

先从数据类型说起：因为字符类型char，只能表示单个字符，不能表示由多个字符连接而成的字符串。为了表示一串字符，使用称为String（字符串）的数据类型。通常我们的用法为String 变量名 = “字符串”；。从本质上来看String字符串便是char类型数组；

但String实际上与System，Scanner和Arrays类一样，都是Java库中一个预定义的类。所以它是引用数据类型，而不是基本数据类型。而且任何Java类都可以将变量表示为引用数据类型。

2.创建字符串

在Java中将字符串作为对象来使用，因此可以像创建其他类对象一样来创建字符串对象。String常用构造方法：

1. String(char[] value)

char[] chars = {'s','t','u','d','e','n'};
String str = new String(chars);

System.out.println(str);
//输出
//studen

等价于

String str = "studen";

2. String (char[] value, int offset, int count)

char[] chars = {'s','t','u','d','e','n'};
String str = new String(chars,1,3);

System.out.println(str);
//输出
//tud

3.String方法

3.1 String对象的简单方法

        String str = "ABCDEFG";
        String str1 = "  ABCDEFG  ";
        String str2 = "abcdefg";

        System.out.println(str.length());
        //输出    7
        System.out.println(str.charAt(3));
        //输出    D
        System.out.println(str.concat(str2));
        //输出    ABCDEFGabcdefg
        System.out.println(str2.toUpperCase());
        //输出    ABCDEFG
        System.out.println(str.toLowerCase());
        //输出    abcdefg
        System.out.println(str1.trim());
        //输出    ABCDEFG     (两边无空格)

需注意：

字符串和数组一样，第一位的索引为0；
获取字符串的长度，需要.length();这是String类中的方法，空字符串的长度为0；
为避免越界访问字符，要确保使用的下标不会超过s.length()-1; 例如：s.charAt(s.length())；会报StringlndexOutOfBoundsException异常（角标越界）；
连接字符串String s3 = s1.concat(s2) ; 等价于 String s3 = s1 + s2;

3.2 String对象的比较方法

        String str = "ABCDEFG";
        String str1 = "DEF";
        String str2 = "abcdefg";
        System.out.println(str.equals(str2));
        //输出    false
        System.out.println(str.equalsIgnoreCase(str2));
        //输出    true
        System.out.println(str.compareTo(str2));
        //输出    -32
        System.out.println(str.compareToIgnoreCase(str2));
        //输出    0
        System.out.println(str.startsWith("B"));
        //输出    false
        System.out.println(str.endsWith("G"));
        //输出    true
        System.out.println(str.contains(str1));
        //输出    true

需注意：

比较字符串内容使用.equals()；而不是 == ，可以理解为.equals()比较的的是内容；==比较的是地址
比较字符串大小使用.compareTo(); 而不是 > , >= 这样的比较符，会报语法错误，编译无法通过

3.3 String获取子串的方法

        String str = "da ge ni lai le";
         str = str.substring(0,9)+"zou le";
        //str = da ge ni zou le

需注意：

.substring(0,9);截取的角标为0-8

3.4 String找出字符或字串的位置

        "Welcome to Java".indexOf('W');     //return 0;
        "Welcome to Java".indexOf('o');     //return 4;
        "Welcome to Java".indexOf('o',5);     //return 9;
        "Welcome to Java".indexOf("come");     //return 3;
        "Welcome to Java".indexOf("Java",5);     //return 11;
        "Welcome to Java".indexOf("java",5);     //return -1;

        "Welcome to Java".lastIndexOf('W');     //return 0;
        "Welcome to Java".lastIndexOf('o');     //return 9;
        "Welcome to Java".lastIndexOf('o',5);     //return 4;
        "Welcome to Java".lastIndexOf("come");     //return 3;
        "Welcome to Java".lastIndexOf("Java",5);     //return -1;
        "Welcome to Java".indexOf("Java");     //return 11;

3.5 字符串和数字间的转换

可以将数值型字符串转换为数值：

转int值：

        String intString = "123";
        int intValue = Integer.parseInt(intString);

转double值：

        String doubleString = "123";        
        double doubleValue = Double.parseDouble(intString);
        System.out.println(doubleValue);

需注意：

转换的字符串不能是String str = "1,12,123";

或者数值转字符串：

int in = 123;
String str = in+"";

//str = 123+"";    123加一个空字符串

3.6字符串与数组之间的转换

字符串转数组：

char[] chars = "Java".toCharArray();

数组转字符串：

char[] chars = {'s','t','u','d','e','n'};
String str = new String(chars);

提示：

1.String对象是不可改变的。字符串一旦创建，内容不能再改变。

//字符串123,需要在后面添加456
String s = "123";
//会这样写
s = s + "456"
//这样s的值便成了"123456"


这并不是直接在123的后边加456;
添加流程是这样的：123和456是两个字符串对象内容，将这两个内容相加产生了一个新的字符串内容123456

2.String 变量存储的是对 String 对象的引用，String 对象里存储的才是字符串的值。严格地讲，术语 String 变量、String 对象和字符串值是不同的。但在大多教情况下，它们之间的区别是可以忽略的。为简单起见，术语字符串将经常被用于指 String 变量、 String 对象和字符串的值。

案例

//创建明文数组，状态数组
//每猜对一个字母，状态数组对应角标值发生改变
import java.util.Random;
class Class34{
    public static void main(String[] args){
        String[] words={
            "apple","computer","refrigerator",
            "banana","congratulation","reverse",
            "monkey","naruto","sasuke","wangquanze"
        };
        WordGame wg=new WordGame(words);
        wg.startGame();
    }
}
class WordGame{
    private String[] words; //用户传入的单词表
    private String word;    //当前正在猜测的单词
    private boolean[] states;//当前单词的密文状态
    private Random random;
    private int missCount=0;
    public WordGame(String[] words){
        this.words=words;
        this.random=new Random();
    }
    public void startGame(){
        while(true){
            //1.随机产生一个单词
            word=words[random.nextInt(words.length)];
            //2.创建该单词的密文状态表
            states=new boolean[word.length()];
            //3.根据密文状态 生成提示单词
            while(!isGameOver()){
                String str=getWord();
                System.out.print("Enter a letter in word "+str+":");
                String ch=In.getString();
                if(word.contains(ch)){
                    //改变密文状态
                    changeStates(ch);
                }else{
                    System.out.println(ch+" is not in the word");
                    missCount++;
                }
            }
            System.out.println("The word is "+word+".You missd "+missCount+" time");
            System.out.print("Do you want to guess another word? Enter y or n:");
            String choice=In.getString();
            if(choice.equals("y")){
                missCount=0;
                continue;
            }else{
                break;
            } 
        }
               
        
    }
//状态数组值有false时，说明密文没有猜完
    private boolean isGameOver(){
        for(int i=0;i<states.length;i++){
            if(states[i]==false){
                return false;
            }
        }
        return true;
    }
    private void changeStates(String ch){
        //abba
        //0110
//如果猜对其中字母，状态数组对应角标为true或重复
        for(int i=0;i<word.length();i++){
            if(ch.equals(word.charAt(i)+"")){
                if(states[i]==true){
                    System.out.println(ch+" is already in the word");
                    return;
                }else{
                    states[i]=true;
                }
            }
        }
    } 
//打印密文猜出来的打印其值，没猜出来的打印*
    private String getWord(){
        //word
        //0101
        //*o*d
        String str="";
        for(int i=0;i<states.length;i++){
            if(states[i]){
                str+=word.charAt(i);
            }else{
                str+="*";
            }
        }
        return str;
    }
}

4. StringBuilder 和 StringBuffer 类

StringBuilder 和 StringBuffer 类，二者类似String类，区别在于String类是不可改变的，可以给一个StringBuilder 或 StringBuffer 中添加，插入或追加新的内容，但是String对象一旦创建，它的值就确定了，不可更改（上方3.6的提示）。
StringBuilder和StringBuffer的初始容量为16个字符，超过16个字符会自动扩容。
StringBuilder和StringBuffer类提供了几个重载方法，可以将 boolean、char、char 数组、double、 float、int、long 和 String 类型值追加到字符串构建器（参数列表）；

StringBuilder和StringBuffer区别：

StringBuffer 线程安全（线程同步），可变的字符序列。适合多线程的时候的使用
StringBuilder 线程不安全（线程不保证同步），单线程模式中优先选择。它在大多数实现将更快。

提示：：如果一个字符串不需要任何改变，则使用 String 类。 Java 可以完成对 String 类的优化，例如：共享限定字符串等。

4.1 创建StringBuffer同StringBuilder

    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();   //默认长度
        //通过  sb.xxx(); 使用它的方法
        StringBuffer sb1 = new StringBuffer(20);    //长度设置为20
        
    }

注意：合适的初始容量能够使程序更加有效，容量过大会浪费内存空间，可以使用trimToSize()方法将容量降到实际的大小

4.2修改字符串方法（StringBuilder 和 StringBuffer）

        StringBuilder sb = new StringBuilder();
        sb.append("早晨");
        sb.append('吃');
                             //早晨吃
        sb.insert(2,"起床");
                             //早晨起床吃
        sb.insert(5,"早饭");
                             //早晨起床吃早饭
        sb.delete(0,2);
                             //起床吃早饭
        sb.replace(3,5,"鸡蛋卷");
                             //起床吃鸡蛋卷
        sb.reverse();
                             //卷蛋鸡吃床起
        sb.setCharAt(0,'J');
                             //J蛋鸡吃床起

4.3 获取属性的方法

        StringBuffer sb = new StringBuffer();
        sb.append("早晨起床吃蛋卷");
        System.out.println(sb.toString());  //早晨起床吃蛋卷
        System.out.println(sb.capacity());  //16 sb的空间
        System.out.println(sb.charAt(2));   //起
        System.out.println(sb.length());    //7
        sb.setLength(6);    //字符串构造器长度（字符串的长度）设置为 6
        System.out.println(sb.toString());  //早晨起床吃蛋
        System.out.println(sb.substring(3));    //床吃蛋
        System.out.println(sb.capacity());  //16 sb的空间
        System.out.println(sb.substring(0,2));  //早晨
        sb.trimToSize();    //如果缓冲区大于保持其当前字符序列所需的缓冲区，则可以将其调整大小以变得更加空间有效
        System.out.println(sb.capacity());  //6  sb的空间

capaciter()方法返回的是当前的容量。是能够储存的字符数量
length()方法返回的是实际储存的字符数量。
setLength(newLength)方法设置字符串的长度。如果newLength小于字符串构造器的当前长度，则字符串构建器会被截短到恰好能包含由参数 newLength 给定的字符个数。如果参数 newLength大于或等于当前长度，则给字符串构建器追加足够多的空字符（’\u0000‘ )，使其长度 length变成新参数newLength。参数 newLength 必须大于等于 0。

注意：

字符串的长度总是小于或等于构建器的容量。长度是存储在构建器中的字符串的实际大小，而容量是构建器的当前大小。如果有更多的字符添加到字符串构建器，超出它的容量，则构建器的容量就会自动增加。在计算机内部，字符串构建器是一个字符数组，因此，构建器的容量就是数组的大小。如果超出构建器的容量，就用新的数组替换现有数组。新数组的大小为2x( 之前数组的长度 +1)。

算前言，总轻负

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
String 类概述及使用；附 StringBuilder 和 StringBuffer 类

1.String概述String 变量名= “到底是什么？”想必大家对String 变量名= “ ”；已经使用的非常熟练了，除了知道它是字符串以外，还知道它的那些信息呢？可是字符串又是个什么东西？以下便是对String的认识：先从数据类型说起：因为字符类型char，只能表示单个字符，不能表示由多个字符连接而成的字符串。为了表示一串字符，使用称为String（字符串）的数据类型。通...
复制链接

扫一扫