JAVASE——常用API

一、StringBuilder类

StringBuilder代表可变字符串对象，相当于是一个容器，它里面的字符串是可以改变的，就是用来操作字符串的。

1.1 使用方法

StringBuilder s = new StringBuilder("abcs");
// 1. 拼接内容
s.append(12);
s.append("黑马");
s.append(666).append("黑马")
// 2. 反转操作
s.reverse();
// 3. 返回字符串长度
s.length();

1.2 应用案例

将int数组转换为指定格式的字符串

public class Test{
    public static void main(String[] args){
        String str = getArrayData( new int[]{11,22,33});
        System.out.println(str);
    }
    
    //方法作用：将int数组转换为指定格式的字符串
    public static String getArrayData(int[] arr){
        //1.判断数组是否为null
        if(arr==null){
            return null;
        }
        //2.如果数组不为null，再遍历，并拼接数组中的元素
        StringBuilder sb = new StringBuilder("[");
        for(int i=0; i<arr.length; i++){
            if(i==arr.legnth-1){
                sb.append(arr[i]).append("]");;
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        //3、把StirngBuilder转换为String，并返回。
        return sb.toString();
    }
}

二、StringJoiner类

StringJoiner号称是拼接神器，不仅效率高，而且代码简洁。

public class Test{
    public static void main(String[] args){
        StringJoiner s = new StringJoiner(",");
        s.add("java1");
        s.add("java2");
        s.add("java3");
        System.out.println(s); //结果为： java1,java2,java3
        
        //参数1：间隔符
        //参数2：开头
        //参数3：结尾
        StringJoiner s1 = new StringJoiner(",","[","]");
        s1.add("java1");
        s1.add("java2");
        s1.add("java3");
        System.out.println(s1); //结果为： [java1,java2,java3]
    }
}

三、Arrays类

Arrays是操作数组的工具类，它可以很方便的对数组中的元素进行遍历、拷贝、排序等操作。

/**
 * 目标：掌握Arrays类的常用方法。
 */
public class ArraysTest1 {
    public static void main(String[] args) {
        // 1、public static String toString(类型[] arr): 返回数组的内容
        int[] arr = {10, 20, 30, 40, 50, 60};
        System.out.println(Arrays.toString(arr));

        // 2、public static 类型[] copyOfRange(类型[] arr, 起始索引, 结束索引) ：拷贝数组（指定范围，包前不包后）
        int[] arr2 = Arrays.copyOfRange(arr, 1, 4);
        System.out.println(Arrays.toString(arr2));

        // 3、public static copyOf(类型[] arr, int newLength)：拷贝数组，可以指定新数组的长度。
        int[] arr3 = Arrays.copyOf(arr, 10);
        System.out.println(Arrays.toString(arr3));

        // 4、public static setAll(double[] array, IntToDoubleFunction generator)：把数组中的原数据改为新数据又存进去。
        double[] prices = {99.8, 128, 100};
        //                  0     1    2
        // 把所有的价格都打八折，然后又存进去。
        Arrays.setAll(prices, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                // value = 0  1  2
                return prices[value] * 0.8;
            }
        });
        System.out.println(Arrays.toString(prices));

        // 5、public static void sort(类型[] arr)：对数组进行排序(默认是升序排序)
        Arrays.sort(prices);
        System.out.println(Arrays.toString(prices));
    }
}

现在，想对Student类的一些对象排序，两种方法：

• 方法一：让Student类实现Comparable接口，同时重写compareTo方法。Arrays的sort方法底层会根据compareTo方法的返回值是正数、负数、还是0来确定谁大、谁小、谁相等。代码如下：

  public class Student implements Comparable<Student>{
      private String name;
      private double height;
      private int age;
      
      // 指定比较规则
      @Override
      public int compareTo(Student o){
      // 认为左边对象 大于 右边对象 请您返回正整数
          return this.age - o.age;//按照年龄升序排序
      }
  }

• 方法二：在调用Arrays.sort(数组,Comparator比较器);时，除了传递数组之外，传递一个Comparator比较器对象。Arrays的sort方法底层会根据Comparator比较器对象的compare方法方法的返回值是正数、负数、还是0来确定谁大、谁小、谁相等。代码如下：

  Arrays.sort(students, new Comparator<Student>()){
     @Override
     public int compare(Student o1, Student o2){
         return Double.compare(o1.getHeight(), o2.getHeight()); 
  }
  }

四、Lambda表达式

作用：用于简化匿名内部类代码的书写。

在使用Lambda表达式之前，必须先有一个接口，而且接口中只能有一个抽象方法。（注意：不能是抽象类，只能是接口）

public class LambdaTest1 {
    public static void main(String[] args) {
        // 目标：认识Lambda表达式.
        //1.创建一个Swimming接口的匿名内部类对象
		Swimming s = new Swimming(){
             @Override
             public void swim() {
                 System.out.println("学生快乐的游泳~~~~");
             }
         };
         s.swim();
		
        //2.使用Lambda表达式对Swimming接口的匿名内部类进行简化
        Swimming s1 = () -> {
              System.out.println("学生快乐的游泳~~~~");
        };
        s1.swim();
    }
}

使用lambda表达式重新写排序方法

Arrays.sort(students, (Student o1, Student O2) -> {
    return Double.compare(o1.getHeight() , o2.getHeight());});

五、正则表达式

正则表达式其实是由一些特殊的符号组成的，它代表的是某种规则。

正则表达式的作用1：用来校验字符串数据是否合法

正则表达式的作用2：可以从一段文本中查找满足要求的内容

matches(String regex)。这个方法是属于String类的方法。

举例

// 1. 匹配单个字符类
"a".matches("[abc]"); // true
"e".matches("[^abc]"); // true
"a".matches(["a-zA-Z"]); //true
"k".matches("[a-z&&[^bc]]"); //true
// 2. 匹配单个预定义字符 
"许".matches(".") ;// "."可以匹配任意字符
"3".matches("\\d"); // "\d"可以匹配[0,9]的数字
"d".matches("\\D"); // "\D"匹配非数字
" ".matches("\s"); // "\s"匹配一个空白字符
"s".matches("\\w"); // "\w"匹配[a-zA-Z0-9]
// 3. 数量词
"a".matches("\\w?"); // ? 一次或者0次
"abc12".matches("\\w*"); // * 0次或者多次
"abc12".matches("\\w+"); // + 1次获多次