String的特性

• String类:代表字符串。Java程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。
• String是一个final类，内部定义了final char[] value用于存储字符串数组，代表不可变的字符序列。
• 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。
• String对象的字符内容是存储在一个字符数组value[]中的
• String实现了Serializable接口：表示字符串是支持序列化的。
• String实现了Comparable接口：表示String可以比较大小
• 通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串声明在字符串常量池中，字符串非常量对象存储在堆中。
• 字符常量池中是不会存储相同内容的字符串的。

面试题：

String s = new String("abc");

此方式创建对象，在内存中创建了两个对象，一个是堆空间中new结构，另一个是char[ ]对应的常量池中的数据："abc"

结论：

• 常量与常量的拼接在常量池，且常量池中不会存在相同内容的常量
• 只要有一个是变量，结果就在堆中。
• 如果拼接的结果调用intern()方法，返回值就在常量池中

---

String常用方法：

• int length():返回字符串的长度:return value.length
• char charAt(int index):返回某索引处的字符return value[index]
• boolean isEmpty():判断是否是空字符串: return value.length == 0
• String toLowerCase():使用默认语言环境，将 String 中的所有字符转换为小写
• String toUpperCase():使用默认语言环境，将 String 中的所有字符转换为大写
• String trim():返回字符串的副本，忽略前导空白和尾部空白
• boolean equals(Object obj):比较字符串的内容是否相同
• boolean equalslgnoreCase(String anotherString):与equals方法类似，忽略大小写
• String concat(String str):将指定字符串连接到此字符串的结尾。等价于用“+”
• int compareTo(String anotherString):比较两个字符串的大小
• String substring(int beginIndex):返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
• String substring (int beginIndex int endIndex):返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
• boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
• boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
• boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
• boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时，返回true
• int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引
• int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
• int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
• int lastIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
• String replace(char oldChar,char newChar):返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。
• 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个，如果超过了，剩下的全部都放到最后一个元素中

注: indexOf和lastIndexOf方法如果未找到都是返回-1

---

String的转换

• String —> char [ ]：调用String的toCharArray()

• char() —> String：调用String的构造器

public void test(){
        //String ---> char[ ]
        String str1 = "abc123";
        char array[] = str1.toCharArray();
        for (int i = 0; i <array.length; i++) {
            System.out.println(array[i]);
        }
    
        //char[ ] --->String
        char arr[] = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(arr);
    }

• String —> byte[ ] (编码)：调用String的getBytes()
• byte[ ] —> String(解码)：调用String的构造器

编码：字符串 —> 字节（看得懂 —> 看不懂的二进制数据）

解码：编码的逆过程：字节 —> 字符串（看不懂的二进制数据 —> 看得懂）

说明：解码时，要求解码使用的字符集必须与编码时使用字符集一致，否则会出现乱码。

public void test1() throws UnsupportedEncodingException {
        //String ---> byte[ ]
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符串，进行编码
        System.out.println(Arrays.toString(bytes));
        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集编码
        System.out.println(Arrays.toString(gbks));

        //byte[ ] ---> String
        String str2 = new String(bytes);//使用默认的字符串，进行解码
        System.out.println(str2);
        String str3 = new String(gbks);//使用gbk字符集解码
        System.out.println(str3);//(注：此时会出现乱码    原因：编码集和解码集不一致！)
        String str4 = new String(gbks, "gbk");
        System.out.println(str4);
    }

StringBuffer与StringBuilder

String、StringBuffer、StringBuilder三者异同

1. String:不可变字符序列
2. StringBuffer:可变的字符序列。线程安全(效率低)
3. StringBuilder:可变的字符序列。jdk5.0新增的，线程不安全(效率高)。

源码分析：

String str = new String(); //char []value = new char[0]
String str1 = new String("abc");   //char[] value = new char[]{'a','b','c'};

StringBuffer buffer1 = new StringBuffer(); //char[] value = new char[16];底层创建一个长度是16的char型数组
buffer1.append('a');  //value[0] = 'a';
buffer1.append('b');  //value[1] = 'b';
StringBuffer buffer2 = new StringBuffer("abc"); //char[] value = new char["abc".length + 16];

扩容问题：如果要添加的数组底层数组盛放不下了，那就需要扩容底层的数组。默认情况下：扩容为原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中

---

StringBuffer类的常用方法

