Java 字符串

字符串

String类：字符串是由多个字符组成的一串数据(字符序列)的字符串常量,值改变后会重新创建一个新的对象
其结构为:
public final class String extends Object implements Serializable, Comparable, CharSequence
构造方法

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Arrays;

public class String_Dome1 {
    /*
    字符串的构造方法：1.new String()
     */
    public static void main(String[] args) throws UnsupportedEncodingException {
        String str1 = new String();//创建一个String对象，默认为空；
        System.out.println(str1);
        String str2 = new String("abc");//创建一个String对象，并为其赋值
        System.out.println(str2);
        char []ch1 = {'a','b','c','d','e'};
        String str3 = new String(ch1);//将一个char数组转化为String类型
        System.out.println(str3);
        String str4 = new String(ch1,0,4);//将一个char数组内的元素，指定起始位置（offset），指定数量（count），转换为字符串类型
        System.out.println(str4);
        String str5 = new String("abc");
        System.out.println(Arrays.toString(str5.getBytes("utf-8")));//将字符串转化为字节类型，编码，指定编码表为utf-8
        byte[] by = str5.getBytes("utf-8");
        String str6 = new String(by,"utf-8");//解码，将字节码zhaung
        System.out.println(str6);
    }
}

判断功能

public class String_Dome2 {
    public static void main(String[] args) {
        /*
                    判断功能
            boolean equals(Object obj)
            boolean equalsIgnoreCase(String str)
            boolean contains(String str)
            boolean isEmpty()
            boolean startsWith(String prefix)
            boolean endsWith(String suffix)

         */
        String str1 = "abcdefgh";
        String str2 = new String("abcdefgh");
        String str3 = new String("abcDefgH");
        System.out.println(str1 == str2);
        //判断字符串的地址是否相等
        System.out.println(str1.equals(str2));
        //判断字符串的值是否相等
        System.out.println(str1.equalsIgnoreCase(str3));
        //判断字符串的值是否相等,不区分大小写
        System.out.println(str1.contains("abc"));
        //判断字符串是否包含"abc";
        System.out.println("".isEmpty());
        //判断字符串是否为空
        System.out.println(str1.startsWith("abcd"));
        //判断字符串是否以"abcd"开头
        System.out.println(str1.endsWith("fgh"));
        //判断字符串是否以"fgh"结尾
    }
}

获取功能

public class String_Dome3 {
    /*
          获取功能
        int length()
        char charAt(int index)
        int indexOf(String str)
        int indexOf(String str,int fromIndex)
        String substring(int start)
        String substring(int start,int end)
     */
    public static void main(String[] args) {

    String str1 = new String("abcdefabcd");
    //                               0123456789
        System.out.println(str1.length());
        //获取字符串的长度（注意字符串和数组获取长度的方式，数组是调用属性使用的是length,字符串调用的则是方法使用的是length()）
        System.out.println(str1.charAt(6));
        //输入字符串的索引值，返回该索引值对应的字符
        System.out.println(str1.indexOf("a"));
        //查找字符串指定字符在该字符串第一次出现的索引值
        System.out.println(str1.indexOf("a",str1.indexOf("a")+1));
        //指定字符串起始位置，返回其位置之后要查找的字符的索引值
        System.out.println(str1.lastIndexOf("a"));
        //倒叙查找元素，返回其索引值
        System.out.println(str1.substring(6));
        //字符串的拼接
        System.out.println(str1.substring(1,6));
        //输出一个新的字符串，指定区间
    }
}

