• 一、String 简介
  • 1.1 String 概述
  • 1.2 分析 String 源码
  • 二、创建 String 对象的两种方式
  • 2.1 通过构造方法创建对象
  • 2.2 直接赋值创建对象
  • 2.3 两种方式的比较
  • 三、String 常用方法
  • 3.1 String的获取操作
  • 3.2 String 的转换操作
  • 3.3 String 的替换与去除功能
  • 3.4 String 的截取与分割操作
  • 3.5 String 的判断操作
  • 3.5 String 的比较操作




一、String 简介

1.1 String 概述

  • String 代表字符串，其实就是字符串常量。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
  • String 类被 final 关键字修饰，意味着 String 类不能被继承，并且它的成员方法都默认为 final 方法，字符串一旦创建就不能再修改，所以只要一个值改变就会生成一个新的String类型对象。
  • String 对象是不可变的，所以可以共享。字符串缓冲区支持可变的字符串，后续会讲到 StringBuffer 。
  • String 类实现了 Serializable、CharSequence、 Comparable 接口。
  • String 实例的值是通过字符数组实现字符串存储的。存储 String 数据也不一定从数组的第 0 个元素开始的，而是从 offset 所指的元素开始。


1.2 分析 String 源码

1）String 的成员变量

/** String的属性值 */  
    private final char value[];

    /** The offset is the first index of the storage that is used. */
    /**数组被使用的开始位置**/
    private final int offset;

    /** The count is the number of characters in the String. */
    /**String中元素的个数**/
    private final int count;

    /** Cache the hash code for the string */
   /**String类型的hash值**/
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
    /**
     * Class String is special cased within the Serialization Stream         Protocol.
     *
     * A String instance is written into an ObjectOutputStream according to
     * <a href="{@docRoot}/../platform/serialization/spec/output.html">
     * Object Serialization Specification, Section 6.2, "Stream Elements"</a>
     */

　　private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];

2）String 的构造方法

String() 
          初始化一个新创建的 String 对象，使其表示一个空字符序列。 
String(byte[] bytes) 
          通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。 
String(byte[] bytes, Charset charset) 
          通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。  
String(byte[] bytes, int offset, int length) 
          通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。 
String(byte[] bytes, int offset, int length, Charset charset) 
          通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。 
String(byte[] bytes, int offset, int length, String charsetName) 
          通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。 
String(byte[] bytes, String charsetName) 
          通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。 
String(char[] value) 
          分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。 
String(char[] value, int offset, int count) 
          分配一个新的 String，它包含取自字符数组参数一个子数组的字符。 
String(int[] codePoints, int offset, int count) 
          分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。 
String(String original) 
          初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。 
String(StringBuffer buffer) 
          分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。 
String(StringBuilder builder) 
          分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。




二、创建 String 对象的两种方式

2.1 通过构造方法创建对象

// 通过构造方法创建字符串对象是在堆内存

String str = new String("hello");//实例化的方式



2.2 直接赋值创建对象

// 直接赋值方式创建对象是在方法区的常量池

String str = "hello";//直接赋值的方式



2.3 两种方式的比较

public class Main {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = new String("Hello");
        String str3 = str2; //引用传递，str3直接指向st2的堆内存地址
        String str4 = "Hello";
        /**
         *  ==:
         * 基本数据类型：比较的是基本数据类型的值是否相同
         * 引用数据类型：比较的是引用数据类型的地址值是否相同
         * 
         * 结论：
         * 1、String类对象通过 “==” 比较，比较的是地址，而不是内容
         * 2、String类对象通过 “equals()” 比较，比较的是内容，而不是地址
         */
         System.out.println(str1 == str2);// false
         System.out.println(str1 == str3);// false
         System.out.println(str2 == str3);// true
         System.out.println(str1 == str4);// true
         
         System.out.println(str1.equals(str1));// true
         System.out.println(str1.equals(str3));// true
         System.out.println(str2.equals(str3));// true
         System.out.println(str1.equals(str4));// true
    }

}




三、String 常用方法

话不多说，先上图！！！

java截取第一个字符串之前的 javastring取第一个字符_java截取第一个字符串之前的

3.1 String的获取操作

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

// 如果是要获取数组长度的话，直接用 arr.length，不用括号
	String str = "Hello";
	int len = str.length();
	System.out.println(len);// 5



2）获取字符串中的第 i 个字符： char charAt(i)

// 格式：char ch = str.charAt(i);  // i为字符串中字符的索引
	String str = "Hello";
    char ch = str.charAt(4);// 下标从0开始
    System.out.println(ch);// o



3）获取指定字符在字符串中第一次出现的索引： int indexOf(int ch)

String str = "Hello";
    int n = str.indexOf('e');// 直接传入字符即可，返回下标从 0 开始
    System.out.println(n);// 1



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

String str = "Helloelp";
    int n = str.indexOf('e', 4);
    System.out.println(n);// 1



5）获取指定字符串在字符串中第一次出现的索引： int indexOf(String s)

String str = "Hello";
    int n = str.indexOf("llo");
    System.out.println(n);// 2



