Java基础（必知必会）API

（一）Java中的字符串和常量池

1. String：字符串类型
   1. java.lang.String使用final修饰，不能被继承
   2. java中的String采用Unicode编码格式，任何一个字符都占用两个字节
   3. String字符串底层封装了字符数组
   4. 字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值----不变对象
2. 常量池
   1. java对字符串有一个优化措施：字符串常量池(堆中)
   2. java推荐我们使用字面量/直接量的方式来创建字符串，并且会缓存所有以字面量形式创建的字符串对象到常量池中，当使用相同字符量再创建字符串时会重用对象以减少内存开销，避免内存中堆积大量内容相同的字符串对象

      String s1 = "123abc"; //堆中创建一个123abc对象，常量池中存储这个对象的引用
      //编译器在编译时，若发现是两个字面量连接，则直接运算好并将结果保存起来，
      //如下代码相当于 String s2 = "123abc";
      String s2 = "123"+"abc"; //复用常量池中的123abc对象
      System.out.println(s1==s2); //true
      
      String s3 = "123";
      //因为s3不是字面量，所以并不会直接运算结果
      //如下代码会在堆中创建新的123abc对象，而不会重用常量池中的对象
      String s4 = s3+"abc";
      System.out.println(s1==s4); //false
      
      /*
        使用字面量创建字符串对象时，JVM会检查常量池中是否有该对象:
        1)若没有，则会创建该字符串对象并存入常量池中
        2)若有，则直接将常量池中的对象地址返回(不会再创建新的字符串对象)
      */
      String s1 = "123abc"; //常量池还没有，因此创建该字符串对象，并存入常量池
      String s2 = "123abc"; //常量池中已经有了，直接重用对象
      String s3 = "123abc"; //常量池中已经有了，直接重用对象
      //引用类型==，比较的是地址是否相同
      System.out.println(s1==s2); //true
      System.out.println(s1==s3); //true
      System.out.println(s2==s3); //true
      s1 = s1+"!"; //创建新的字符串对象并将地址赋值给s1
      System.out.println(s1==s2); //false，因为s1为新对象的地址，与s2不同了

 （二）String常用的API方法

1. length()：获取字符串的长度(字符个数)

    String str = "我爱Java!";
    int len = str.length(); //获取str的长度
    System.out.println(len); //7

2. trim()：去除当前字符串两边的空白字符

    String str = "  hello world            ";
    System.out.println(str); //  hello world
    str = str.trim(); //去除当前字符串两边的空白字符
    System.out.println(str); //hello world

3. toUpperCase()和toLowerCase()：将当前字符串中的英文部分转为全大写/全小写

    String str = "我爱Java!";
    String upper = str.toUpperCase(); //将str中英文部分转为全大写
    System.out.println(upper); //我爱JAVA!
    
    String lower = str.toLowerCase(); //将str中英文部分转为全小写
    System.out.println(lower); //我爱java!

4. startsWith(String str)和endsWith(String str)：判断当前字符串是否是以给定的字符串开始/结尾的

    String str = "thinking in java";
    boolean starts = str.startsWith("think"); //判断str是否是以think开头的
    System.out.println("starts:"+starts); //true
    
    boolean ends = str.endsWith(".png"); //判断str是否是以.png结尾的
    System.out.println("ends:"+ends); //false

5. charAt()：返回当前字符串指定位置上的字符

    //                      111111
    //            0123456789012345
    String str = "thinking in java";
    char c = str.charAt(9); //获取位置9所对应的字符
    System.out.println(c); //i

6. indexOf()和lastIndexOf()：检索给定字符串在当前字符串中的开始位置

    //                      111111
    //            0123456789012345
    String str = "thinking in java";
    int index = str.indexOf("in"); //检索in在字符串str中的开始位置
    System.out.println(index); //2
   	
    index = str.indexOf("in",3); //从下标为3的位置开始找in第一次出现的位置
    System.out.println(index); //5
   	
    index = str.indexOf("IN"); //当前字符串不包含IN，所以返回-1
    System.out.println(index); //-1
   
    index = str.lastIndexOf("in"); //找in最后一次出现的位置
    System.out.println(index); //9

7. substring()：截取当前字符串中指定范围内的字符串

    //                      1
   //            01234567890
   String str = "www.badu.cn";
   String name = str.substring(4,8); //截到下标4到7范围的字符串
   System.out.println(name); //badu
   
   name = str.substring(4); //从下标4开始一直截到末尾
   System.out.println(name); //badu.cn

