常用类

String类

• String类是一个final的，即无法被继承

• 字符串是一个常量

• 内部定义了final byte类型数组

通过赋值号=的方式是区别于new的方式给字符串赋值，=的方式是将字符串存在常量池中，使用对象引用常量池中存在的地址

若使用赋值号的方式给字符串赋值，如果有两个相同的字符串，那么此时两个对象都同时引用两个相同的地址，因此可以通过==来判等

通过new的方式无法通过==来判等

对字符串赋值时，使用新的引用地址进行赋值

对现有的字符串进行拼接（+=）时，也需要进行重新指定

使用String类中的replace进行修改字符串时，也必须重新指定字符串的值

对象的创建

String s = new String();//空参
String s = new String("字符串");//有参
String s = new String(char[]数组);
String s = new String(char[]数组, 开始位置, 结束位置);
String s = new String(byte[]数组);
String s = new String(byte[]数组, 开始位置, 结束位置);
//针对byte数组，还有指定编码格式的方法
String s = new String(byte[]数组, "编码格式");//需要try-catch环绕
String s = "字符串";

不同的拼接方式

两个字面量的连接相当于字面量，即s = "111" + "222"等价于s = 111222，所以也是在常量池中声明

如果赋值时，有变量名（前提这个变量没有被final修饰，被该关键字修饰的变量是一个常量）的参与，那么此时不是在常量池处理，要在堆空间进行，有点类似于new

使用函数的返回值赋值(=)，也是相当于在常量池进行操作

String是不可变型，在函数中，即使作为形式参数在函数体内修改其值，仍不会改变

方法	含义
s1.compareTo(s2)	比较大小，第一个大返回正值，第二个大返回负值，相等返回0，kəmˈper，比较
s1.length()	求长，长度为0时抛出异常
s1.charAt(数字)	取出数字出的下标值
s1.substring(开始位置,结束位置)	取子串，只有1个值时，从开始位置取到末尾
s1.indexOf(字符串,开始位置)	从开始位置查看字符串是否是s1的子串，如果存在，返回开始位置，不存在返回-1，开始位置可以省略，默认为0，lastindexOf反向进行比较
s1.equals(串)	两串判等
s1.startsWith(串, 开始位置)	当省略开始位置时，相当于判断串是否在开头位置，不省略就相当于在下标位置判断
s1.endsWith(串)	串是否在末尾
s1.trim()	返回删掉两端空格的值，中文修剪
s1.replace(串1,串2)	返回把s1中的所有串1都换成串2后的串，rəˈplās，代替
s1.toLowerCase()	返回s1都变小写字母后的值
s1.toUpperCase()	返回s1都变大写字母后的值
s1.equalsIgnoreCase(串)	忽略大小写对比两串
s1.contains(串)	contains 中文为包含，查看串是否在s1中，返回boolean类型
s1.replace(需要替换的串,替换内容)	返回替换内容
s1.replaceAll(需要替换的正则表达式串, 替换之后的正则表达式串)	返回使用正则表达式串替换全部的内容
s1.replaceFirst(需要替换的正则表达式串, 替换之后的正则表达式串)	返回使用正则表达式串替换第一个出现的字符串
s1.split(正则表达式, 最多的个数)	返回一个字符串数组，将字符串按照正则表达式进行切片，如果省略最多的个数，那就全部切片，如果不省略，那么将超出的切片放到最后一个串中

数据类型转换

其他类型转String String.valueof(其他类型的重载)

String转char数组变量.toCharArray()，返回char[]

String转byte类型的数组变量.getBytes(字符编码格式)，返回byte[]，编码格式可以省略（不省略时，需要try-catch环绕），默认是UTF-8，用什么编码，就用什么解码

StringBuffer类和StringBulider类

String是不可变的字符序列，StringBuffer和StringBuilder是可变的字符序列，因此值改变，引用地址不变

buffer中文是缓冲，builder中文是建造者

StringBuffer在java.lang.StringBuffer类下，线程安全，效率低

