String类的学习

本节内容总结来自传智播客毕向东老师的公开课，感谢毕向东老师 ！如有错误之处，欢迎大家指教 ！

 

String s = “abc”;  // “abc”是一个对象；

只要是字符串，都是String类的实例对象；

 

String s = “abc”;

String s = new String(“abc”);

两者效果是一样的，但常用第一种写法；

 

字符串既是对象，也是常量，一旦被初始化就不会再改变；

String s1 = “wsx”;

s1 = “edc”;

System.out.println(s1);  // 结果是 edc

“wsx”并没有变，变的是s1，指向了新的对象；”wsx”对象内容没变，只是s1中保存的对象地址变了；

 

String类常用的方法：

获取：

  获取字符串长度： int length();

  根据位置获取位置上的字符： char charAt(int index);

  从指定位置开始，获取字符在字符串中第一次出现的位置： int indexOf(int ch);  int indexOf(int ch, int fromIndex);

  从指定位置开始，获取子字符串在字符串中第一次出现的位置： int 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);

  获取字符串中的一部分： String subString(begin);  String subString(begin, end);

判断：

  字符串中是否包含某个字串（字符）： boolean contains(String str);  boolean contains(char ch);

  字符串中是否有内容： boolean isEmpty();

  字符串是否以指定内容开头： boolean startsWith(String str);  boolean startsWith(char ch);

  字符串是否以指定内容结尾： boolean endsWith(String str);  boolean endsWith(char ch);

  判断字符串内容是否相同： boolean equals();

  判断字符串内容是否相同，并忽略大小写： boolean equalsIgnoreCase();

转换：

  将字符数组（或部分字符数组）转成字符串：new String(char[]);  new String(char[], offset, count);

  将字符串转成字符数组： char[] toCharArray();

  将字节数组转成字符串： new String(byte[]);  new String(byte[], offset, count);

  将字符串转成字节数组： byte[] getBytes();

  将基本类型转成字符串： 3 + “”;  String.valueOf(3);

  注意：字符串和字节数组在转换过程中，是可以指定编码表的；

替换：

  替换一个字符： replcae(char oldChar, char newChar);

  替换字符串： replace(CharSequence target, CharSequence replacement);  // CharSequence是接口，就把它理解成String来用

切割：

  String[] split(regex);

转换，去除空格，比较：

  转换成大写，小写： String toUpperCase();  String toLowerCase();

  去除字符串前后空格： String trim();

  对两个字符串进行自然顺序的比较： int compareTo(String str);

StringBuffer：线程安全的可变字符序列

线程同步；

字符串缓冲区；

是一个容器，可以对字符串进行修改；

三个特点：

  长度是可变化的；

  可以直接添加多种数据类型；

  最后通过toString()方法转成字符串；

常用方法：

  存储：

  在数据末尾处添加：StringBuffer appnd();  // 形参可以是基本数据类型，String类，StringBuffer类，也可以是对象

  在任意位置插入：StringBuffer insert(index, 数据);

  删除：

  删除缓冲区中部分数据：StringBuffer delete(int start, int end);

  删除指定位置数据：StringBuffer delete(int index);

  修改：

  修改部分内容：StringBuffer replace(int start, int end, String str);

  修改某一个字符：void setCharAt(int index, char ch);

  获取：

  获取指定位置字符：char charAt(int index);

  获取字符/字符串所在位置：int indexOf(String str);

  反向获取字符、字符串所在位置：int lastIndexOf(String str);

  获取长度：int length();

  获取容器中某一部分的数据：String subString(int start, int end);

  反转：

    StringBuffer reverse();

  将缓冲区中指定数据存储到指定数组中：

    // 先定义一个字符数组：char[] ch = new char[4];

    void getChars(int srcBegin, int srcEnd, char[] char, int charBegin);  // charBegin：数组的起始位置

StringBuilder：线程不安全的可变字符序列

线程不同步；

除了线程不安全，其他都可以取代StringBuffer；

多线程用StringBuffer，单线程用StringBuilder；

基本数据类型对应的对象包装类：

  int      Integer

  char    Character

  boolean  Boolean

  short    Short

  byte     Byte

  long     Long

  float     Float

  double   Double

