Java: String类

一 String类

在 Java SE 中，String 类是用于处理字符串的一个非常重要的类。字符串在 Java 中是不可变的（immutable），意味着一旦创建，字符串的内容就不能被修改。所有对字符串的操作实际上都是创建了一个新的字符串对象。

1.String对象的创建

    public static void main1(String[] args) {
        String s=new String("123456");
        String s1="123";
        char[] array={'a','b','c'};
        String s2=new String(array);
        System.out.println(s);
        System.out.println(s1);
        System.out.println(s2);
    }

2.String的比较

2.1String引用的是不同的对象。

public class Test {
    public static void main(String[] args) {
        String a=new String("abc");
        String b=new String("abc");
        String c=a;
        System.out.println(a==b);
        System.out.println(a==c);

String类型a和b分别是不同的地址，a==b就是比较a和b的地址是否相同，所以是false， String c=a;意思是将a的地址赋给c，所以a==c

代码运行结果

2.2 而equals（）比较的就是字符串的内容是否相同，如果相同则返回true，否则返回false

    public static void main(String[] args) {
        String a=new String("abc");
        String b=new String("abc");
        String c=a;
        System.out.println(a==b);
        System.out.println(a==c);
        System.out.println(a.equals(b));
        System.out.println(a.equals(c));

运行结果

2.3int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较

public class Test {
    public static void main(String[] args) {
        String a=new String("abc");
        String b=new String("abcfas");
        String c=a;

        System.out.println(a.compareTo(b));
        System.out.println(a.compareTo(c));
        System.out.println(b.compareTo(c));

3.String的长度引用

     String a=new String("abc");
        System.out.println(a.length());

4.字符串的查找

4.1 char charAt(int index)

返回index位置上字符，如果index为负数或者越界，抛出 IndexOutOfBoundsException异常

   String s=new String("aaaaavvvvvvvvddddd");
        System.out.println(s.charAt(3));

4.2 int indexOf(int ch)

返回ch第一次出现的位置，没有返回-1

String s=new String("aaaaavvvvvvvvddddd");
        System.out.println(s.indexOf('a'));

4.3 int indexOf(int ch, int fromIndex)

从fromIndex位置开始找ch第一次出现的位置，没有返回-1

 String s=new String("aaaaavvvvvvvvddddd");
        System.out.println(s.indexOf('a',3));

4.4 int indexOf(String str)

返回str第一次出现的位置，没有返回-1

String s=new String("aaaaavvvvvvvvddddd");
        System.out.println(s.indexOf("av"));

4.5 nt indexOf(String str, int fromIndex)

从fromIndex位置开始找str第一次出现的位置，没有返回-1

String s=new String("aaaaavvvvvvvvddddd");
        System.out.println(s.indexOf("av",5));

4.6 nt lastIndexOf(int ch)

从后往前找，返回ch第一次出现的位置，没有返回-1

  String s=new String("aaaaavvvvvvvvddddd");
        System.out.println(s.lastIndexOf("v"));

4.7 int lastIndexOf(int ch, int fromIndex)

从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1

String s=new String("aaaaavvvvvvvvddddd");
        System.out.println(s.lastIndexOf("v",11));

4.8 int lastIndexOf(String str)

从后往前找，返回str第一次出现的位置，没有返回-1

String s=new String("aaaaavvvvvvvvddddd");
        System.out.println(s.lastIndexOf("vvv"));

4.9 int lastIndexOf(String str, int fromIndex)

从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

        String s=new String("aaaaavvvvvvvvddddd");
        System.out.println(s.lastIndexOf("vvvv",8));

5.字符串的转化

5.1数值和字符串转化

数字转字符串

public class Test {
    public static void main(String[] args) {
        String s1=String.valueOf(1234);
        String s2=String.valueOf(12.34);
        String s3=String.valueOf(true);
        String s4=String.valueOf(new Student("ha",12));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);

    }

字符串转数字

public class Test {
    public static void main(String[] args) {
        int month=Integer.parseInt("1234");
        double month2=Double.parseDouble("12.12");
        System.out.println(month+1);
        System.out.println(month2+2);
    }

5.2大小写的转化

public class Test {
    public static void main(String[] args) {
        String s=new String("abUIUuks");
        System.out.println(s.toUpperCase());
        System.out.println(s.toLowerCase());
    }

5.3字符串和数组的转化

字符串转数组

public class Test {
    public static void main(String[] args) {
        String s=new String("abcd");
        char[] arr=s.toCharArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println();
    }

数组转字符串

public class Test {
    public static void main(String[] args) {
        String s=new String("abcd");
        char[] arr=s.toCharArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println();
        //数组转字符串
        String s1=new String(arr);
        System.out.println(s1);
    }

5.4格式化

public class Test {
    public static void main(String[] args) {
        String s=String.format("%d-%d-%d",2019,9,14);
        System.out.println(s);
    }

6.字符串的替换

String replaceAll(String regex, String replacement)

替换所有的指定内容

String replaceFirst(String regex, String replacement)

替换首个指定内容

    public static void main(String[] args) {
        String s=new String("abdhhhhddd");
        System.out.println(s.replaceAll("h","m"));
        System.out.println(s.replaceFirst("h","m"));
    }

7.字符串的拆分

String[] split(String regex)

将字符串全部拆分

public static void main(String[] args) {
        String s="helloworld";
        String[] a=s.split("w");
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }

String[] split(String regex, int limit)

将字符串以指定的格式，拆分为limit组

public class Test {
    public static void main(String[] args) {
        String s="helloworwld";
        String[] a=s.split("w",3);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }

8.字符串的截取

1.String substring(int beginIndex)

从指定索引截取到结尾

2.String substring(int beginIndex, int endIndex)

截取部分内容

public class Test {
    public static void main(String[] args) {
        String s=new String("sda156");
        System.out.println(s.substring(2));
        System.out.println(s.substring(2,5));
    }

9.others

String trim()

去掉字符串中的左右空格,保留中间空格

public class Test {
    public static void main(String[] args) {
        String s=new String("  123FD  123  ");
        System.out.println(s.trim());
    }

二字符串的不可变性

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：

并不是因为String类被final修饰，才不可变，而是因为value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改，并且由于被private修饰，所以无法被引用，所以空间里面的内容无法被修改。

所以String无法被修改，String 类的不可变性意味着每次对字符串的修改都会生成一个新的字符串对象

三字符串的修改

所以String无法被修改，String 类的不可变性意味着每次对字符串的修改都会生成一个新的字符串对象。

public class Test {
    public static void main(String[] args) {
        String s=new String("hello");
        String a=s+" "+"world";
        System.out.println(a);
    }

在上面的代码中，a+ " World" 并不会修改原来的 s 对象，而是生成了一个新的字符串 "Hello World"，然后将其赋值给 a变量。原来的 "Hello" 字符串仍然保存在内存中，直到垃圾回收机制将其清除。

四 StringBuilder和StringBuffer

1.StringBuff append(String str)

在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、 double、float、int、long、Object、String、StringBuff的变量

   StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.append("abc"));

2.char charAt(int index)

获取index位置的字符

StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.charAt(1));

3.int length()

获取字符串的长度

StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.length());

4.int capacity()

获取底层保存字符串空间总的大小

StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.capacity());

5.void setCharAt(int index, char ch)

将index位置的字符设置为ch

StringBuilder s=new StringBuilder("abc123");
        //s.setCharAt(1,'j');
        //System.out.println(s);

6.int indexOf(String str)

返回str第一次出现的位置

 StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.indexOf("b"));

7.int indexOf(String str, int fromIndex)

从fromIndex位置开始查找str第一次出现的位置

 StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.indexOf("b",1));

8.int lastIndexOf(String str)

返回最后一次出现str的位置

 StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.lastIndexOf("a"));

9.int lastIndexOf(String str, int fromIndex)

从fromIndex位置开始找str最后一次出现的位置

StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.lastIndexOf("a",1));

10.StringBuffer deleteCharAt(int index)

删除index位置字符

 StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.deleteCharAt(3));

11.StringBuffer delete(int start, int end)

删除[start, end)区间内的字符

 StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.delete(3,4));

12.StringBuffer replace(int start, int end, String str)

将[start, end)位置的字符替换为str

 StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.replace(3,4,"uuuu"));

13.String substring(int start)

从start开始一直到末尾的字符以String的方式返回

StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.substring(5));

14.String substring(int start，int end)

将[start, end)范围内的字符以String的方式返回

 StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.substring(5,6));

15.StringBuffer reverse()

反转字符串

StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.reverse());

