2021-07-13 Java常见API

String类相关

位于 java.lang.String 是字符串类

它底层就是一个字符数组,他的很多特性就是数组特性

 1 字符串一旦创建,这个字符串对象不能更改

 所以尽量不要使用String进行大量的字符串拼接操作

 2  字符串需要""表示

 3  为了提高字符串访问效率,提出一个缓存机制,字符串常量池

基本使用

public class String_02 {

public static void main(String[]args){

   String s1 = "abc";//拥有数组特性圈①

   //虽然=后没有new,但是s1仍然代表String的对象,因为字符常量池

   s1 = "123";

   //s1没有使用final修饰,所以他能改①,只不过s1指向了123

   //这个对象,abc没有改变

   //第二部分

   String s2 = "Hello";

   String s3 = "Hello";

   String s4 = "hello";

   System.out.println(s2==s3);

   //s2s3都指向常量池中这个字符串对象,所以内存地址相同

   System.out.println(s4==s3);

   //s4指向新的对象

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

    //堆内存内肯定也一样

   //第三部分

   String s5 = new String("abc");

   String s6 = new String("abc");

   //s5s6是new的方式,所以分别指向各自的堆地址,这样==是false

   String s7 = "abc";

   System.out.println(s5==s6);

   System.out.println(s5==s7+"s5+s7");//堆内存和常量池里salse

   System.out.println(s5.equals(s6));

   //String类里覆写了equals,比较的是值不是内存地址所以比较字符串应该用equals

}

}

 

 

字符串拼接

 public class String_01 {

  public static void main(String[]args){

     String[] arr = {"a12","b34","c56","d78"};//声明一个字符串数组

     String temp = "";//声明一个空的字符串

     for(int i=0;i<arr.length;i++){//通过多次创建数组来拼接字符串

        temp+=arr[i];//效率比较低

     }

     System.out.println(temp);

  }

}

常用方法

1. 1. 是否空字符串boolean isEmpty()：判断是否是空字符串：return value.length == 0
   2. 转换大小写String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
   3. String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
   4. String trim()：返回字符串的副本，忽略前导空白和尾部空白
   5. boolean equals(Object obj)：比较字符串的内容是否相同
   6. boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
   7. String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
   8. int compareTo(String anotherString)：比较两个字符串的大小
   9. String     substring(int   beginIndex)： 返回一个新的字符串， 它是此字符串的从
   10. beginIndex开始截取到最后的一个子字符串。
   11. String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字 符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
   12. boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
   13. boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
   14. boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
   15. boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列 时，返回 true
   16. int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
   17. int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出 现处的索引，从指定的索引开始
   18. int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
   19. int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后 一次出现处的索引，从指定的索引开始反向搜索注：indexOf和lastIndexOf方法如果未找到都是返回-1
   20. String replace(char oldChar, char newChar)：返回一个新的字符串，它是
   21. 通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
   22. String replace(CharSequence target, CharSequence replacement)： 使 用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
   23. String     replaceAll(String   regex,     String     replacement) ： 使 用 给 定 的
   24. replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
   25. String     replaceFirst(String regex,     String     replacement) ： 使用给定的
   26. replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
   27. boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
   28. String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
   29. String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此 字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中

