Java常用类——String

概述

String：使用一对“”表示字符串。在Java中属于引用类型，对字符串进行操作的类。

• String声明为final的，不可继承
• String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小
• String内部定义了final char[] value用于存储字符串数据
• 、String：代表不可变的字符串序列。简称：不可变性。
  1、当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的Value进行赋值。
  2、当对现有的字符串进行链接操作时，也需要重新指定内存区域赋值不能使用原有的Value进行赋值。
  3、当调用String replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值不能使用原有的Value进行赋值。

String的使用

实例化

字面量的方式进行初始化赋值与 new+构造器 方式的区别

   public void Test02(){
        //通过字面量定义赋值：此时s1和s2指向的Java EE声明在方法区的字符串常量池中
        String s1="JavaEE";
        String s2="JavaEE";
        //通过new+构造器方式：此时s3和s4保存的地址指向堆区中创建的对象
        String s3 = new String("JavaEE");
        String s4 = new String("JavaEE");
        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s1==s4);//false
        System.out.println(s3==s4);//false
        System.out.println("===============");
        Person tom = new Person("Tom", 18);
        Person tom1 = new Person("Tom", 18);
        System.out.println(tom.name.equals(tom1.name));//true
        System.out.println(tom.name== tom1.name);//true
        System.out.println(tom==tom1);//false
    }

通过字面量的方式（区别与new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
字符串常量池中是不会存储相同的内容的字符串的。
出现字符串拼接时，常量与常量的拼接结果在常量池。而且常量池中不会存在相同内容的常量。
只要其中有一个是变量，结果就在堆中
如果拼接结果调用intern()方法，返回值就在常量池中

String类型与其他类型互相转换

String与基本数据类型和包装类的互相转换
String -->基本数据类型、包装类：调用包装类的静态方法：parseXxx（str）
基本数据类型、包装类—>String：调用String重载的ValueOf（XXX）

   public void Test01(){
        String s1="123";
        // String-->Integer-->int
        int i = Integer.parseInt(s1);
        //int -->String
        String s2 = String.valueOf(i);
    }

String 与 char[]之间的转换
String -->char[]:调用String的toCharArray()
char[] -->String :调用String的构造器

  public void Test02(){
        String str1="abc123";
//        String-->char[]
        char[] chars = str1.toCharArray();
        for (int i=0;i<chars.length;i++){
            System.out.println(chars[i]);
        }
//        char[]-->String
        char[] chars1 = {'q', 'w', 'e', 'r'};
        String s = new String(chars1);
        System.out.println(s);
    }

String与byte[]之间的转换
编码： String -->byte[]:调用String的getBytes()
解码：byte[]–>String
要求解码和编码的字符集一致，否则会出现乱码

 public void Test03() throws UnsupportedEncodingException {
        String s1="abc123中文";
        byte[] bytes = s1.getBytes();//使用默认的字符集
        System.out.println(Arrays.toString(bytes));

        //使用GBK编码
        byte[] gbks = s1.getBytes("gbk");
        System.out.println(Arrays.toString(gbks));


        System.out.println("======================");
        //byte[]-->String
        String s = new String(bytes);
        System.out.println(s);

        String s2 = new String(gbks, "gbk");//指定字符集
        System.out.println(s2);
    }

String类常用方法

取字符串长度 length() return value.length
char charAt() 返回某索引处字符
boolean isEmpty() 判断是否为空字符串
大写字符->小写字符 toLowerCase 返回一个小写字符串，不改变原来字符串
小写字符->大写字符 toUpperCase
返回字符串的副本 忽略首尾空白 ，中间不变 trim()
equals() 比较两个字符串内容是否相同
equalsIgnoreCase() 忽略大小写比较
concat() 拼接两个字符串 相当于+ 返回一个字符串
compareTo() 比较两个字符串大小（allsc码值）
s1.substring(int big) 返回一个字符串，该字符串是从s1字符串索引为big截取一直到结尾的字符串
substring(big,blg)同上，返回索引big到blg（不包含）的一个字符串

boolean endsWith() 测试字符串是否以指定字符为后缀
bollean startsWith() 判断字符串是否以指定字符为前缀
startsWith(ptrefix,toffset) 判断字符串从指定索引开始的子字符串是否为指定前缀
contains() 查看当前字符串是否包含指定字符串
indexOf(String s) 返回当前字符串中指定字符串第一次出现的索引值 不存在返回-1
indexOf(String s, int i) 返回当前字符串中指定字符串第一次出现的索引值,从指定索引开始
lastIndexOf(String s) 返回当前字符串中指定字符串第一次出现的索引值从右边开始
lastIndexOf(String s,int i) 返回当前字符串中指定字符串第一次出现的索引值,从指定索引开