16.String toString()

将所有字符按照String的方式返回

  StringBuilder s=new StringBuilder("abc123");
        System.out.println(s.toString());

String、StringBuffer、StringBuilder的区别

特性	String	StringBuffer	StringBuilder
可变性	不可变	可变	可变
线程安全	线程安全	线程安全	非线程安全
同步机制	不需要	方法是同步的 (`synchronized`)	没有同步机制
性能	性能较差（频繁修改时）	性能较好，但比 `StringBuilder` 慢	性能最好
使用场景	字符串内容固定，少有修改	多线程环境下需要频繁修改字符串	单线程环境下需要频繁修改字符串

五例题

1.字符串中的第一个唯一字符

给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1 。

class Solution {
    public int firstUniqChar(String s) {
        int[] count=new int[26];
        for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);
            count[ch-'a']++;
        }

          for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);
            if(count[ch-'a']==1){
                return i;
            }
        }
        return -1;
    }
}

2.最后一个单词的长度

计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）

第一种方法

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s=in.next();
        String[] arr=s.split(" ");
        int len=arr[arr.length-1].length();
        System.out.println(len);
    }
}

第二种方法

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s=in.next();
        int index=s.lastIndexOf(" ");
        int len=s.substring(index+1).length();
        System.out.println(len);

    }
}

3.检测字符串是否为回文

class Solution {
       public boolean isPalindrome(String s) {
        s=s.toLowerCase();
        int left=0;
        int right=s.length()-1;
        while(left<right){
            while(left<right && !judge(s.charAt(left))){
                left++;
            }
            while(left<right && !judge(s.charAt(right))){
                right--;
            }
            if(s.charAt(left)==s.charAt(right)){
                left++;
                right--;
            }else{
                return false;
            }
        }
        return true;
    }
    private boolean judge(char arr){
        if(Character.isDigit(arr)|| Character.isLetter(arr)){
            return true;
        }
        return false;
    }
}

希望能对大家有所帮助！！！！