常用类--String

一、String

1.1 String是不可变对象

String的底层是一个 char类型字符数组
String类是final修饰的，不能被继承，不能改变，但引用可以重新赋值
String采用的编码方式是Unicode方式
通过 new 创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同；
以“”方式给出的字符串，只要字符序列相同（顺序和大小），无论在程序代码中出现几次，JVM都会建立一个 String 对象，并在字符串池中维护。
String是一个引用类型

1.2 String常量池

java为了提高性能，静态字符串在常量池中创建并且是同一对象，使用时直接拿去用；
对于重复的字符串直接量会在jvm会去常量池中查找，如果有则返回，无则创建

public class string01 {

    public static void main(String[] args) {

        //在常量池中查找，没有创建一个

        String s="Hello";

        //在常量池中查找，有的话不会创建新对象

        String s1="Hello";

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

        String s2=new String("Hello");//新建一个对象

        System.out.println(s1==s2);//false

    }

}

String s= new String("a");创建了几个对象？
两个或一个，如果常量池中有a则返回总共1个，如果没有则创建a，加上new关键字是2个

1.3 String构造方法

package cn.tedu.day02;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.io.UnsupportedEncodingException;

public class String02 {

    public static void main(String[] args) throws UnsupportedEncodingException {

        /*

        * String的构造方法：1、无参构造*/

        String s=new String();

        System.out.println(s);

        /*

        * utf-8*/

        String s1=new String(new byte[]{'1','2','3','4'},1,3,"utf8");

        System.out.println(s1);

        String s2=new String(new char[]{'H','e','l','l','o'});

        System.out.println(s2);

        String s3=new String(new char[]{'A','B','C'},1,2);

        System.out.println(s3);

        String s4=new String(new int[]{'1','2','3'},1,2);

        System.out.println(s4);

        String s5=new String(new StringBuffer("high"));

        System.out.println(s5);

        String s6=new String(new StringBuilder("agh"));

        System.out.println(s6);

    }

}

1.4.1 String的判断方法

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

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

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

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

package cn.tedu.day02;

public class String03 {

    public static void main(String[] args) {

        String s="abc";

        String s1="Aac";

        String s2=new String("abc");

        /*第一种比较的方式*/

        System.out.println(s==s2);//f 比较的对象，比较的地址值

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

        //2、不区分大小写

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

        //3、判断以什么开始

        System.out.println(s.startsWith("ab"));

        //4、判断以什么结束

        System.out.println(s.endsWith("c"));

    }

}

1.4.2 String的截取

int length(): 获取字符串的长度，其实也就是字符个数
char charAt(int index): 获取指定索引处的字符
int indexOf(String str): 获取 str 在字符串对象中第一次出现的索引
String substring(int start): 从 start 开始截取字符串
String substring(int start,int end): 从 start 开始，到 end 结束截取字符串。前包后不包

public class String04 {