6）获取指定字符串在字符串中从指定位置开始第一次出现的索引： int indexOf(String s, int fromIndex)

String str = "Hellopoallohi";
    int n = str.indexOf("llo",5);
    System.out.println(n);// 8



7）获取指定字符在字符串中最后一次出现的索引： int lastIndexOf(int ch)

String str = "Hellopoallohi";
    int n = str.lastIndexOf('o');
    System.out.println(n);// 10
// 同理，可根据以上方法知道 lastIndexOf() 的其他重载函数，不一一列出来了




3.2 String 的转换操作

1）把字符串转换为字符数组： char[] toCharArray()

2）把字符串转换为小写字符串： String toLowerCase()

3）把字符串转换为大写字符串： String toUpperCase()

4）将 Object 型转换为字符串类型： String valueOf(Object obj)



public class TestString {
    public static void main(String[] args) {
         // 创建字符串对象
        String s = "abcde";
 
        // char[] toCharArray():把字符串转换为字符数组
        char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }
 
        System.out.println("-----------");
 
        // String toLowerCase():把字符串转换为小写字符串
        System.out.println("HelloWorld".toLowerCase());// helloworld
        // String toUpperCase():把字符串转换为大写字符串
        System.out.println("HelloWorld".toUpperCase());// HELLOWORLD

		String str1 = String.valueOf(1243);
    	String str2 = String.valueOf(true);
    	String str3 = String.valueOf(3.5);
    	System.out.println(str1 + "..." + str2 + "..." + str3);// 1243...true...3.5
        
    }

}




3.3 String 的替换与去除功能

1）把字符串中的指定字符替换为目标字符： String replace(char oldChar, char newChar)

2）把字符串中的指定字符串替换为目标字符串： String replace(CharSequence taget, CharSequence replacement)

3）去除字符串两端空格并返回一个新字符串： String trim()



public class Main {
    public static void main(String[] args) {
    	String str = "hello world";
    	String str1 = str.replace('e', 'o');
    	System.out.println(str);// hello world 因为replace() 并不会改变原字符串
    	System.out.println(str1);// hollo world
    	
    	String str2 = str.replace("world", "java");
    	System.out.println(str2);// hello java
    	
    	String s = "   java    ";
    	String ss = s.trim();// 不会改变原字符串
    	System.out.println(s);// 输出“   java    ”
    	System.out.println(ss);// 输出"java"
    }

}




3.4 String 的截取与分割操作

1）截取从索引 beginIndex 后的字符串（包括beginIndex）： String substring(int beginIndex)

2）截取索引区间 [beginIndex, endIndex) 的字符串： String substring(int beginIndex, int endIndex)

3）根据参数regex将字符串分割为若干个字符串并存入字符串数组： String[] split(String regex)



public class Main {
    public static void main(String[] args) {
    	String str = "hello,world,java,c,python";
    	String str1 = str.substring(2);
    	String str2 = str.substring(2, 5);
    	System.out.println(str1);// llo,world,java,c,python
    	System.out.println(str2);// llo
    	String[] ss = str.split(",");
    	for (int i = 0; i < ss.length; i++)// hello world java c python 
    		System.out.print(ss[i]+" ");
    }
}




3.5 String 的判断操作

1）比较字符串的内容是否相同： boolean equals(Object obj)

2）比较字符串的内容是否相同,忽略大小写： boolean equalsIgnoreCase(String str)

3）判断字符串对象是否以指定的字符串 str 开头： boolean startsWith(String str)

4）判断字符串对象是否以指定的字符串 str 结尾： boolean endsWith(String str)

5）判断字符串是否包含指定字符序列： boolean econtains(CharSequence cs)

6）判断字符串长度是否为 0 ： boolean isEmpty()



public class Main {
    public static void main(String[] args) {
    	String s1 = "hello";
        String s2 = "hello";
        String s3 = "Hello";
 
        // 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));// false
 
        // boolean startsWith(String str):判断字符串对象是否以指定的str开头
        System.out.println(s1.startsWith("he"));// true
        System.out.println(s1.startsWith("ll"));// false
        
        System.out.println(s1.endsWith("lo"));// true
        System.out.println(s1.endsWith("ll"));// false
        
        System.out.println(s1.contains("ll"));// true
        
        System.out.println(s1.isEmpty());// false
    }

}




3.5 String 的比较操作

根据字典序比较两个字符串大小：int compareTo(String anotherString)

返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至比较的字符或被比较的字符有一方结束。

  • 如果参数字符串等于此字符串，则返回值 0；
  • 如果此字符串小于字符串参数，则返回一个小于 0 的值；
  • 如果此字符串大于字符串参数，则返回一个大于 0 的值。
//一般根据返回的正负数比较他们的大小
String str1 = "Strings";
String str2 = "Strings";
String str3 = "Strings123";

int result = str1.compareTo(str2);
System.out.println(result);// 0

result = str2.compareTo(str3);
System.out.println(result);// -3

result = str3.compareTo(str1);
System.out.println(result);// 3