Java常用类

1、Object类

1.1 什么是Object类

Object是所有类的父类，任何类都默认继承Object
理论上Object类是所有类的父类，即直接或间接的继承java.lang.Object类
由于所有的类都继承在Object类，因此省略了extends Object关键字

1.2 Object类中的主要方法

Object类中的常用方法：

toString()
getClass()
equals()
clone()
finalize()
hashCode()
wait()
notify()和otifyAll()

1.2.1 toString()

源码

//hashCode获取对象的hashcode值
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

测试代码

public class ObjectClass {
    public static void main(String[] args) {
        System.out.println(new Object().toString());
    }
}

运行结果

1.2.2 getClass()

源码

//final修饰的方法不能被子类继承
//native修饰的方法说明该方法不是以Java语言实现的，而是以本地语言实现的，Java可以直接拿来用
public final native Class<?> getClass();

测试代码

public class ObjectClass {
    public static void main(String[] args) {
        System.out.println(new Object().getClass());
    }
}

运行结果

1.2.3 equals()

源码

public boolean equals(Object obj) {
    // "=="比较两个变量本身的值，即两个对象在内存中的地址
    return (this == obj);
}

测试代码

public class ObjectClass {
    public static void main(String[] args) {
        Object obj = new Object();
        Object obj2 = obj;
        System.out.println(obj2.equals(obj));
        Object str1 = new String("123");
        Object str2 = new String("123");
        System.out.println(str1.equals(str2));
        Person p1 = new Person("xcc",12);
        Person p2 = new Person("xcc",12);
        System.out.println(p1.equals(p2));
    }
}

class Person{
    private String name;
    private int age;
    public Person(){}
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
}

运行结果

拓展：字符串常量池

1.2.4 clone()

源码

protected native Object clone() throws CloneNotSupportedException;

赋值对象

Person p = new Person(23, "zhang"); 
Person p1 = (Person) p.clone();

浅拷贝

被复制对象的所有值属性都含有与原来对象的相同，而所有的对象引用属性仍然指向原来的对象。

深拷贝

在浅拷贝的基础上，所有引用其他对象的变量也进行了clone，并指向被复制过的新对象。

1.2.5 finalize()

源码

protected void finalize() throws Throwable { }

该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。 Java允许在类中定义一个名为finalize()的方法。它的工作原理是：一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用其finalize()方法。并且在下一次垃圾回收动作发生时，才会真正回收对象占用的内存。

关于垃圾回收，有三点需要记住：

对象可能不被垃圾回收。只要程序没有濒临存储空间用完的那一刻，对象占用的空间就总也得不到释放。
垃圾回收并不等于“析构”。
垃圾回收只与内存有关。使用垃圾回收的唯一原因是为了回收程序不再使用的内存。

finalize()的用途：

无论对象是如何创建的，垃圾回收器都会负责释放对象占据的所有内存。这就将对finalize()的需求限制到一种特殊情况，即通过某种创建对象方式以外的方式为对象分配了存储空间。不过这种情况一般发生在使用“本地方法”的情况下，本地方法是一种在Java中调用非Java代码的方式。

1.2.6 hashCode()

源码

public native int hashCode();

返回该对象的哈希码值。该方法用于哈希查找，可以减少在查找中使用equals的次数，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash Code() == obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。

1.2.7 wait()

源码

public final void wait() throws InterruptedException {
    wait(0);
}

public final native void wait(long timeout) throws InterruptedException;

public final void wait(long timeout, int nanos) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos > 0) {
        timeout++;
    }

    wait(timeout);
}

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。

wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生。

其他线程调用了该对象的notify方法。
其他线程调用了该对象的notifyAll方法。
其他线程调用了interrupt中断该线程。
时间间隔到了。

此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

1.2.8 notify()和otifyAll()

源码

//该方法唤醒在该对象上等待的某个线程。
public final native void notify();
//该方法唤醒在该对象上等待的所有线程。
public final native void notifyAll();

2、包装类

2.1 包装类介绍

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一经创建，其内容（所封装的基本类型数据值）不可改变。

基本类型和对应的包装类可以相互装换：

由基本类型向对应的包装类转换称为装箱，例如把 int 包装成 Integer 类的对象；
包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int。

Java 1.5 之后可以自动拆箱装箱

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

3、Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。 Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