转换功能

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class String_Dome4 {
//    转换功能
//    byte[] getBytes()
//    char[] toCharArray()
//    static String valueOf(char[] chs)
//    String toLowerCase()
//    String toUpperCase()
//    String concat(String str)
//    Stirng[] split(分割符);
    public static void main(String[] args) {
        String str1 = new String("abc");
        try {
            System.out.println(Arrays.toString(str1.getBytes("utf8")));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        //将字符串转化为字节类型，编码，指定编码表为utf-8
        String str2 = new String("abcd");
        System.out.println(Arrays.toString(str2.toCharArray()));
        //将字符串转化为字符数组
        char [] ch = {'a','b','c','d'};
        System.out.println(String.valueOf(ch));
        //将字符数组转化为字符串
        String str3 = new String("AbCdEf");
        System.out.println(str3.toLowerCase());
        //将字符串全部转化为小写，储存在新的字符串中
        System.out.println(str3.toUpperCase());
        //将字符串全部转化为大写，储存在新的字符串中
        System.out.println(str1.concat(str2));
        //将两个字符串拼接起来
        System.out.println(str1+str2+str3);
        //将多个字符串拼接起来
        String str4 = "a:b:c:d";
        String []arrStr = str4.split(":");
        //将字符串以”：“分割，并储蓄在一个新的字符数组里面
        System.out.println(Arrays.toString(arrStr));
        String str5 = "sd455ff5f4s5as4";
        String []arrStr1 = str5.split("\\d");
        System.out.println(Arrays.toString(arrStr1));
        //将字符串以int型变量分割，并储蓄在一个新的字符数组里面
    }
}

替换功能

public class String_Dome5 {
    public static void main(String[] args) {
//        替换功能
//        String replace(char old,char new)
//        String replace(String old,String new)
//        replaceAll(String regex, String replacement)
//        replaceFirst(String regex, String replacement)
//        去除字符串两空格
//        String trim()
        String str1 = "abcdefgabab";
        String new_Str1 = str1.replace('a','A');
        System.out.println(new_Str1);
        //将字符串中所有的'a'用‘A‘替换，字符替换
        String new_str2 = str1.replace("ab","AB");
        System.out.println(new_str2);
        //将字符串中所有的'ab'用'AB'替换,字符串替换
        String str2 = "a2dds5ds6d5";
        String new_str3 = str2.replaceAll("\\d",":");
        System.out.println(new_str3);
        //将字符串中所有的int常量用'；'替换,正则表达式替换
        String new_str4 = str2.replaceFirst("\\d",":");
        System.out.println(new_str4);
        //将字符串中第一个的int常量用'；'替换,正则表达式替换
        String str3 = "  abc d";
        String new_str5 = str3.trim();
        System.out.println(new_str5);
        System.out.println(new_str5.length());
        //去掉字符串首尾的空格
        String new_str6 = str3.replace(" ","");
        System.out.println(new_str6);
        System.out.println(new_str6.length());
        //去掉字符串中所有的空格
    }
}

正则表达式

public class String_RE {
    /*
    正则表达式
     */
    public static void main(String[] args) {
        String str = "156468";
        String str1 = "1";
        String str2 = "624";
        System.out.println(str1.matches("1"));
        //匹配数字是否为"1";
        System.out.println(str1.matches("\\d"));
        //匹配一位数字0-9；
        System.out.println(str.matches("\\d{6}"));
        //匹配0到6次数字0-9；
        System.out.println(str.matches("\\d{3,4}"));
        //匹配3到4次数字0-9
        System.out.println(str2.matches("[6,9][2,3][4,7]"));
        //匹配数字每位数字是否在对应的该数组之中
        System.out.println(str.matches("\\d*"));
        //匹配0次或多次数字0-9
        System.out.println(str.matches("\\d+"));
        //匹配一次或多次数字0-9
        /**
         * 输入电话号码看是否符合中国大陆的标准电话号码规格
         */
        Scanner scanner = new Scanner(System.in);
        int count = 1;
        while (count <= 5) {
            System.out.println("请输入号码：");
            String ph_num = scanner.next();

            if (ph_num.matches("[1][35789]\\d{9}")) {
                System.out.println("输入正确！");
                break;
            } else {
                System.out.println("输入的电话号码有误！！！");
                count++;
            }
        }
    }
}

import java.util.Scanner;

public class String_RE1 {

    public static void main(String[] args) {
        String str = "abc12Ab";
        String str1 = "   ";
        System.out.println(str.matches("[A-z0-9]*"));
        System.out.println(str.matches("\\w*"));
        //匹配0到多次大小写字母与数字
        System.out.println(str1.matches("\\s*"));
        //匹配0到多次空白字符
        System.out.println(str.matches("\\S*"));
        //匹配0到多次非空白字符
        System.out.println(str.matches("\\D*"));
        //匹配0到多次非数字字符
        /**
         * 判断邮箱输入规则
         */
        Scanner scanner = new Scanner(System.in);
        int count = 1;
        while (count <= 5) {
            System.out.println("请输入邮箱：");
            String ph_num = scanner.next();

            if (ph_num.matches("\\w{6,17}@(\\w{2,6}\\.(com|com\\.cn))")) {
                System.out.println("输入正确！");
                break;
            } else {
                System.out.println("输入的邮箱账号有误！！！");
                count++;
            }
        }
    }

}

StringBuffer与StringBuilder

import com.play.Stringbuffer;

public class StringBuffer_Dome {
    public static void main(String[] args) {
        StringBuffer strbuf  = new StringBuffer();
        //默认为 16个char字符的大小，且StringBuffer的定义只能创建对象来实现
        StringBuffer strbuf1 = new StringBuffer("abc");
        strbuf1.append(1);
        System.out.println(strbuf1);
        //向strbuf1的末尾添加一个int型的1；且操作的是strbuf1这个字符串，并没有生成新的数组
        strbuf1.append("ABC");
        System.out.println(strbuf1);
        //向strbuf1末尾添加一个字符串”ABC“；
        strbuf1.insert(1,"XXXX");
        System.out.println(strbuf1);
        //向strbuf1字符串索引为1后面添加一个字符串
        strbuf1.deleteCharAt(5);
        System.out.println(strbuf1);
        //删除strbuf1索引下标为5的元素
        strbuf1.delete(1,5);
        System.out.println(strbuf1);
        //删除字符串区间，包含起始位置，不包括结束位置
        strbuf1.replace(0,3,"AAA");
        System.out.println(strbuf1);
        //替换字符串区间包，含起始位置，不包括结束位置
        System.out.println(strbuf1.substring(0,4));
        System.out.println(strbuf1);
        //截取字符串区间，截取部分生成一个新的字符串
         }
}

public class StringBuilder_Dome {
    /*
    String             值不可变
    StringBuffer       值不可变   多线程安全
    StringBuilder      值不可变   多线程不安全
     */
    public static void main(String[] args) {
        StringBuilder strbuf  = new StringBuilder();
        //默认为 16个char字符的大小，且StringBuilder的定义只能创建对象来实现
        StringBuilder strbuf1 = new StringBuilder("abc");
        strbuf1.append(1);
        System.out.println(strbuf1);
        //向strbuf1的末尾添加一个int型的1；且操作的是strbuf1这个字符串，并没有生成新的数组
        strbuf1.append("ABC");
        System.out.println(strbuf1);
        //向strbuf1末尾添加一个字符串”ABC“；
        strbuf1.insert(1,"XXXX");
        System.out.println(strbuf1);
        //向strbuf1字符串索引为1后面添加一个字符串
        strbuf1.deleteCharAt(5);
        System.out.println(strbuf1);
        //删除strbuf1索引下标为5的元素
        strbuf1.delete(1,5);
        System.out.println(strbuf1);
        //删除字符串区间，包含起始位置，不包括结束位置
        strbuf1.replace(0,3,"AAA");
        System.out.println(strbuf1);
        //替换字符串区间包，含起始位置，不包括结束位置
        System.out.println(strbuf1.substring(0,4));
        System.out.println(strbuf1);
        //截取字符串区间，截取部分生成一个新的字符串
    }
}