StringBuilder在java.lang.StringBulilder类下，线程不安全，效率高，在JDK5.0新增

两个类无法使用=的方式赋值，只能通过new的方式，字符串的拼接只能用.append()方法，无法使用+=

s1.setCharAt(下标, char值) 更改下标处的值

StringBuffer使用空参构造时相当于创建了一个长度为16的byte数组

StringBuffer中有一个参数只有整形的构造器，含义是指定大小，可以提高效率，如果之后的操作使其超出指定大小，也会自动扩容

时间API

JDK8之前

currentTimeMillis方法

该类位于java.lang.System类中的静态方法，返回1970年1月1日0时0分0秒与当前的时间差（毫秒），

通常也被称为时间戳，返回long

System.out.println(System.currentTimeMillis());

java.util.Date类

import java.util.Date;

构造时可以有参构造，也可以无参构造

有参构造有多个重载，第一个为直接指定毫秒数，第二个为年月日，第三个为年月日时分，第三个为年月日时分秒，除了直接指定毫秒数，其他的有参构造均已过时

使用年月日等有参构造时，年份时从1900年开始计算的，也就是说最终的年份就等于1900+传入的年份

月份从0开始计算，0代表1月

方法	含义
.toString()	返回周 月 日 时:分:秒 时区 年份
.getTime()	返回1970年1月1日0时0分0秒与当前的时间差（毫秒）

构造器：

• 无参构造：返回当前时间
• 有参构造：new Date(长整型数)，长整型数作为一个毫秒数传递，如果整数值过大，需要在其后添加L

java.sql.Date类

继承于java.util.Date，主要针对数据库

java.text.SimpleDateFormat类

主要是对Date类的格式化和解析，所以需要提前使用Date类

默认的无参构造仅能输出固定格式

可以通过查询文档，实现其他格式的输出

功能：

• 格式化日期

• 逆格式化

方法	含义
.format(Data类)	格式化Data类中的日期格式，返回字符串
.parse(字符串)	返回一个Date对象，parse中文为解析，默认只能识别年-月-日 上下午 时间的格式，解析格式取决于构造器

java.util.Calendar类