方法	说明
static int abs(int a)	返回 a 的绝对值
static long abs(long a)	返回 a 的绝对值
static float abs(float a)	返回 a 的绝对值
static double abs(double a)	返回 a 的绝对值
static int max(int x,int y)	返回 x 和 y 中的最大值
static double max(double x,double y)	返回 x 和 y 中的最大值
static long max(long x,long y)	返回 x 和 y 中的最大值
static float max(float x,float y)	返回 x 和 y 中的最大值
static int min(int x,int y)	返回 x 和 y 中的最小值
static long min(long x,long y)	返回 x 和 y 中的最小值
static double min(double x,double y)	返回 x 和 y 中的最小值
static float min(float x,float y)	返回 x 和 y 中的最小值

4、Random类

4.1 java.lang.Math.Random(内部静态方法)

源码

public static double random() {
    return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
}

//私有的内部静态类
private static final class RandomNumberGeneratorHolder {
    static final Random randomNumberGenerator = new Random();//java.util.Random
}

导入的包

调用这个Math.Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，即取值范围是 [0.0,1.0) 的左闭右开区间，返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。

4.2 java.util.Random(类)

构造函数

//无参构造函数
public Random() {
    this(seedUniquifier() ^ System.nanoTime());
}

//有参构造函数
//种子确定后，每次产生的序列都一样
public Random(long seed) {
    if (getClass() == Random.class)
        this.seed = new AtomicLong(initialScramble(seed));
    else {
        // subclass might have overriden setSeed
        this.seed = new AtomicLong();
        setSeed(seed);
    }
}

Random类中的常用方法

Random类中的方法比较简单，每个方法的功能也很容易理解。需要说明的是，Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率是均等的。下面对这些方法做一下基本的介绍：

public boolean nextBoolean()

该方法的作用是生成一个随机的boolean值，生成true和false的值几率相等，也就是都是50%的几率。

public double nextDouble()

该方法的作用是生成一个随机的double值，数值介于[0,1.0)之间。

public int nextInt() 该方法的作用是生成一个随机的int值，该值介于int的区间，也就是-231到231-1之间。
public int nextInt(int n)

该方法的作用是生成一个随机的int值，该值介于[0,n)的区间，也就是0到n之间的随机int值，包含0而不包含n。

public void setSeed(long seed)

该方法的作用是重新设置Random对象中的种子数。设置完种子数以后的Random对象和相同种子数使用new关键字创建出的Random对象相同。

示例

//生成[0,1.0)区间的小数
double d1 = r.nextDouble();
//[0,5.0)区间的小数
double d2 = r.nextDouble() * 5;
//[1,2.5)区间的小数
double d3 = r.nextDouble() * 1.5 + 1;
//成[0,10)区间的整数
int n2 = r.nextInt(10);

5、日期时间类

5.1 java.util.Date类

5.1.1 概述

java.util.Date类表示特定的瞬间，精确到毫秒。Date类的构造函数可以把毫秒值转成日期对象。

5.1.2 构造函数

//transient关键字的主要作用就是让某些被transient关键字修饰的成员属性变量不被序列化。
private transient long fastTime;
//分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）
public Date() {
    this(System.currentTimeMillis());
}
//分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数
public Date(long date) {
    fastTime = date;
}

tips: 由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。
System.out.println(new Date(0L)); //Thu Jan 01 08:00:00 CST 1970

toString()方法

public String toString() {
    // "EEE MMM dd HH:mm:ss zzz yyyy"; Wed Jan 26 16:41:38 CST 2022
    ......
}

主要方法

方法	描述
boolean after(Date date)	若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
boolean before(Date date)	若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
Object clone( )	返回此对象的副本。
int compareTo(Date date)	比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
int compareTo(Object obj)	若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
boolean equals(Object date)	当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
long getTime( )	返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
int hashCode( )	返回此对象的哈希码值。
void setTime(long time)	用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。

示例

public class ObjectClass {
    public static void main(String[] args) {
        Date date1 = new Date();
        Date date2 = new Date(date1.getTime()-600000000);
        System.out.println(date1);
        System.out.println(date2);
    }
}

5.2 SimpleDateFormat(格式化日期)

SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。 格式标识符