• StringBuffer append (xxx):提供了很多的append()方法，用于进行字符串拼接( 增 )
• StringBuffer delete (int start, int end):删除指定位置的内容( 删 )
• StringBuffer setCharAt(int n,char ch): 修改指定位置(n)的字符(ch)({改 )
• StringBuffer replace (int start, int end, String str):把[start,end)位置替换为str( 改 )
• Char charAt(int n): 查找指定位置 (n)的字符( 查 )
• StringBuffer insert (int offset,xxx):在指定位置插入xXx( 插 )
• int length():求出字符串长度( 长度 )
• StringBuffer reverse ():把当前字符序列逆转( 遍历 )

String、StringBuffer、StringBuilder三者转换

1. String –> StringBuffer、StringBuilder：调用相应构造器
2. StringBuffer、StringBuilder —> String ：① 调用String构造器 ② StringBuffer、StringBuilder的toString()

日期时间

1. java.lang.System类

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差(称为时间戳 )

• 此方法适用于计算时间差。

public class DateTimeTest {
/**
 *@BelongsProject: JavaSenior
 *@BelongsPackage: PACKAGE_NAME
 *@Author: hexin
 *@CreateTime: 2022-11-27  22:06
 *@Description:
 *@Version: 1.0
 *
 */
    //1.System类中的currentTimeMillis()
    @Test
    public void test(){
        long time = System.currentTimeMillis();
        //返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差
        System.out.println(time);
    }
}

计算世界时间的主要标准有：

• UTC(Coordinated Universal Time)
• GMT(Greenwich Mean Time)
• CST(Cental Standard Time)

2. java.util.Date类

表示特定的瞬间，精确到毫秒

构造器：

• Date(): 使用无参构造器创建的对象可以获取本地当地时间。
• Date(long date)

常用方法

• getTime(): 返回自1970年1月1日00:00 GMT以此Date对象表示的毫秒数
• toString(): 把此Date对象转换为以下形式的String：dow mon ddhh：mm：ss zzz yyyy 其中：dow是一周中的某一天(Sun,Mon,Tue,Wed,Thu,Fri,Sat)，zzz是时间标准(显示当前的年、月、日、时、分、秒)
• 其它很多方法都过时了。

@Test
    public void test1(){
        //构造器一：Date()：创建一个对应当前时间的Date对象
        Date date = new Date();
        System.out.println(date.toString()); //Sun Nov 27 22:35:56 CST 2022
        System.out.println(date.getTime()); //1669559756795

        //构造器二：创建指定毫秒数的Date对象
        Date date1 = new Date(2669559756795L);
        System.out.println(date1.toString());

        //创建java.sql.Date对象
        java.sql.Date date2 = new java.sql.Date(3992815619287L);
        System.out.println(date2);

        //如何将java.util.Date对象转换为java.sql.Date对象
        //情况一：
        Date date3 = new java.sql.Date(3992815649287L);
        java.sql.Date date4 = (java.sql.Date)date3;
        //情况二：
        Date date5 = new Date();
        java.sql.Date date6 = new java.sql.Date(date5.getTime());
    }

3. java.text.SimpleDateFormat类

Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化何解析日期的具体类。

它运行进行 格式化：日期->文本、解析：文本->日期

• 格式化：
  • SimpleDateFormat(): 默认的模式和语言环境创建对象
  • public SimpleDateFormat(String pattern): 该构造方法可以用 参数pattern 指定格式创建一个对象，该对象调用；
  • pubic String format(Date date): 方法格式化时间对象date
• 解析：
  • public Date parse(String source): 从给定字符串的开始解析文本，以生成一个日期。

@Test
public void testSimpleDateFormat() throws ParseException {
    //实例化SimpleDateFormat:使用默认的构造器
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat();

    //格式化:日期 ---> 字符串

    Date date = new Date();
    String format = simpleDateFormat.format(date);
    System.out.println(format);

    //解析：格式化的逆过程：字符串 ---> 日期

    String string = "2022/09/06 上午11:12";
    Date date1 = simpleDateFormat.parse(string);
    System.out.println(date1);
    //***************按照指定的方式格式化和解析，调用带参的构造器*********************
    SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //格式化
    String format1 = simpleDateFormat1.format(date);
    System.out.println(format1);//2022-11-29 11:22:05
    //解析：要求字符串必须符合SimpleDateFormat识别的格式(通过构造器参数体现，否则就会抛异常)
    Date parse = simpleDateFormat1.parse("2022-09-06 11:12:05");
    System.out.println(parse);
}

4. java.util.Calendar(日历)类

• Calendar是一个抽象基类，主要用于完成日期字段之间的相互操作的功能。
• 获取Calendar实例的方法
  • 使用 Calendar.getlnstance() 方法
  • 调用它的子类 GregorianCalendar 的构造器
• 一个Calendar的实例是系统时间的抽象表示，通过 get(int field) 方法来取得想要的时间信息。如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY、MINUTE、SECOND
  • public void set(int field, int value)
  • public void add(int field, int amount)
  • public final Date getTime()
  • public final void setTime(Date date)

注意：

• 获取月份时：一月是0，二月是1……12月是11
• 获取星期时：周日是1，周二是2……周六是7

public class CalendarTest {
    /**
 *@BelongsProject: JavaSenior
 *@BelongsPackage: PACKAGE_NAME
 *@Author: hexin
 *@CreateTime: 2022-11-29  13:57
 *@Description:
 *@Version: 1.0
 *
 */
    @Test
    public void testCalendar(){
        //1.实例化
        //方式一：创建其子类(GregorianCalendar)的对象
        //方式二：调用其静态方法getInstance()
        Calendar calendar = Calendar.getInstance();

        //2.常用方法
        //get()
        int day = calendar.get(Calendar.DAY_OF_MONTH);//本月的第几天
        System.out.println(day);
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//本年的第几天
        //set()
        calendar.set(Calendar.DAY_OF_MONTH,6);
        day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        //add()
        calendar.add(Calendar.DAY_OF_MONTH, 3);
        day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        //getTime():日历类 ---> Date
        Date time = calendar.getTime();
        System.out.println(time);
        //setTime()：Date ---> 日历类
        Date date = new Date();
        calendar.setTime(date);
        day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
    }

LocallDate、LocalTime、LocalDateTime的使用(JDK 8以后)

体现了不可变性

Instance的使用

@Test
public void test3(){
    //now():获取本初子午线对应的标准时间
    Instant instant = Instant.now();
    System.out.println(instant); //2022-11-29T11:22:08.500169700Z
    //添加时间偏移量
    OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
    System.out.println(offsetDateTime); //2022-11-29T19:23:49.997987800+08:00
    //获取当前时间与1970年1月1日0时0分秒之间以毫秒为单位的时间差。 ---> Date类的getTime()
    long l = instant.toEpochMilli();
    System.out.println(l); //1669721464257
    //ofEpochMilli():通过给定的毫秒数，获取Instant实例： ---> Date(long millis)
    Instant instant1 = Instant.ofEpochMilli(1669721464257L);
    System.out.println(instant1); //2022-11-29T11:31:04.257Z
}

DateTimeFormatter的使用

1. java.lang.System类

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分秒之间以毫秒为单位的时间差。 ➢此方法适于计算时间差。
●计算世界时间的主要标准有:
➢ UTC(Coordinated Universal Time)
➢ GMT(Greenwich Mean Time)
➢ CST(Central Standard Time)

/**
 类似于java.util.Date类
*/
@Test
public void test3(){
    //now():获取本初子午线对应的标准时间
    Instant instant = Instant.now();
    System.out.println(instant); //2022-11-29T11:22:08.500169700Z
    //添加时间偏移量
    OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
    System.out.println(offsetDateTime); //2022-11-29T19:23:49.997987800+08:00
    //获取当前时间与1970年1月1日0时0分秒之间以毫秒为单位的时间差。 ---> Date类的getTime()
    long l = instant.toEpochMilli();
    System.out.println(l); //1669721464257
    //ofEpochMilli():通过给定的毫秒数，获取Instant实例： ---> Date(long millis)
    Instant instant1 = Instant.ofEpochMilli(1669721464257L);
    System.out.println(instant1); //2022-11-29T11:31:04.257Z
}

---

比较器

• 在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。
• Java实现对象排序的方式有两种: ➢ 自然排序: java.lang.Comparable ➢ 定制排序: java.util.Comparator

Comparable接口使用举例：

方式一：自然排序

1. 像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式
2. 像String、包装类重写compareTo()方法以后，进行了从小到大的排列
3. 重写compareTo(obj)的规则：
   • 如果当前对象this大于形参对象obj,则返回正整数，
   • 如果当前对象this小于形参对象obj，则返回负整数,
   • 如果当前对象this等于形参对象obj,则返回零。
4. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口， 重写compareTo(obj)方法。在compareTo(obj).方法中指明如何排序

class Goods implements Comparable{
    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
    //指明商品比较大小的方式,再按照产品名称从低到高排序
    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods){
            //方式一
            Goods goods = (Goods)o;
            if(this.price> goods.price){
                return 1;
            }else if(this.price<goods.price){
                return -1;
            }else{
                return this.name.compareTo(goods.name);
            }
            //方式二
//          return Double.compare(this.price,goods.price);
        }
        throw new RuntimeException("传入的数据类型不一致！");
    }
}
class GoodsCompare{
    @Test
    public void test(){
        Goods[] goods = new Goods[5];
        goods[0] = new Goods("lenovo", 9883);
        goods[1] = new Goods("Xiaomi", 3623);
        goods[2] = new Goods("HuaWei", 8223);
        goods[3] = new Goods("Samsung", 13999);
        goods[4] = new Goods("Microsoft", 13999);
        Arrays.sort(goods);
        System.out.println(Arrays.toString(goods));
    }
}

