Java常用类

字符串相关类：String

1.String声明为final，不可被继承。
2.实现了Serializable接口：表示字符串是支持序列化的;
实现了Comparable接口：表示String是可以比较大小的；
3.String内部定义了final char[] value[]用于存储字符串数据；
4.String代表不可变的字符序列。

• 当对字符串重新赋值；

• 对现有字符串进行连接操作；

• 当调用replace()修改指定字符或字符串时；
  都会重新指定内存区域进行赋值。

5.通过字面量的方式给一个字符串赋值，此时字符串的值声明在字符串常量池中。

6.字符串常量池是不会存储相同内容的字符串的。

在jdk1.6之前，字符串常量池在JVM的方法区（永久代）中，jdk1.7之后移到了堆中，jdk1.8去除永久代，改为元空间。

String实例化的两种方式：

// String实例化方式一：字面量赋值 
// 首先会从字符串常量池中查找，如果该字符串已经存在，在返回引用，否则在字符串常量池中创建
String st1 = "abc";
// String实例化方式二：new + 构造器 在堆空间中创建
String st2 = new String("abc");

内存解析：

intern 方法是一个native方法，intern方法会从字符串常量池中查询当前字符串是否存在，如果存在，就直接返回当前字符串；如果不存在，则会在常量池中创建并返回堆中的对象引用。

String常用方法

public class StringMethodTest {
    @Test
    public void test1() {
        String st1 = "Taylor Swift";
        // int length()：返回字符串的长度：return value.length
        System.out.println(st1.length());// 12
        // char charAt(int index)：返回某索引处的字符return value[index]
        System.out.println(st1.charAt(0));// T
        // boolean isEmpty()：判断是否是空字符串：return value.length == 0
        System.out.println(st1.isEmpty());// false
        // String toLowerCase()：使用默认语言环境，将String 中的所有字符转换为小写
        System.out.println(st1.toLowerCase());// taylor swift
        // String toUpperCase()：使用默认语言环境，将String 中的所有字符转换为大写
        System.out.println(st1.toUpperCase());// TAYLOR SWIFT
        // String trim()：返回字符串的副本，忽略前导空白和尾部空白
        String st2 = " hello world ";
        String st3 = st2.trim();
        System.out.println(st3);// " hello world "
        System.out.println(st2.trim());// "hello world"
        // boolean equals(Object obj)：比较字符串的内容是否相同
        System.out.println(st2.equals(" hello world "));// true
        System.out.println(st2.equals(st3));// false
        //boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
        System.out.println(st2.equalsIgnoreCase(" HELLO world "));// true
        //String concat(String str)：将指定字符串连接到此字符串的结尾。等价于用“+”
        String st4 = "Justin ".concat("Bieber");
        System.out.println(st4);// Justin Bieber
        //int compareTo(String anotherString)：比较两个字符串的大小
        String st5 = "abc";
        String st6 = "abd";
        System.out.println(st5.compareTo(st6));// -1  (c-d=>99-100)
        //String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
        String st7 = "学习JAVA高级语法";
        System.out.println(st7.substring(2));// JAVA高级语法
        //String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
        System.out.println(st7.substring(0,6));//学习JAVA
    }

    @Test
    public void test2(){
        // boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
        String st1 = "Jim Smith";
        System.out.println(st1.endsWith("aaa"));// false
        System.out.println(st1.endsWith("Smith"));// true
        // boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
        String st2 = "张伟";
        System.out.println(st2.startsWith("张"));// true
        // boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
        System.out.println(st2.startsWith("张",0 ));// true
        System.out.println(st2.startsWith("张伟dsg",0 ));// false
        // boolean contains(CharSequence s)：当且仅当此字符串包含指定的char值序列时，返回true
        System.out.println("hello world".contains("o"));// true
        // int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
        System.out.println("Runnable".indexOf("n"));// 2
        // int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始(包含此索引)
        System.out.println("hellohello".indexOf("l",4));// 7
        // int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
        System.out.println("hello".lastIndexOf("l"));// 3
        // int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
        System.out.println("helloworld".lastIndexOf("o",9));// 6
        // 注：indexOf和lastIndexOf方法如果未找到都是返回-1

    }

    @Test
    public void test3(){
        // String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar得到的。
        String st1 = "aabbccaa";
        String st2 = st1.replace('a','A');
        System.out.println(st2);
        // String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
        // String replaceAll(String regex, String replacement) ：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
        // String replaceFirst(String regex, String replacement) ：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
        // boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
        // String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
        // String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此 字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
    }
}

String 与char[]转换

public void test1(){
        // String -> char[]  调用String的toCharArray()
        String st1 = "qwerasdf";
        char[] charArray1 = st1.toCharArray();
        for (int i = 0; i < charArray1.length; i++) {
            System.out.print(charArray1[i]);
        }
        // char[] -> String  调用String()构造器
        String st2 = new String(charArray1);
        System.out.println(st2);
    }

String与byte[] 转换