字母	日期或时间元素	表示	示例
G	Era标志符	Text	AD
y	年	Year	1996; 96
M	年中的月份	Month	July; Jul;07
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
d	月份中的天数	Number	10
F	月份中的星期	Number	2
E	星期中的天数	Text	Tuesday; Tue
a	Am/pm 标记	Text	PM
H	一天中的小时数	（0-23）	Number 0
k	一天中的小时数	（1-24）	Number 24
K	am/pm 中的小时数	（0-11）	Number 0
h	am/pm 中的小时数	（1-12）	Number 12
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
S	毫秒数	Number	978
z	时区	General time zone	Pacific Standard Time; PST; GMT-08:00
Z	时区	RFC 822 time zone	-0800

public String format(Date date)：将Date对象格式化为字符串。

public class DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2020年09月19日
    }
}

public Date parse(String source)：将字符串解析为Date对象。

public class DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = "2018年12月11日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
    }
}

SimpleDateFormat为一个非线程安全的类

在阿里巴巴Java开发手册的第一章第六节——并发处理中关于这一点也有明确说明：

5.3 Calendar类

5.3.1 概念

java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

5.3.2 获取实例对象

Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象，如下：

public static Calendar getInstance()：使用默认时区和语言环境获得一个日历

public class CalendarInit { 
    public static void main(String[] args) { 
        Calendar cal = Calendar.getInstance(); 
    } 
}

5.3.3 常用方法

public int get(int field)：返回给定日历字段的值。
public void set(int field, int value)：将给定的日历字段设置为给定值。
public void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。 Calendar类中提供很多成员常量，代表给定的日历字段： |字段值|含义| |---|---| |YEAR |年| |MONTH |月（从0开始，可以+1使用）| |DAY_OF_MONTH |月中的天（几号）| |HOUR |时（12小时制）| |HOUR_OF_DAY |时（24小时制）| |MINUTE |分| |SECOND |秒| |DAY_OF_WEEK |周中的天（周几，周日为1，可以-1使用）|

5.4 旧版本注意点

Date

缺点一：易用性较差。

Date类年份的起始选择是1900年，月份的起始从0 开始。这意味着，如果你想要用Date表示Java 8的发布日期，即2014年3月18日，需要创建下面这样的Date实例:

Date date = new Date(114, 2, 18);//打印结果：Tue Mar 18 00:00:00 CET 2014

缺点二：Date类是可变的，当我们在多线程环境下使用它，编程人员应该确认Date对象的线程安全

Calendar

java.util.Calendar类是为了替代Date类而出现的。很不幸的是，Calendar类中也有许多缺点，许多设计缺陷问题并未彻底解决。缺点如下：

月份依旧是从0开始计算(不过，至少Calendar 类拿掉了由1900年开始计算年份这一设计)。
Calendar类也是可变的，使用起来不安全。
同时存在Date和Calendar这两个类，容易使程序员产生困惑。到底该使用哪一个类呢?此外，有的特性只在某一个类有提供，比如用于以语言无关方式格式化和解析日期或时间的DateFormat方法就只在Date类里有。

5.5 Java 8中的日期类

5.5.1 日期和时间：LocalDate和LocalTime

  //1.1 通过of重载的工厂方法创建
  LocalDate ofDate = LocalDate.of(2014, 3, 18);//2014-03-18
  LocalTime ofTime = LocalTime.of(13, 45, 20); // 13:45:20
  //1.2 使用静态方法parse来创建
  LocalDate parseDate = LocalDate.parse("2014-03-18");//2014-03-18
  LocalTime parseTime = LocalTime.parse("13:45:20");// 13:45:20

  //2. 读取LocalDate和LocalTime常用值的两种方式
  //2.1 LocalDate 和 LocalTime 类提供了多种方法来 读取常用的值，比如年份、月份、星期几等
  int hour = ofTime.getHour(); // 13
  int minute = ofTime.getMinute(); // 45
  int second = ofTime.getSecond(); // 20
  System.out.println(ofTime);

  int year = ofDate.getYear(); // 2014
  Month month = ofDate.getMonth(); // MARCH
  int day = ofDate.getDayOfMonth(); // 18
  DayOfWeek dow = ofDate.getDayOfWeek(); // TUESDAY
  int len = ofDate.lengthOfMonth(); // 31 (days in March)
  boolean leap = ofDate.isLeapYear(); // false (判断是否为为闰年)
  System.out.println(ofDate);

  //2.2 通过传递一个TemporalField参数给get方法拿到同样的信息。
  int y = ofDate.get(ChronoField.YEAR);//2014
  int m = ofDate.get(ChronoField.MONTH_OF_YEAR);//3
  int d = ofDate.get(ChronoField.DAY_OF_MONTH);//18
  int dow2 = ofDate.get(ChronoField.DAY_OF_WEEK);//2
  
  int hour2 = ofTime.get(ChronoField.HOUR_OF_DAY);//13
  int minute2 = ofTime.get(ChronoField.MINUTE_OF_HOUR);//45
  int second2 = ofTime.get(ChronoField.SECOND_OF_MINUTE);//20