方式二：定制排序：java.util.Comparator

• 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用Comparator的对象来排序， 强行对多个对象进行整体排序的比较。
• 重写compare(Object o1,Object o2)方法，比较o1和o2的大小: 如果方法返回正整数，则表示o1大于o2;如果返回O，表示相等;返回负整数，表示o1小于o2。
• 可以将Comparator传递给sort方法（如Collections.sort或Arrays.sort) ,从而允许在排序顺序上实现精确控制。
• 还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

 @Test
public void test1(){
    Goods[] goods = new Goods[5];
    goods[0] = new Goods("lenovo", 9883);
    goods[1] = new Goods("Xiaomi", 3623);
    goods[2] = new Goods("HuaWei", 8223);
    goods[3] = new Goods("Samsung", 13999);
    goods[4] = new Goods("Microsoft", 13999);
    Arrays.sort(goods,new Comparator(){
        //指明按照产品名称从低到高排序,再比较商品从高到低的方式
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof Goods&&o2 instanceof Goods){
                Goods goods1 = (Goods) o1;
                Goods goods2 = (Goods) o2;
                if(goods1.getName().equals(goods2.getName())){
                    return -Double.compare(goods1.getPrice(), goods2.getPrice());
                }else{
                    return goods1.getName().compareTo(goods2.getName());
                }
            }
            throw new RuntimeException("输入的数据类型不一致！");
        }
    });
    System.out.println(Arrays.toString(goods));
}