最常用的功能：就是基本数据类型与字符串之间的转换

   基本数据类型转字符串：

   基本数据类型 + “”;

   包装类.toString(基本数据类型值);   举例：Integer.toString(34);

   字符串转基本数据类型：

       xxx a = Xxx.parseXxx(String str);

   整型为例：Integer.parseInt(String str);

JDK1.5新特性：自动装箱拆箱

  自动装箱：

    以前写法：Integer i = new Integer(6);

    现在写法：Integer i = 6;

  自动拆箱：

    i = i + 3;  // i自动拆箱变成int型，和int型的3相加之后，再自动装箱变成Integer型

  还有一个小特性：

    // byte范围外的数据

    Integer a = 128;

    Integer b = 128;

    System.out.println(a == b);  // 结果为false

    // byte范围内的数据

    Integer a = 127;

    Integer b = 127;

    System.out.println(a == b);  // 结果应该为false，但结果为true

  解释：a和b指向了同一个Integer对象，因为当数值在byte范围之内，对于新特性，如果该数值已存在，则不会再开辟新空间；

一些实例：

/**
 * 功能：String类对象解析
 */

package string;

public class String1
{
    public static void main(String[] args)
    {
// s1在内存中有一个对象
        String s1 = "abc";
// s2在内存中有两个对象
        String s2 = new String("abc");
                
        // s1和s2是两个独立的对象，地址不一样
        // == 比较的是地址，所以结果为false
        System.out.println(s1==s2);
        
        // String类重写的继承自Object类的equals()方法
        // 只比较字符串的内容是否相等，所以返回true
        System.out.println(s1.equals(s2));
        
        String s3 = "abc";
        // 指向同一个对象，返回true
        // 因为在内存的常量池中已经存在
        System.out.println(s1==s3);
        
        String s4 = new String("abc");
        // 两个对象，返回false
        System.out.println(s2==s4);
    }
}

/**
 * 功能：字符串特性
 */
package string;

public class String2
{
    public static void main(String[] args)
    {
        test();
    }
    
    public static void test()
    {
        // 一旦被初始化，就不会再改变
        String s = "hello, java";
        // 产生新的字符串，原来的字符串不变
        String s1 = s.replace("a", "n");
        
        // 打印出来结果内容不变
        System.out.println("s:" + s);
        System.out.println("s1:" + s1);
    }
}

/**
 * 功能：将字符串反转
 */
package string;

public class String3
{
    public static void main(String[] args)
    {
        String str = "asdfghj";
        
        // 将字串串转成字符数组
        char[] charStr = str.toCharArray();
        
        // 对字符数组内容进行反转
        char[] charStr2 = reverse(charStr);
        
        // 将字符数组转成字符串
        getStr(charStr2);
    }
    
    public static char[] reverse(char[] charStr)
    {
        for(int start=0,end=charStr.length-1; start <= end; start++, end--)
        {
            swap(charStr, start, end);
        }
        
        return charStr;
    }
    
    public static void swap(char[] charStr, int start, int end)
    {
        char temp = charStr[start];
        charStr[start] = charStr[end];
        charStr[end] = temp;
    }
    
    public static void getStr(char[] charStr2)
    {
        String str = new String(charStr2);
        System.out.println("str:" + str);
    }
}

/**
 * 功能：StringBuffer特性
 */
package string;

public class StringBuffer1
{
    public static void main(String[] args)
    {
        StringBuffer sb1 = new StringBuffer();
        StringBuffer sb2 = sb1.append("123");
        
        // 结果返回true，说明是同一个对象
        System.out.println(sb1 == sb2);
        
        // 内容都一样
        System.out.println(sb1.toString());
        System.out.println(sb2.toString());
        
        // 说明：
        // StringBuffer是一个容器，不管你是往里面添加东西还是
        // 删除东西，都是在同一个容器中操作，所以定义的多个容器对象
        // 都直向给同一个对象，所以可简化上面操作
        sb2.append("456").append("789").append(true);
        // 结果显示两个对象还是相等的
        System.out.println(sb2.toString());
        System.out.println(sb1.toString());
    }
}