5.5.2 合并日期与时间LocalDateTime

  //3. 创建LocalDateTime的两种方式
  //3.1 通过重载的of工厂方法创建
  LocalDateTime dt1 = LocalDateTime.of(2014, Month.MARCH, 18, 13, 45, 20);
  LocalDateTime dt2 = LocalDateTime.of(ofDate, ofTime);
  //3.2 通过合并日期和时间的方式创建
  LocalDateTime dt3 = ofDate.atTime(13, 45, 20);
  LocalDateTime dt4 = ofDate.atTime(ofTime);
  LocalDateTime dt5 = ofTime.atDate(ofDate);
  //4. 从LocalDateTime中提取LocalDate或者LocalTime 组件
  LocalDate date1 = dt1.toLocalDate();//2014-03-18
  LocalTime time1 = dt1.toLocalTime();//13:45:20

5.5.3 机器时间处理Instant

  //1. 通过向静态工厂方法ofEpochSecond传递一个代表秒数的值创建一个该类的实例。
  Instant instant1 = Instant.ofEpochSecond(3);
  //2. ofEpochSecond的重载增强版本，它接收第二个以纳秒为单位的参数值，对传入作为秒数的参数进行调整。
  // 2秒之后再加上 100万纳秒(1秒)
  Instant instant3 = Instant.ofEpochSecond(2, 1_000_000_000);
  //4秒之前的100万纳秒(1秒)
  Instant instant4 = Instant.ofEpochSecond(4, -1_000_000_000);

5.5.4 时间区间:Duration和Period

private static void userDurationAndPeriod(){
    LocalTime time1 = LocalTime.of(13, 45, 20); // 13:45:20
    LocalTime time2 = LocalTime.of(20, 45, 20); // 13:45:20
    LocalDateTime dateTime1 = LocalDateTime.of(2014, Month.MARCH, 18, 13, 45, 20); // 2014-03-18T13:45
    LocalDateTime dateTime2 = LocalDateTime.of(2015, Month.MARCH, 18, 13, 45, 20); // 2015-03-18T13:45
    Instant instant1 = Instant.ofEpochSecond(3);
    Instant instant2 = Instant.ofEpochSecond(4);
    LocalDate localDate1 = LocalDate.of(2014, 3, 8);
    LocalDate localDate2 = LocalDate.of(2014, 3, 18);
    //Duration的创建方式
    //1. 通过两个LocalTimes对象、两个LocalDateTimes对象、或者两个Instant对象创建duration
    Duration d1 = Duration.between(time1,time2);
    Duration d2 = Duration.between(dateTime1, dateTime2);
    Duration d3 = Duration.between(instant1, instant2);
    //2. 通过工厂类，直接创建对应的实例;
    Duration threeMinutes1 = Duration.ofMinutes(3);
    Duration threeMinutes2 = Duration.of(3, ChronoUnit.MINUTES);
    //Duration的创建方式
    //1. 通过两个LocalDate对象创建duration
    Period tenDays = Period.between(localDate1,localDate2);
    //2. 通过工厂类，直接创建对应的实例;
    Period tenDays2 = Period.ofDays(10);
    Period threeWeeks = Period.ofWeeks(3);
    Period twoYearsSixMonthsOneDay = Period.of(2, 6, 1);
    System.out.println(d1.getSeconds());
    System.out.println(d2.getSeconds());
}

5.5.5 格式化日期DateTimeFormatter