public class String_04 {

public static void main(String[]args){

   String s1 = "qwert!";

   //1.获取字符串上某个位置上的字符char charAt(int index)

   System.out.println(s1.charAt(2));

    //2.判断是否以指定字符串开始boolean startsWith(String prefix)

   System.out.println("Hello.java".startsWith("He"));

   //  判断是否以指定字符串结尾,注意空格

     System.out.println("Hello.java".endsWith("va"));

    //3.比较两个字符串是否相等boolean equals(Object obj)

     System.out.println("abc".equals("Abc"));//false

    //                 不区分大小写用equalsIgnoreCase

     System.out.println("abc".equalsIgnoreCase("Abc"));

    //4.把字符串转变为字节数组byte[] getBytes()

     byte[] bytes = "abc".getBytes();

     for(byte b : bytes){

        System.out.println(b);

     }

    //把字符串转变为字符数组char[] toCharArray()

     char[] chars = "abc".toCharArray();

    for (char c : chars) {

         System.out.println(c);

    }

   //   字节数组转换字符串 : new String(bytes,起始值,个数);

   //   字符串转字节数组 : getBytes();

   //   字符数组转字符串 : new String(chars,起始值,个数);

   //   字符串转字符数组 : toCharArray();

   //6.获取字符串中,指定字符串的起始索引,找不到就返回-1 int indexOf(String str)

    System.out.println("abcdefghijk".indexOf("bc"));

    //7.获取字符串中,指定字符串最后一次出现的索引,找不到返回-1 int lastIndeOf(String str)

    System.out.println("abcdebcfg".lastIndexOf("bc"));

    //8.返回字符串长度int length()

    System.out.println("abc".length());

    //9.指定字符串替换 String replaceAll(String regex, String replacement)

    //  replase不支持正则表达式,replaceAll支持,因为.在正则表达式中 可以匹配任意字符,所以把所有字符都替换为1

    System.out.println("abc.dae".replaceAll(".", "1"));//1111111

    System.out.println("abc.dae".replace(".", "1"));//abc1dae

    //10.分割字符串,需要指定分隔符,返回字符串数组,支持正则表达式String[] split(String regex)

    String myTime = "2021,07,13";

    String [] time = myTime.split(",");

    for(String string:time){

       System.out.println(string);

    }

    //11.获取该字符串中,以某个下标为起始的子字符串(包含)String substring(int beginIndex)

    // defg

   System.out.println("abcdefg".substring(3));

   //12.获取该字符串中,以某个下标为起始(包含),到指定位置结束(不包含)String substring(int beginIndex, int endIndex)

    // 注意 起始包含,结束不包含

   // de

   System.out.println("abcdefg".substring(3,5));

   //13.去除字符串两边空格String trim()

   System.out.println("         a      b           ".trim());

    //14.转大写转小写toUpperCase();toUpperCase()   

   System.out.println("asdADnca".toUpperCase());// ASDADNCA

    System.out.println("asdADnca".toUpperCase());// asdadnca

    //15.调用指定对象的toString方法,并且使用三目运算符屏蔽了空指针异常static String valueOf(Object obj)

    //输出一个引用类型的时候,会自动调用该对象的toString方法

   Object obj = null;

   // 当obj为null时,确不会出现空指针异常

   System.out.println(obj);   

    System.out.println(String.valueOf(obj));     

}

}

构造方法

 

它的构造方法支持多种入参

public class String_03 {

public static void main(String[]args){

   //1.字面量

   String s1 = "abc";

   //2

   String s2 = new String("xxx");

   //3.字节数组

   byte[] bytes = {65,98,99,100,101,102,103};

   String s3 = new String(bytes);

   //abcdef

   System.out.println(s3);

   //4.截取字节数组一部分

   //下标为3开始(包含),取两个

   String s4 = new String(bytes,3,2);

   System.out.println(s4);

   //5.字符数组

   char[] chars = {'a','b','c','d','e'};

   String s5 = new String(chars);

   //abcd

   System.out.println(s5);

   //6.截取字符数组的一部分,同上

   String s6 = new String(chars,2,2);

   //cd

   System.out.println(s6);

}

}

StringBuffer和StringBuilder

概述

是一个可变的字符串缓冲区,适合做拼接操作

底层也是char 数组,不过默认长度是16,而字符串内容多少长度是多少

原理

先定义好长度,以容纳更多字符

如果预留长度不够,会进行自动扩容

默认长度为16 扩大后容量为(当前容量+1)*2 16 34 70

区别

StringBuilder : 非线程安全,在多线程环境下使用,可能会出现问题,常用在方法中

StringBuffer : 线程安全,在多线程环境中不会出问题,常用在类中

 

有synchronized多线程时排队执行

使用

public class String_05 {

  public static void main(String[]args){

     //创建字符串缓冲区对象

     StringBuilder sb = new StringBuilder();

     //尾部添加数据

     sb.append("a");

     sb.append("b");

     //他有return 可以链式调用

     sb.append("c").append("d");

     System.out.println(sb);

     //反转

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

     //指定位置添加数据

     sb.insert(1, "2");

     System.out.print(sb);

     //已有元素个数

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

     // 16 当前数组的容量,value.length

     System.out.println(sb.capacity());

     //转换成String型

     String s = sb.toString();

     //StringBuffer 和 StringBuilder和String一样都是一种类型

}

}

===========================================

public class String_06 {

   public static void main(String[] args) {

      String s1 = "ab";

      String a = "a";

      String b = "b";

      // 在编译阶段,就会把+号去掉,就等于是 ab

      // 所以使用 == s1和s2是相等的

      String s2 = "a"+"b";

      // 编译阶段是没有办法确定a和b的,因为还没有运行,空间还没有

      // 最终还是会转换为StringBuffer进行拼接

      // 拼接完后再转换为String类型,转换的时候是 new String() 进行转换的

      // 所以 s1 == s3 是false

      String s3 = a+b;

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

      System.out.println(s1 == s3);

   }

}