8. String的静态方法valueOf()：将其它数据类型转换为String

   int a = 123;
   String s1 = String.valueOf(a); //将int型变量a转换为String类型并赋值给s1
   System.out.println(s1); //123---字符串类型
   
   double d = 123.456;
   String s2 = String.valueOf(d); //将double型变量d转换为String类型并赋值给s2
   System.out.println(s2); //123.456----字符串类型
   
   String s3 = a+""; //任何内容和字符串连接的结果都是字符串，效率低
   System.out.println(s3); //123---字符串类型

 （三）StringBuilder类

1. 由于String是不变对象，每次修改内容要创建新对象，因此String不适合做频繁修改操作，为了解决这个问题，java提供了StringBuilder类。
2. StringBuilder是专门用于修改字符串的一个API，内部维护一个可变的char数组，修改都是在这个数组上进行的，修改速度、性能优秀，并且提供了修改字符串的常见的方法：增、删、改、插。

   //String不适合频繁修改内容
   String s = "a";
   for(int i=0;i<10000000;i++){
       s = s+i;
   }
   System.out.println("执行完毕");
   
   //用StringBuilder可以提高修改字符串的性能
   StringBuilder builder = new StringBuilder("a");
   for(int i=0;i<10000000;i++){
       builder.append(i);
   }
   System.out.println("执行完毕");

3. StringBuilder常用方法
   1. append()：追加内容
   2. replace()：替换部分内容
   3. delete()：删除部分内容
   4. insert()：插入内容

      String str = "好好学习java";
      //复制str中的内容到builder中-----好好学习java
      StringBuilder builder = new StringBuilder(str);
      
      //append():追加内容
      builder.append("，为了找个好工作!");
      System.out.println(builder); //好好学习java，为了找个好工作!
      
      //replace():替换部分内容
      builder.replace(9,16,"就是为了改变世界"); //替换下标9到15的
      System.out.println(builder); //好好学习java，就是为了改变世界!
      
      //delete():删除部分内容
      builder.delete(0,8); //删除下标0到7的
      System.out.println(builder); //，就是为了改变世界!
      
      //insert():插入操作
      builder.insert(0,"活着"); //从下标0的位置插入
      System.out.println(builder); //活着，就是为了改变世界!

  （四）正则表达式

1. 正则表达式是用来描述字符串内容格式，使用它通常用于匹配一个字符串的内容是否符合格式要求。
2. 正则表达式的语法---了解、不用纠结、不用深入研究

   1.[]：表示一个字符,该字符可以是[]中指定的内容
       例如：
       [abc]：这个字符可以是a或b或c
       [a-z]：表示任意一个小写字母
       [a-zA-Z]：表示任意一个字母
       [a-zA-Z0-9_]：表示任意一个数字字母下划线
       [^abc]：该字符只要不是a或b或c

   
   2.预定义字符：
       .：表示任意一个字符,没有范围限制
       \d：表示任意一个数字,等同于[0-9]
       \w：表示任意一个单词字符,等同于[a-zA-Z0-9_]--单词指字母/数字/_
       \s：表示任意一个空白字符
       \D：表示不是数字
       \W：不是单词字符
       \S：不是空白字符

   
   3.量词：
       ?：表示前面的内容出现0-1次
            例如: [abc]? 可以匹配:a 或 b 或 c 或什么也不写
       +：表示前面的内容最少出现1次
             例如: [abc]+ 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcba...但是不能匹配:什么都不写 或 abcfdfsbbaqbb34bbwer...
       *：表示前面的内容出现任意次(0-多次)---匹配内容与+一致，只是可以一次都不写
            例如: [abc]* 可以匹配:b或aaaaaaaaaa...或abcabcba....或什么都不写,但是不能匹配:abcfdfsbbaqbb34bbwer...
       {n}：表示前面的内容出现n次
             例如: [abc]{3} 可以匹配:aaa 或 bbb 或 aab 或abc 或bbc,但是不能匹配: aaaa 或 aad
       {n,m}：表示前面的内容出现最少n次最多m次
             例如: [abc]{3,5} 可以匹配:aaa 或 ?abcab 或者 abcc,但是不能匹配:aaaaaa 或 aabbd
       {n,}：表示前面的内容出现n次以上(含n次)
             例如: [abc]{3,} 可以匹配:aaa 或 aaaaa.... 或 abcbabbcbabcba....,但是不能匹配:aa 或 abbdaw...

   
   4.()：用于分组,是将括号内的内容看做是一个整体
       例如: (abc){3} 表示abc整体出现3次. 可以匹配abcabcabc,但是不能匹配aaa 或abcabc

                (abc|def){3}表示abc或def整体出现3次.可以匹配: abcabcabc 或 defdefdef 或 abcdefabc,但是不能匹配abcdef 或abcdfbdef