private static void useDateFormatter() {
        LocalDate date = LocalDate.of(2014, 3, 18);
        //1. 从时间生成字符串
        //1.1 使用特定不同的格式器生成字符串
        String s1 = date.format(DateTimeFormatter.BASIC_ISO_DATE);//20140318
        String s2 = date.format(DateTimeFormatter.ISO_LOCAL_DATE);//2014-03-18
        //1.2 DateTimeFormatter类还支持静态工厂方法，它可以按 照某个特定的模式创建格式器
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
        DateTimeFormatter chinaFormatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
        String s3 = date.format(formatter);//18/03/2014
        String s5 = date.format(chinaFormatter2);//2014年3月18日 星期二
        //2. 从字符串生成时间
        //2.1 通过解析代表日期或时间的字符串重新创建该日期对象。
        LocalDate date1 = LocalDate.parse("20140318", DateTimeFormatter.BASIC_ISO_DATE);
        LocalDate date2 = LocalDate.parse("2014-03-18", DateTimeFormatter.ISO_LOCAL_DATE);
        LocalDate date3 = LocalDate.parse("18/03/2014", formatter);
        LocalDate date5 = LocalDate.parse("2014年3月18日 星期二", chinaFormatter2);
        //3. 自定义DateTimeFormatter
        DateTimeFormatter complexFormatter = new DateTimeFormatterBuilder()
                .appendText(ChronoField.DAY_OF_MONTH)
                .appendLiteral(". ")
                .appendText(ChronoField.MONTH_OF_YEAR)
                .appendLiteral(" ")
                .appendText(ChronoField.YEAR)
                .parseCaseInsensitive()
                .toFormatter(Locale.ITALIAN);
}

5.5.6 处理时区ZoneId和ZoneDateTime

ZoneId

ZoneId romeZone = ZoneId.of("Europe/Rome");

Set<String> zoneIds= ZoneId.getAvailableZoneIds();
   for (String zone : zoneIds) {
      //共计599个
      System.out.println(zone);
   }

ZoneDateTime

private static void useZoneId(){
    ZoneId romeZone = ZoneId.of("Europe/Rome");
    LocalDate date = LocalDate.of(2014, Month.MARCH, 18);
    ZonedDateTime zdt1 = date.atStartOfDay(romeZone);
    LocalDateTime dateTime = LocalDateTime.now();
    ZonedDateTime zdt2 = dateTime.atZone(romeZone);
    Instant instant = Instant.now();
    ZonedDateTime zdt3 = instant.atZone(romeZone);
    System.out.println(zdt1);
    System.out.println(zdt2);
    System.out.println(zdt3);
}

6、String类

6.1 概念

String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。java把String类声明的final类，不能有类。String类对象创建后不能修改，由0或多个字符组成，包含在一对双引号之间。

6.2 常用方法

public int length()——返回该字符串的长度。

public char charAt(int index)——返回字符串中指定位置的字符；注意字符串中第一个字符索引是0，最后一个是length()-1。

public String substring(int beginIndex)——该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。

public String substring(int beginIndex, int endIndex)——该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。

public int compareTo(String anotherString)——该方法是对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。

public int compareToIgnore(String anotherString)——与compareTo方法相似，但忽略大小写。

public boolean equals(Object anotherObject)——比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。

public boolean equalsIgnoreCase(String anotherString)——与equals方法相似，但忽略大小写。

public String concat(String str)——将参数中的字符串str连接到当前字符串的后面，效果等价于"+"。

public int indexOf(int ch/String str)——用于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。

public int indexOf(int ch/String str, int fromIndex)——改方法与第一种类似，区别在于该方法从fromIndex位置向后查找。

public int lastIndexOf(int ch/String str)——该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找。

public int lastIndexOf(int ch/String str, int fromIndex)——该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找。

public String toLowerCase()——返回将当前字符串中所有字符转换成小写后的新串。

public String toUpperCase()——返回将当前字符串中所有字符转换成大写后的新串。

public String replace(char oldChar, char newChar)——用字符newChar替换当前字符串中所有的oldChar字符，并返回一个新的字符串。

public String replaceFirst(String regex, String replacement)——该方法用字符replacement的内容替换当前字符串中遇到的第一个和字符串regex相匹配的子串，应将新的字符串返回。

public String replaceAll(String regex, String replacement)——该方法用字符replacement的内容替换当前字符串中遇到的所有和字符串regex相匹配的子串，应将新的字符串返回。

String trim()——截去字符串两端的空格，但对于中间的空格不处理。

boolean startsWith(String prefix)——用来比较当前字符串的起始字符和子字符串prefix是否相同，重载方法中同时还可以指定比较的开始位置offset。

boolean endWith(String suffix)——用来比较当前字符串的终止字符与子字符串suffix是否相同，重载方法中同时还可以指定比较的开始位置offset。