    public static void main(String[] args) {

        String s="Hello";

        String s1="liyimeng";

        String s2=new String(new char[]{1,2,3});

        System.out.println(s.length());//5

        System.out.println(s1.length());//8

        System.out.println(s2.length());//3

        //第一种；charAt:根据索引找字符串

        System.out.println(s.charAt(2));//h

        //第二种：indexOf：根据字符串找索引

        System.out.println(s.indexOf("H"));//0

        System.out.println(s1.indexOf('y',2));//2

        //第三种：substring

        System.out.println(s.substring(1));//ello

        //第四种：substring(前包后不包）字符串没变，创建了一个新串

        System.out.println(s.substring(1,4));//ell

1.4.3 String的转换

char[] toCharArray()：把字符串转换为字符数组
String toLowerCase()：把字符串转换为小写字符串
String toUpperCase()：把字符串转换为大写字符串

import java.util.Arrays;

import java.util.Locale;

public class String05 {

    public static void main(String[] args) {

        String s="l y m";

        //1、toCharArray把字符串转化为字符数组

        char c[]=s.toCharArray();

        System.out.println(Arrays.toString(c));

        c=new char[]{'H','e','l','l','o'};

         String s1=new String(c);

        System.out.println(s1);

        //2、toUpperCase全部变大写

        System.out.println(s.toUpperCase(Locale.ROOT));

        //3、toLowerCase全部变小写

        System.out.println(s.toLowerCase(Locale.ROOT));

    }

}

1.4.4 其他方法

String trim(): 去除字符串两端空格
String[] split(String str): 按照指定符号分割字符串

import java.util.Arrays;

public class String06 {

    public static void main(String[] args) {

        String s="  hello  world  ";

        //trim:去除字符串两端空格(中间的不去）字符串不可变

        System.out.println(s.trim());

        //split：分割字符串

        System.out.println(s.length());

        System.out.println(Arrays.toString(s.split("h")));

        System.out.println(s.length());

        String s2="www.baidu.com";

        //1、获取两个点的索引

        int start=s2.indexOf(".");

        int end=s2.lastIndexOf(".");

        String result=s2.substring(start+1,end);

        System.out.println((result));

        //String api中的方法进行测试

    }

}


1.5 StringBuilder

1.5.1 可变字符串

StringBuilder 是一个线程非安全的可变字符序列
StringBuilder 底层在其父类中封装了一个 char类型的数组
StringBuilder 创建了一个初始容量为 16

//构造方法

public class StringBuilder01

public class StringBuilder01 {

    public static void main(String[] args) {

        //构造方法

        StringBuilder sb=new StringBuilder();

        System.out.println("无参构造方法："+sb);

        System.out.println("初始容量："+sb.capacity());

        //

        StringBuilder sb1=new StringBuilder(32);

        System.out.println("自定义容量："+sb1.capacity());

        //

        StringBuilder sb2=new StringBuilder("hello");

        System.out.println("容量："+sb2.capacity());

        System.out.println(sb2);

    }

}

    public static void main(String[] args) {

        //构造方法

        StringBuilder sb=new StringBuilder();

        System.out.println("无参构造方法："+ sb);

        System.out.println("初始容量："+sb.capacity());

        StringBuilder sb1=new StringBuilder(32);

        System.out.println("自定义容量："+sb1.capacity());

        StringBuilder sb2=new StringBuilder("hello");

        System.out.println("容量："+sb2.capacity());

        System.out.println(sb2);

    }

}

1.5.2 常用方法

append（任意内容）：追加字符串，数组放满，容量翻倍
追加扩容问题：
- 扩容实现原理：数组的 arrays.copyOf() 方法

• 扩容算法：原数组容量 * 2 + 2

• 测试：

public class String02 {

    public static void main(String[] args) {

        StringBuilder stringBuilder=new StringBuilder("hello");

        System.out.println(stringBuilder. append("lllllllllllllllllllll"));

        System.out.println("sb的容量："+stringBuilder.capacity());

        System.out.println("sb的内容："+stringBuilder);

        System.out.println("sb的长度："+stringBuilder.length());

        System.out.println(stringBuilder. append("lllllllllllllllllllllllll"));//超出的字符串长度*2+2

        System.out.println("sb的容量："+stringBuilder.capacity());

        System.out.println("sb的内容："+stringBuilder);

        System.out.println("sb的长度："+stringBuilder.length());

    }

}

insert（int ，任意类型）：插入
delete（int start，int end）：删除
replace（int start，int end，String s）：替换
reverse（）：反转

public class StringBuilder04 {

    public static void main(String[] args) {

        //insert:

        StringBuffer stringBuffer=new StringBuffer("hello");

        stringBuffer.insert(2,"lym");

        System.out.println(stringBuffer);

        //delete:

        StringBuffer stringBuffer1=new StringBuffer("lym");

        System.out.println(stringBuffer1.delete(1,3));

        //replace:

        StringBuffer stringBuffer2=new StringBuffer("zhangsan");

        System.out.println(stringBuffer2.replace(1,5,"qqq"));

        //reverse:反转

        System.out.println(stringBuffer.reverse());

    }

}

方法返回值问题
- 因为这些方法的返回值语句是 return this; 因此可以连续调用

public class String05 {

    public static void main(String[] args) {

        StringBuilder stringBuilder=new StringBuilder();

        stringBuilder.append("hello").append("lym").append(1).replace(2,5,"zhang").reverse();

        System.out.println(stringBuilder);

    }

}

1.5.4 StringBuilder和StringBuffer的区别：

StringBuffer 是线程安全的

• StringBuilder是线程非安全的，因此运行速率较快

1.5.5 StringBuilder和String相互转化：

1、StringBuilder转换为String

public String toString(): 通过 toString（）就可以实现把StringBuilder转换为String

2、String转换为StringBuilder

pubilc StringBuilder(String s): 通过构造方法就可以实现String转换为StringBuilder

巴特西