3. String支持与正则表达式相关的方法
   1. matches()：使用给定的正则表达式验证当前字符串的格式是否符合要求

      /*
         邮箱的正则表达式:
           [a-zA-Z0-9_]+@[a-zA-Z0-9]+(\.[a-zA-Z]+)+
      */
      String email = "zhangsan@bada.cn";
      String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
      boolean match = email.matches(regex); //使用regex匹配email是否符合格式要求
      if(match){
          System.out.println("是正确的邮箱");
      }else{
          System.out.println("不是正确的邮箱");
      }

   2. split()：将当前字符串按照满足正则表达式的部分进行拆分

      String line = "abc123de4f456ghi";
      String[] data = line.split("[0-9]+"); //按数字拆分(数字就拆没了)
      System.out.println(Arrays.toString(data)); //将data数组按String格式输出
      
      line = "123.456.789"; //
      data = line.split("\\."); //按.拆(.就拆没了)
      System.out.println(Arrays.toString(data));
      
      //最开始就是可拆分项目(.)，那么数组第1个元素为空字符串-----------""
      //如果连续两个(两个以上)可拆分项，那么中间也会拆出一个空字符串----""
      //如果末尾连续多个可拆分项，那么拆出的空字符串被忽略
      line = ".123.456..789.487.....";
      data = line.split("\\."); //按.拆(.就拆没了)
      System.out.println(Arrays.toString(data));

   3. replaceAll()：将当前字符串中满足正则表达式的部分给替换为给定的字符串

      String line = "abc123def456ghi5";
      //将line中数字部分替换为#NUMBER#
      line = line.replaceAll("[0-9]+","#NUMBER#");
      System.out.println(line);

  （五）Java中的包装类

1. java定义了8个包装类，目的是为了解决基本类型不能直接参与面向对象开发的问题，使用基本类型可以通过包装类对象的形式存在。

2. 包括：Integer、Character、Byte、Short、Long、Float、Double、Boolean。其中Character和Boolean是直接继承Object的，而其余6个包装类继承自java.lang.Number

3. JDK1.5推出了一个新的特性：自动拆装箱，当编译器编译时若发现有基本类型与包装类型相互赋值时，将会自动补充代码来完成转换工作，这个过程称为自动拆装箱。

   //演示valueOf()复用部分数据特点:
   Integer i1 = new Integer(5);
   Integer i2 = new Integer(5);
   System.out.println(i1==i2); //false，因为==是比较地址
   
   //Integer.valueOf()会复用-128到127范围内的数据，建议使用valueOf()方式
   Integer i3 = Integer.valueOf(5);
   Integer i4 = Integer.valueOf(5); //因为在-128到127之间，所以重用了i3对象
   System.out.println(i3==i4); //true
   
   //演示自动拆装箱:
   //触发自动装箱特性，会被编译为: Integer i = Integer.valueOf(5);
   Integer i = 5;
   //触发自动拆箱特性，会被编译为: int j = i.intValue();
   //intValue()作用是:将包装类型转换为int类型
   int j = i;
   
   //演示包装类的常用操作:
   //1)可以通过包装类来得到基本类型的取值范围:
   int max = Integer.MAX_VALUE; //获取int的最大值
   int min = Integer.MIN_VALUE; //获取int的最小值
   System.out.println("int的最大值为:"+max+"，int的最小值为:"+min);
   
   long max1 = Long.MAX_VALUE; //获取long的最大值
   long min1 = Long.MIN_VALUE; //获取long的最小值
   System.out.println("long的最大值为:"+max1+"，long的最小值为:"+min1);
   
   //2)包装类可以将字符串转换为对应的基本类型------必须掌握
   String str = "38";
   int age = Integer.parseInt(str); //前提str能正确表达一个int数据
   System.out.println(age); //38
   
   String s = "123.456";
   double price = Double.parseDouble(s); //前提s能正确表达一个double数据
   System.out.println(price); //123.456

---

        本文完！至此，基础入门阶段笔记都在这里了，大家有不同建议和观点的可以评论区一起讨论哦。

        写在结尾:

        2022 年 9 月 23 日 一个java菜鸟，发布于北京海淀。

        好记性不如烂笔头，持续学习，坚持输出~今天是持续写作的第4天。可以点赞、评论、收藏啦。

---