regionMatches(boolean b, int firstStart, String other, int otherStart, int length)——从当前字符串的firstStart位置开始比较，取长度为length的一个子字符串，other字符串从otherStart位置开始，指定另外一个长度为length的字符串，两字符串比较，当b为true时字符串不区分大小写。

contains(String** **str)——判断参数s是否被包含在字符串中，并返回一个布尔类型的值。

String[] split(String str)——将str作为分隔符进行字符串分解，分解后的字字符串在字符串数组中返回。

字符串与基本类型的转换

public static byte parseByte(String s)
public static short parseShort(String s)
public static short parseInt(String s)
public static long parseLong(String s)
public static float parseFloat(String s)
public static double parseDouble(String s)

基本类型转换为字符串类型

static String valueOf(char data[])
static String valueOf(char data[], int offset, int count)
static String valueOf(boolean b)
static String valueOf(char c)
static String valueOf(int i)
static String valueOf(long l)
static String valueOf(float f)
static String valueOf(double d)

7、StringBuilder

一个可变的字符序列。此类提供与StringBuffer兼容的API，但不保证同步。此类设计用作StringBuffer替代品，用于单个线程使用字符串缓冲区的位置（通常情况下）。在可能的情况下，建议使用此类优先于StringBuffer因为在大多数实现中它会更快。

StringBuilder实例不适合多线程使用。如果需要这样的同步，则建议使用StringBuffer。

构造方法

构造器	描述
`StringBuilder()`	构造一个字符串构建器，其中不包含任何字符，初始容量为16个字符。
`StringBuilder(int capacity)`	构造一个字符串构建器，其中没有字符，并且具有 `capacity`参数指定的初始容量。
`StringBuilder(CharSequence seq)`	构造一个字符串构建器，其中包含与指定的 `CharSequence`相同的字符。
`StringBuilder(String str)`	构造一个初始化为指定字符串内容的字符串构建器。

所有方法

变量和类型	方法	描述
`StringBuilder`	`append(boolean b)`	将 `boolean`参数的字符串表示形式追加到序列中。
`StringBuilder`	`append(char c)`	将 `char`参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(char[] str)`	将 `char`数组参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(char[] str, int offset, int len)`	将 `char`数组参数的子数组的字符串表示形式追加到此序列。
`StringBuilder`	`append(double d)`	将 `double`参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(float f)`	将 `float`参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(int i)`	将 `int`参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(long lng)`	将 `long`参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(CharSequence s)`	将指定的字符序列追加到此 `Appendable` 。
`StringBuilder`	`append(CharSequence s, int start, int end)`	将指定的 `CharSequence`序列追加到此序列。
`StringBuilder`	`append(Object obj)`	追加 `Object`参数的字符串表示形式。
`StringBuilder`	`append(String str)`	将指定的字符串追加到此字符序列。
`StringBuilder`	`append(StringBuffer sb)`	将指定的 `StringBuffer`追加到此序列。
`StringBuilder`	`appendCodePoint(int codePoint)`	将 `codePoint`参数的字符串表示形式追加到此序列。
`int`	`capacity()`	返回当前容量。
`char`	`charAt(int index)`	返回指定索引处的此序列中的 `char`值。
`IntStream`	`chars()`	返回 `int`的流，对此序列中的 `char`值进行零扩展。
`int`	`codePointAt(int index)`	返回指定索引处的字符（Unicode代码点）。
`int`	`codePointBefore(int index)`	返回指定索引之前的字符（Unicode代码点）。
`int`	`codePointCount(int beginIndex, int endIndex)`	返回此序列的指定文本范围内的Unicode代码点数。
`IntStream`	`codePoints()`	返回此序列中的代码点值流。
`int`	`compareTo(StringBuilder another)`	`StringBuilder`字典顺序比较两个 `StringBuilder`实例。
`StringBuilder`	`delete(int start, int end)`	删除此序列的子字符串中的字符。
`StringBuilder`	`deleteCharAt(int index)`	按此顺序删除指定位置的 `char` 。
`void`	`ensureCapacity(int minimumCapacity)`	确保容量至少等于指定的最小值。
`void`	`getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)`	将字符从此序列复制到目标字符数组 `dst` 。
`int`	`indexOf(String str)`	返回指定子字符串第一次出现的字符串中的索引。
`int`	`indexOf(String str, int fromIndex)`	从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
`StringBuilder`	`insert(int offset, boolean b)`	将 `boolean`参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, char c)`	将 `char`参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, char[] str)`	将 `char`数组参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int index, char[] str, int offset, int len)`	将 `str`数组参数的子数组的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, double d)`	将 `double`参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, float f)`	将 `float`参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, int i)`	将第二个 `int`参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, long l)`	将 `long`参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int dstOffset, CharSequence s)`	将指定的 `CharSequence`插入此序列。
`StringBuilder`	`insert(int dstOffset, CharSequence s, int start, int end)`	将指定的 `CharSequence`序列插入此序列。
`StringBuilder`	`insert(int offset, Object obj)`	将 `Object`参数的字符串表示形式插入此字符序列中。
`StringBuilder`	`insert(int offset, String str)`	将字符串插入此字符序列。
`int`	`lastIndexOf(String str)`	返回指定子字符串最后一次出现的字符串中的索引。
`int`	`lastIndexOf(String str, int fromIndex)`	返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。
`int`	`length()`	返回长度（字符数）。
`int`	`offsetByCodePoints(int index, int codePointOffset)`	返回此序列中的索引，该索引从给定的 `index`偏移 `codePointOffset`代码点。
`StringBuilder`	`replace(int start, int end, String str)`	使用指定的 `String`的字符替换此序列的子字符串中的字符。
`StringBuilder`	`reverse()`	导致此字符序列被序列的反向替换。
`void`	`setCharAt(int index, char ch)`	指定索引处的字符设置为 `ch` 。
`void`	`setLength(int newLength)`	设置字符序列的长度。
`CharSequence`	`subSequence(int start, int end)`	返回一个新的字符序列，它是该序列的子序列。
`String`	`substring(int start)`	返回一个新的 `String` ，其中包含此字符序列中当前包含的字符的子序列。
`String`	`substring(int start, int end)`	返回一个新的 `String` ，其中包含当前包含在此序列中的字符的子序列。
`void`	`trimToSize()`	尝试减少用于字符序列的存储空间。