@Test
    public void Test01(){
        String s1="HelloWorld";
        //取字符串长度 length()  return value.length
        System.out.println(s1.length());
        //char charAt()  返回某索引处字符
        System.out.println(s1.charAt(0));
        //boolean isEmpty()  判断是否为空字符串
        System.out.println(s1.isEmpty());
        //大写字符->小写字符 toLowerCase 返回一个小写字符串，不改变原来字符串
        System.out.println(s1.toLowerCase(Locale.ROOT));
        //小写字符->大写字符 toUpperCase
        System.out.println(s1.toUpperCase(Locale.ROOT));
        //返回字符串的副本 忽略首尾空白 ，中间不变 trim()
        System.out.println(s1.trim());
        String s2=s1.toUpperCase(Locale.ROOT);
        //equals() 比较两个字符串内容是否相同
        System.out.println(s1.equals(s2));
        //equalsIgnoreCase() 忽略大小写比较
        System.out.println(s1.equalsIgnoreCase(s2));
        String s3="lan";
        //concat() 拼接两个字符串 相当于+ 返回一个字符串
        System.out.println(s1.concat(s3));
        //compareTo() 比较两个字符串大小（allsc码值）+> 0=  -<
        System.out.println(s1.compareTo(s3));
        //s1.substring(int big)  返回一个字符串，该字符串是从s1字符串索引为big截取一直到结尾的字符串
        System.out.println(s1.substring(3));
        //substring(big,blg)同上，返回索引big到blg（不包含）的一个字符串
        System.out.println(s1.substring(2,6));
    }
    @Test
    public void Test02(){
        String s1="holle wrold";
//       boolean endsWith()  测试字符串是否以指定字符为后缀
        System.out.println(s1.endsWith("ldd"));
//       bollean  startsWith() 判断字符串是否以指定字符为前缀
        System.out.println(s1.startsWith("ho"));
//        startsWith(ptrefix,toffset) 判断字符串从指定索引开始的子字符串是否为指定前缀
        System.out.println(s1.startsWith("ll", 2));

        System.out.println("===================");
        String s2="wr";
//        contains()  查看当前字符串是否包含指定字符串
        System.out.println(s1.contains(s2));
//        indexOf(String s) 返回当前字符串中指定字符串第一次出现的索引值 不存在返回-1
        System.out.println(s1.indexOf(s2));
//        indexOf(String s, int i) 返回当前字符串中指定字符串第一次出现的索引值,从指定索引开始
        System.out.println(s1.indexOf(s2,6));
//        lastIndexOf(String s) 返回当前字符串中指定字符串第一次出现的索引值从右边开始
        System.out.println(s1.lastIndexOf(s2));
//         lastIndexOf(String s,int i) 返回当前字符串中指定字符串第一次出现的索引值,从指定索引开始 从右边开始
        System.out.println(s1.lastIndexOf(s2,4));

    }
    @Test
    public void test03(){
//        替换
        String s1="hollho wrold";
//      replace(oldchar,newchar) 返回一个新的字符串：将该字符串的指定的old的字符串换为new的字符
        System.out.println(s1.replace('h', 'l'));
//      replace(target,replacement) 返回一个新的字符串：将该字符串的指定字面量换成另一个指定字面量
        System.out.println(s1.replace("ho", "lanlan"));
        //把字符串中的数字替换成“，”，如果结果中开头和结尾有“，”的话去掉
        String sr="hello123world456java789mysql";
        System.out.println(sr.replaceAll("\\d+", ",").replaceAll(":^,|,$", " "));
//      匹配
        String s2="12345";
        boolean matches = s2.matches("\\d+");
        System.out.println(matches);
        String tel="098923-8912890";
//      判断这是否是一个固定电话
        boolean matches1 = tel.matches("098923-\\d{7,8}");
        System.out.println(matches1);
//        切片
        System.out.println("=====================");
        String s3="hello|world|java";
        String[] split = s3.split("\\|");
        for (int i=0;i<split.length;i++){
            System.out.println(split[i]);
        }
        System.out.println();
        String s4="hello.world.java";
        String[] split2 = s3.split("\\.");
        for (int i=0;i<split2.length;i++){
            System.out.println(split2[i]);
        }
    }