两种方式对比：

1. Comparable接口的方式一旦一定，保证Comparable接口实现类的对象在任何位置都可以比较大小
2. Comparator接口属于临时性比较。

---

其他常用类

System类：

• System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。

• 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。

• 成员变量

  • System类内部包含in、out和err三个成员变量，分别代表标准输入流 (键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

• 成员方法

  • native long currentTimeMillis(): 该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数

  • void exit(int status):该方法的作用是退出序。其中status的值为0代表正常退出，非零代表异常退出。 使用该方法可以在图形界面编程中实现程序的退出功能等。

  • void gc(): 该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。

  • String getProperty(String key): 该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示:

    属性名	属性说明
    java. version	Java运行时环境版本
    java. home	Java安装目录
    os.name	操作系统的名称
    os.version	操作系统的版本
    user.name	用户的账户名称
    user.home	用户的主目录
    user.dir	用户的当前工作目录

Math类：

• java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。
  abs绝对值
  acos,asin,atan,cos,sin,tan三角函数
  sqrt平方根
  pow(double a,doble b)a的b次幂log自然对数
  expe为底指数
  max(double a,double b)min(double a,double b)
  random()返回0.0到1.0的随机数
  long round(double a)double型数据a转换为long型（四舍五入)toDegrees(double angrad) 弧度—>角度
  toRadians(double angdeg) 角度—>弧度

BigInteger、BigDecimal类：

BigInteger类：

• Integer类作为int的包装类，能存储的最大整型值为2^31-1，Long类也是有限的，最大为263-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
• java.math包的 Biglnteger可以表示不可变的任意精度的整数。BigInteger提供所有Java的基本整数操作符的对应物，并提供 java.lang.Math的所有相关方法。另外，Biglnteger还提供以下运算:模算术、GCD计算、质数测试、素数生成、位操作以及一些其他操作。
• 构造器 Biglnteger(String val):根据字符串构建Biglnteger对象
• 常用方法：
  • public BigInteger abs():返回此 Biglnteger 的绝对值的 BigInteger。
  • BigInteger add(Biglnteger val):返回其值为(this + val)的 BigInteger
  • BigInteger subtract(Biglnteger val):返回其值为(this - val)的
  • BigIntegerBigInteger multiply(BigInteger val):返回其值为(this * val)的
  • BigIntegerBigInteger divide(BigInteger val):返回其值为(this / val)的 BigInteger。整数相除只保留整数部分。
  • BigInteger remainder(BigInteger val):返回其值为(this % val)的 BigInteger。
  • BigInteger[] divideAndRemainder(BigInteger val):返回包含(this / val)后跟(this % val)的两个BigInteger的数组。
  • Biglnteger pow(int exponent):返回其值为(this^exponent)的 BigInteger。

BigDecimal类：

• 一般的Float类和Double类可以用来做科学计算或工程计算，但在 商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。
• BigDecimal类支持不可变的、任意精度的有符号十进制定点数。
• 构造器:
  • public BigDecimal(double val)public BigDecimal(String val)
• 常用方法:
  • public BigDecimal add(BigDecimal augend)
  • public BigDecimal subtract(BigDecimal subtrahend)public BigDecimal multiply(BigDecimal multiplicand)
  • public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)