public void test2() throws UnsupportedEncodingException {
        // String -> byte[]  调用String的getBytes()
        String st1 = "abc123哈哈";
        byte[] byteArray1 = st1.getBytes();// 使用默认编码
        System.out.println(Arrays.toString(byteArray1));// [97, 98, 99, 49, 50, 51, -27, -109, -120, -27, -109, -120]
        byte[] byteArray2 = st1.getBytes("gbk");
        System.out.println(Arrays.toString(byteArray2));// [97, 98, 99, 49, 50, 51, -71, -2, -71, -2]
        // byte[] ->String    调用String()构造器
        String st2 = new String(byteArray1);
        System.out.println(st2);// abc123哈哈
        String st3 = new String(byteArray2,"gbk");
        System.out.println(st3);// abc123哈哈
    }
}

StringBuffer 与 StringBuilder

String：不可变的字符序列
StringBuffer：可变的字符序列；线程安全，效率低
StringBuilder：可变的字符系列；线程不安全，效率高
底层都是使用char[]存储
StringBuffer(StringBuilder)常用方法：

 public void test1(){
        // StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
        StringBuffer st1 = new StringBuffer("abc");
        st1.append("!!!");// abc!!!
        System.out.println(st1);
        // StringBuffer delete(int start,int end)：删除指定位置的内容
        st1.delete(0,1);// 取头不取尾
        System.out.println(st1);// bc!!!
        // StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
        st1.replace(2,4,"de");
        System.out.println(st1);// bcde!
        // StringBuffer insert(int offset, xxx)：在指定位置插入xxx
        st1.insert(4,"f");
        System.out.println(st1);// bcdef!
        // StringBuffer reverse() ：把当前字符序列逆转
        System.out.println(st1.reverse());// !fedcb
        // public int indexOf(String str) 返回指定字符串的索引位置
        System.out.println(st1.indexOf("b"));// 5
        // public String substring(int start,int end) 截取指定起始位置的字符串
        System.out.println(st1.substring(1,5));// fedc
        // public int length()
        // public char charAt(int n )
        // public void setCharAt(int n ,char ch)
    }
}

日期时间API

Date类

@Test // System类中的currentTimeMillis()
public void test1(){
    // 时间戳：返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差
    long time = System.currentTimeMillis();
    System.out.println(time);
}

@Test // util.Date类
public void test2(){
    // 构造器一：Date(),创建一个当前时间的Date对象
    Date date1 = new Date();
    System.out.println(date1);// 默认调用重写的toString()
    System.out.println(date1.getTime());// getTime()获取当前时间对应的毫秒数
    // 构造器二：Date(long time)
}

SimpleDateFormat类

@Test
public void test1() throws ParseException {
    // 实例化SimpleDateFormat,使用默认构造器
    SimpleDateFormat sdf = new SimpleDateFormat();
    Date date1 = new Date();
    // 格式化日期 日期->String
    String date2 = sdf.format(date1);
    System.out.println(date1);// Mon Mar 02 14:15:11 CST 2020
    System.out.println(date2);// 20-3-2 下午2:15
    // 解析 String->日期
    String date3 = "20-3-2 下午2:15";
    Date date4 = sdf.parse(date3);
    System.out.println(date4);// Mon Mar 02 14:15:00 CST 2020
    // 使用带参构造器
    SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");
    System.out.println(sdf2.format(new Date()));// 2020-03-02 02-24-05
}

比较器

自然排序：java.lang.Comparable
需要进行比较的类需要实现Comparable接口中的toCompare()方法，在实现Comperable接口时可使用该类作为泛型限定，在编译期间即可发现传入参数是否为需要进行比较的实体对象。

@Override // 按照年龄排序
public int compareTo(Object o) {
    if (o instanceof Person) {
        Person person = (Person)o;
        // return Integer.compare(this.age,preson.age);
        return this.age-person.age;// 从小到大
    }
    else{
        throw new RuntimeException("输入类型不匹配");
    }
}

定制排序：java.util.Comparator
需要重写Comparator类中的compare()方法

Comparator comparator = new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        if(o1 instanceof Person && o2 instanceof Person){
            return ((Person) o1).getAge()-((Person)o2).getAge();
        }
        else{
            throw new RuntimeException("传入参数错误");
        }
    }
};

枚举类

public class EnumTest1 {
    public static void main(String[] args) {
        StudentGrade stu = StudentGrade.ONE;
        System.out.println(stu);// 自动调用Enum中的toString()

        // values()返回枚举类型的对象数组
        StudentGrade[] values = StudentGrade.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }
        // valueOf()把一个字符串转为对应的枚举类对象
        StudentGrade stu2 = StudentGrade.valueOf("TWO");
        System.out.println(stu2);// TWO
    }
}

enum StudentGrade{
    // 提供当前枚举类的对象
    ONE("大一"),
    TWO("大二"),
    THREE("大三"),
    FOUR("大四");
    // 声明StudentGrade对象的属性
    private final String grade;
    // 私有化构造器
    private StudentGrade(String grade){
        this.grade = grade;
    }

    public String getGrade(){
        return this.grade;
    }
}