日历类，这个类是一个抽象类，需要使用其子类进行new，子类为gregorianCalendar，Gregorian中文为公历，读音为```ˈɡriˈɡɔ:riən``

方式二，调用静态方法进行实例化，Calendar 变量名 = Calendar.getInstance()

Instance中文为实例化

方法	含义
.get(整数)	返回字符串，整数为固定的值，可以直接输入Calender.的方式获取内置的常量，都有具体的含义，即获取一些属性，比如今天是一年中的第几天
.set(整数1,整数2)	设置天数，整数1与上边的整数含义相同，整数2为设置后的值，比方设置今天是一年中的第一天，此时其他属性的值也会改变，比如今天是一个月的第几天
.add(整数1,整数2)	整数1与上边作用相同，整数2表示在原来的基础上增加多少天（可以为负值，表示减去的天数）
.getTime()	返回一个Date对象
.setTime(Date对象)	使用Date对象设置值

JDK8及之后

java.time.LocalXXX类

以下的类都在java.time.下

LocalDate获取当前日期

LocalTime获取当前时间

LocalDateTime获取当前日期和时间

以上都不允许使用new的方式进行创建对象，并且都是有不可变性，使用plus或者minus进行增加或者减少相应的值，对象必须要变化

可以使用类名.now()的方式实例化，now为静态方法

now()方法实例化

        LocalDate date = LocalDate.now();
        LocalTime time = LocalTime.now();
        LocalDateTime dateTime = LocalDateTime.now();

of()方法实例化

设定指定的年月日时分秒毫秒，此时没有偏移量

所设置的值必须是在合法范围内的

    LocalDate date = LocalDate.now(年, 月, 日);
    LocalTime time = LocalTime.now(时, 分, 秒, 毫秒);
//毫秒是可选的
    LocalDateTime dateTime = LocalDateTime.now(年, 月, 日, 时, 分, 秒, 毫秒);
//秒和毫秒是可选的

输出时间信息

		System.out.println(date);
//年-月-日
        System.out.println(time);
//小时(24小时制):分钟:秒.毫秒
        System.out.println(dateTime);
//年-月-日T小时(24小时制):分钟:秒.毫秒

可以通过变量名.getXXX()的一系列的方法获取想要的值

增加、减少、修改信息

可以通过变量名 = 变量名.plusXXX(整数)的方式增加相应的值

可以通过变量名 = 变量名.minusXXX(整数)的方式减少相应的值

可以通过变量名 = 变量名.withXXX(整数)的方式修改相应的值

minus中文为减少，读音为/ˈmaɪ.nəs/

以上三个方法返回类型均为LocalDate、LocalTime、LocalDateTime

因为有不可变性，所以必须使用赋值号

Instant类

也是通过now()创建

如图

Java比较器

对象比较大小，有两个，分别为comparable，comparator，都需要重写

Comparable接口

中文可比较的，读音'kɔmpərəbl，如果要实现对象的排序，需要这个类实现Comparable接口，并且重写CompareTo(Object)方法，通常被称为自然排序

规则：

• 当前对象this大于形参对象，返回正整数
• 当前对象this大于形参对象，返回负整数
• 当前对象this等于形参对象，返回0

class 类名 implements Comparable{
    public int CompareTo(Object o){
        if(o instanceof 类名){ //需要进行类的转换
            类名 对象名 = (类名) o;//强制类型转换
            //按照规则实现的接口
        } 
    }
}

再调用Arrays.sort(对象数组)进行排序

重载：Arrays.sort(对象数组, 开始位置, 结束位置)

Comparator

中文为比较器，'kɔmpəreitə，又被称为定制排序

该类在java.util.下

例如String等类都有默认的排序规则（从小到大）如果要从大到小，可以使用Comparator进行定制

使用背景：

• 程序没有实现Comparable接口，而不方便修改代码
• 实现了Comparable，但该接口不适合当前的操作

方式：

• 新建一个类实现Comparator或者使用匿名类实现接口
• 实现public int compare(Object o1, Object o2)方法
• 先判断类型是否匹配，再从方法中进行强制类型转换
• 如果针对的基本数据类型排序，需要将其转为包装类
• 调用Arrays.sort(变量, 实现类的对象)

class 类名 implement Comparator{
    public int compare(Object o1, Object o2){
        if(o1 instanceof 类型 && o2 instanceof 类型){
            类 变量1 = (类) o1;
            类 变量2 = (类) o2;
            //将变量1和变量2中的属性进行对比，也遵循相等返回0，小于返回负数，大于返回正数
        }
    }
}

实现类

public class CompareTest {
    public static void main(String[] args) {
        Integer[] a = {334,4,542,65,4,42,5,425,4,6,53,62};
        SortInt sortInt = new SortInt();
        Arrays.sort(a,sortInt);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

class SortInt implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        if(o1 instanceof Integer && o2 instanceof Integer){
            Integer a = (Integer) o1;
            Integer b = (Integer) o2;
            return a - b;
        }
        return 0;
    }
}

匿名类

public class CompareTest {
    public static void main(String[] args) {
        Integer[] a = {334, 4, 542, 65, 4, 42, 5, 425, 4, 6, 53, 62};
        Arrays.sort(a, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Integer && o2 instanceof Integer) {
                    Integer a = (Integer) o1;
                    Integer b = (Integer) o2;
                    return a - b;
                }
                return 0;
            }
        });
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

System类

定义在java.lang.下，构造器是私有的，因此无法创建对象，内部的成员属性和方法都是静态的，因此可以直接调用

math类

BigInteger类

在Math下，大数类

构造器：BigInteger(字符串)

BigDecimal类

枚举类

类的对象是有限个，定义一系列常量时，可以使用枚举类

自定义枚举类

JDK5.0之前使用此方法

• 声明成员变量用private final修饰
• 构造器使用private修饰，进行私有化
• 提供当前枚举类的多个对象
• 其他可能需要的方法

class TestEnum{
    //声明成员变量用private final修饰
    private final int serialNum;//序号
    private final String name;

    //构造器私有化
    private TestEnum(int serialNum, String name) {
        this.serialNum = serialNum;
        this.name = name;
    }

    //提供当前枚举类的多个对象
    public static TestEnum chinese = new TestEnum(1, "语文");
    public static TestEnum math = new TestEnum(2, "数学");
    public static TestEnum english = new TestEnum(3, "英语");

    //可能用到的方法
    @Override
    public String toString() {
        return "TestEnum{" +
                "serialNum=" + serialNum +
                ", name='" + name + '\'' +
                '}';
    }

    public static void main(String[] args) {
        TestEnum ch = TestEnum.chinese;
        System.out.println(ch);
    }
}

enum关键字

JDK5.0新增

默认继承于java.lang.Enum类

• 类前不使用class修饰，而是使用enum修饰

• 提供当前枚举类的对象，对象与对象之间用逗号隔开，格式为变量名(参数)，末尾用分号结束

• 声明成员变量用private final修饰

• 构造器使用private修饰，进行私有化

• 其他可能需要的方法

• toString()如果不重写，进行输出时，默认输出的是常量名

enum TestEnum { //类前使用enum修饰
    //提供当前枚举类的对象，对象与对象之间用逗号隔开，格式为变量名(参数)，末尾用分号结束
    chinese(1, "语文"),
    math(2, "数学"),
    english(3, "英语");
    //声明成员变量用private final修饰
    private final int serialNum;//序号
    private final String name;
    //私有化构造器
    private TestEnum(int serialNum, String name) {
        this.serialNum = serialNum;
        this.name = name;
    }

    //可能用到的方法
    @Override
    public String toString() {
        return "TestEnum{" +
                "serialNum=" + serialNum +
                ", name='" + name + '\'' +
                '}';
    }

    public static void main(String[] args) {
        TestEnum ch = TestEnum.chinese;
        System.out.println(ch);
    }
}

类名.values()方法：返回自定的枚举类的类型数组，数组中包含所有的常量

		TestEnum[] t = TestEnum.values();
        for (int i = 0; i < t.length; i++) {
            System.out.println(t[i]);
        }

类名.valueOf(字符串)方法：返回自定义枚举类型中的与字符串重名的常量，如果不存在，就抛出异常

enum也可以实现接口，格式enum 类名 implements 接口，也可以实现枚举类中每个对象的实现接口的不同方法，格式枚举类(参数){重写接口中的方法}，即通过匿名子类

注解Annotation

读音a·nuh·tay·shn

JDK5.0引入

框架 = 注解 + 反射 + 设计模式

@Override
编译时检查是否重写了父类中的相应方法

@Deprecated
中文是已弃用，用于修饰过时的

读音为deh·pruh·kayt

上面代码中，将name属性和print()方法修饰为@Deprecate后，使用时，会出现删除线，通常在会引发危险，或者有更好的替代方案时，会使用此注解

@SuppressWarnings

suppress，中文为压制，读音səˈpres，warning中文为警告

在idea中，没有使用过的方法/属性会显示为灰色，可以通过添加@SuppressWarnings({"unused"})注解后显示为正常颜色

自定义注解

参照SuppressWarnings

注解声明为，自动继承了java.lang.annotation.Annotation接口

• 成员变量可以用任意的类型（包括类和class）

• 如果只有一个成员变量，可以使用value表示

• 成员变量使用方法的形式定义，例如定义int a，可以写为int a()

• 也可以定义时指定一个默认值，类型 变量名 default 默认值

• 如果没有指定默认值，使用时，必须要指定一个值，即注解名(变量名 = 值)

public @interface 注解名{
    
}

JDK提供的元注解

用来修饰其他注解

Retention

中文为保留的意思，读音为rəˈten(t)SH(ə)n

Q.E.D.