8、StringBuffer

线程安全，可变的字符序列。字符串缓冲区类似于String ，但可以进行修改。在任何时间点它都包含一些特定的字符序列，但序列的长度和内容可以通过某些方法调用来改变。

字符串缓冲区可供多个线程使用。这些方法在必要时进行同步，以便任何特定实例上的所有操作都表现得好像它们以某个串行顺序出现，这与所涉及的每个单独线程所进行的方法调用的顺序一致。

从JDK 5版本开始，这个类已经补充了一个设计用于单个线程的等效类， StringBuilder 。 通常应优先使用StringBuilder类，因为它支持所有相同的操作，但速度更快，因为它不执行同步。

构造方法

构造器	描述
`StringBuffer()`	构造一个字符串缓冲区，其中没有字符，初始容量为16个字符。
`StringBuffer(int capacity)`	构造一个字符串缓冲区，其中没有字符和指定的初始容量。
`StringBuffer(CharSequence seq)`	构造一个字符串缓冲区，其中包含与指定的 `CharSequence`相同的字符。
`StringBuffer(String str)`	构造一个初始化为指定字符串内容的字符串缓冲区。

所有方法

变量和类型	方法	描述
`StringBuffer`	`append(boolean b)`	将 `boolean`参数的字符串表示形式追加到序列中。
`StringBuffer`	`append(char c)`	将 `char`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(char[] str)`	将 `char`数组参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(char[] str, int offset, int len)`	将 `char`数组参数的子数组的字符串表示形式追加到此序列。
`StringBuffer`	`append(double d)`	将 `double`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(float f)`	将 `float`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(int i)`	将 `int`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(long lng)`	将 `long`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(CharSequence s)`	将指定的 `CharSequence`追加到此序列。
`StringBuffer`	`append(CharSequence s, int start, int end)`	将指定的 `CharSequence`序列附加到此序列。
`StringBuffer`	`append(Object obj)`	追加 `Object`参数的字符串表示形式。
`StringBuffer`	`append(String str)`	将指定的字符串追加到此字符序列。
`StringBuffer`	`append(StringBuffer sb)`	将指定的 `StringBuffer`追加到此序列。
`StringBuffer`	`appendCodePoint(int codePoint)`	将 `codePoint`参数的字符串表示形式追加到此序列。
`int`	`capacity()`	返回当前容量。
`char`	`charAt(int index)`	返回指定索引处的此序列中的 `char`值。
`IntStream`	`chars()`	返回 `int`的流，对此序列中的 `char`值进行零扩展。
`int`	`codePointAt(int index)`	返回指定索引处的字符（Unicode代码点）。
`int`	`codePointBefore(int index)`	返回指定索引之前的字符（Unicode代码点）。
`int`	`codePointCount(int beginIndex, int endIndex)`	返回此序列的指定文本范围内的Unicode代码点数。
`IntStream`	`codePoints()`	返回此序列中的代码点值流。
`int`	`compareTo(StringBuffer another)`	`StringBuffer`字典顺序比较两个 `StringBuffer`实例。
`StringBuffer`	`delete(int start, int end)`	删除此序列的子字符串中的字符。
`StringBuffer`	`deleteCharAt(int index)`	按此顺序删除指定位置的 `char` 。
`void`	`ensureCapacity(int minimumCapacity)`	确保容量至少等于指定的最小值。
`void`	`getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)`	将字符从此序列复制到目标字符数组 `dst` 。
`int`	`indexOf(String str)`	返回指定子字符串第一次出现的字符串中的索引。
`int`	`indexOf(String str, int fromIndex)`	从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
`StringBuffer`	`insert(int offset, boolean b)`	将 `boolean`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, char c)`	将 `char`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, char[] str)`	将 `char`数组参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int index, char[] str, int offset, int len)`	将 `str`数组参数的子数组的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, double d)`	将 `double`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, float f)`	将 `float`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, int i)`	将第二个 `int`参数的字符串表示形式插入到此序列中。
`StringBuffer`	`insert(int offset, long l)`	将 `long`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int dstOffset, CharSequence s)`	将指定的 `CharSequence`插入此序列。
`StringBuffer`	`insert(int dstOffset, CharSequence s, int start, int end)`	将指定的 `CharSequence`序列插入此序列。
`StringBuffer`	`insert(int offset, Object obj)`	将 `Object`参数的字符串表示形式插入此字符序列。
`StringBuffer`	`insert(int offset, String str)`	将字符串插入此字符序列。
`int`	`lastIndexOf(String str)`	返回指定子字符串最后一次出现的字符串中的索引。
`int`	`lastIndexOf(String str, int fromIndex)`	返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。
`int`	`offsetByCodePoints(int index, int codePointOffset)`	返回此序列中的索引，该索引从给定的 `index`偏移 `codePointOffset`代码点。
`StringBuffer`	`replace(int start, int end, String str)`	使用指定的 `String`的字符替换此序列的子字符串中的字符。
`StringBuffer`	`reverse()`	导致此字符序列被序列的反向替换。
`void`	`setCharAt(int index, char ch)`	指定索引处的字符设置为 `ch` 。
`void`	`setLength(int newLength)`	设置字符序列的长度。
`CharSequence`	`subSequence(int start, int end)`	返回一个新的字符序列，它是该序列的子序列。
`String`	`substring(int start)`	返回一个新的 `String` ，其中包含此字符序列中当前包含的字符的子序列。
`String`	`substring(int start, int end)`	返回一个新的 `String` ，其中包含当前包含在此序列中的字符的子序列。
`void`	`trimToSize()`	尝试减少用于字符序列的存储空间。

Java常用类

Java常用类

1、Object类

1.1 什么是Object类

1.2 Object类中的主要方法

1.2.1 toString()

1.2.2 getClass()

1.2.3 equals()

1.2.4 clone()

1.2.5 finalize()

1.2.6 hashCode()

1.2.7 wait()

1.2.8 notify()和otifyAll()

2、包装类

2.1 包装类介绍

3、Math类

4、Random类

4.1 java.lang.Math.Random(内部静态方法)

4.2 java.util.Random(类)

5、日期时间类

5.1 java.util.Date类

5.1.1 概述

5.1.2 构造函数

5.2 SimpleDateFormat(格式化日期)

5.3 Calendar类

5.3.1 概念

5.3.2 获取实例对象

5.3.3 常用方法

5.4 旧版本注意点

5.5 Java 8中的日期类

5.5.1 日期和时间：LocalDate和LocalTime

5.5.2 合并日期与时间LocalDateTime

5.5.3 机器时间处理Instant

5.5.4 时间区间:Duration和Period

5.5.5 格式化日期DateTimeFormatter

5.5.6 处理时区ZoneId和ZoneDateTime

6、String类

6.1 概念

6.2 常用方法

7、StringBuilder

8、StringBuffer

9、File类