Java_String类&&StringBuilder类&&正则表达式&&日期相关类

Java_String类

String类的概念

1. java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如：“abc”。字符串是常量,用双引号表示,字符串的值在创建之后不能更改，并且java.lang.String类描述的字符串内容是个常量不可更改，因此可以被共享使用。

2. String类由final关键字修饰，表示该类不能被继承。

3. 从jdk1.9开始该类的底层不使用char[]来存储数据，而是改成 byte[]加上编码标记，从而节约了一些空间。

4. String对象的字符内容是存储在一个字符数组value[]中的。

5. String类描述的字符串内容是个常量不可更改，因此可以被共享使用。

   String str1 = “abc”; // 其中"abc"这个字符串是个常量不可改变。 
   str1 = “123”; // 将“123”字符串的地址赋值给变量str1。改变str1的指向并没有改变原指向的内容
   
   String str = "hello";
   //本质上this.value = new char[0];
   String  s1 = new String();
    
   //this.value = original.value;
   String  s2 = new String(String original); 
   
   //this.value = Arrays.copyOf(value, value.length);
   String  s3 = new String(char[] a); 
   String  s4 = new String(char[] a,int startIndex,int count);
   

常量池的概念

1. 由于String类型描述的字符串内容是常量不可改变，JVM为了提升性能和减少内存开销，避免字符串的重复创建，其维护了一块特殊的内存空间,即字符串池(String ），若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对象，从而提高了性能。

3. 字符串常量存储在字符串常量池,目的是共享

4. 字符串非常量对象存储在堆中

5. 两个字符串拼接时：

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

   String str1  = “abc”;
   与
   String str2 = new String(“abc”);的区别
   

   

6. 以上两种创建方式存在性能和内存占用方面存在差别

   package com.company;
   // 字符串池的样例
   public class Java_16 {
       public static void main(String[] args) {
   //      采用字面值的方式赋值
   // 1. 采用字面值方式创建一个字符串,JVM首先会区字符串池中查找是否存在"ASD"这个对象,
   // 2. 如果不存在"ASD"对象,则会新建一个"ASD"对象,然后将池中的"ASD"对象的引用地址返回给字符串常量str,这样,str会指向"ASD"对象,
   // 3. 如果存在"ASD"对象,则不创建任何对象,直接将池中的"ASD"对象的值返回给"str"
           String str1 = "ASD";
           String str2 = "ASD";
           System.out.println(str1 == str2); // 输出 true
   //        采用new关键字的方式赋值
   // 1. 采用new关键字新建一个字符串对象时，JVM首先在字符串池中查找有没有"aaa"这个字符串对象，
   // 2. 如果有，则不在池中再去创建"ASD"这个对象了，直接在堆中创建一个"ASD"字符串对象，然后将堆中的这个"ASD"对象的地址返回赋给引用str3，这样，str3就指向了堆中创建的这个"ASD"字符串对象；
   // 3. 如果没有，则首先在字符串池中创建一个"ASD"字符串对象，然后再在堆中创建一// 个"ASD"字符串对象，然后将堆中这个"ASD"字符串对象的地址返回赋给str3引用，这样，str3指向了堆中创建的这个"ASD"字符串对象。
   // 4. 采用new关键字创建对象时，每次new出来的都是一个新的对象，也即是说引用str3和str4指向的是两个不同的对象，
           String str3 = new String("ASD");
           String str4 = new String("ASD");
           System.out.println(str3 == str4); // 输出 false
       }
   }
   

字符串池优缺点

1. 字符串池的优点就是避免了相同内容的字符串的创建，节省了内存，省去了创建相同字符串的时间，同时提升了性能
2. 字符串池的缺点就是牺牲了JVM在常量池中遍历对象所需要的时间，不过其时间成本相比而言比较低。

常用方法

1. 方法声明	功能介绍
   String()	使用无参方式构造对象得到空字符序列
   String(byte[] bytes, int offset, intlength)	使用bytes数组中下标从offset位置开始的length个字节来构造对象
   String(byte[] bytes)	使用bytes数组中的所有内容构造对象
   String(char[] value, int offset, int count)	使用value数组中下标从offset位置开始的count个字符来构造对象
   String(char[] value)	使用value数组中的所有内容构造对象
   String(String original)	根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本

2. 常用的成员方法

   方法声明	功能介绍
   String toString()	返回字符串本身
   byte[] getBytes()	将当前字符串内容转换为byte数组并返回
   char[] toCharArray()	用于将当前字符串内容转换为char数组并返回
   char charAt(int index)	方法charAt用于返回字符串指定位置的字符。
   int length()	返回字符串字符序列的长度
   boolean isEmpty()	判断字符串是否为空
   int compareTo(String anotherString)	用于比较调用对象和参数对象的大小关系
   int compareToIgnoreCase(String str)	不考虑大小写，也就是’a’和’A’是相等的关系
   String concat(String str)	用于实现字符串的拼接
   boolean contains(CharSequence s)	用于判断当前字符串是否包含参数指定的内容
   String toLowerCase()	返回字符串的小写形式
   String toUpperCase()	返回字符串的大写形式
   String trim()	返回去掉前导和后继空白的字符串
   boolean startsWith(String prefix)	判断字符串是否以参数字符串开头
   boolean startsWith(String prefix, int toffset)	从指定位置开始是否以参数字符串开头
   boolean endsWith(String suffix)	判断字符串是否以参数字符串结尾
   boolean equals(Object anObject)	用于比较字符串内容是否相等并返回
   int hashCode()	获取调用对象的哈希码值
   boolean equalsIgnoreCase(String anotherString)	用于比较字符串内容是否相等并返回，不考虑大小写，如：'A’和’a’是相等
   int indexOf(int ch)	用于返回当前字符串中参数ch指定的字符第一次出现的下标
   int indexOf(int ch, int fromIndex)	用于从fromIndex位置开始查找ch指定的字符
   int indexOf(String str)	在字符串中检索str返回其第一次出现的位置，若找不到返回-1
   int indexOf(String str, int fromIndex)	表示从字符串的fromIndex位置开始检索str第一次出现的位置
   int lastIndexOf(int ch)	用于返回参数ch指定的字符最后一次出现的下标
   int lastIndexOf(int ch, int fromIndex)	用于从fromIndex位置开始查找ch指定字符出现的下标
   int lastIndexOf(String str)	返回str指定字符串最后一次出现的下标
   int lastIndexOf(String str, int fromIndex)	用于从fromIndex位置开始反向搜索的第一次出现的下标。
   String substring(int beginIndex, int endIndex)	返回字符串中从下标beginIndex（包括）开始到 endIndex（不包括）结束的子字符串
   String substring(int beginIndex)	返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串

intern方法

1. 一个初始为空的字符串池,由String类单独维护,当调用intern方法时，如果池已经包含一个等于此String对象的字符串（用equals(oject)方法确定），则返回池中的字符串。
2. 如果池中不存在一个等于此String对象的字符串:将此String对象添加到池中，并返回此String对象的引用。 对于任意两个字符串s和t，当且仅当s.equals(t)为true时，s.instan() == t.instan才为true。
3. 所有字面值字符串和字符串赋值常量表达式都使用 intern方法进行操作。

package com.company;
// intern 方法
public class Java_17 {

    public static void main(String[] args) {
        String Str1 = new String("ASD");
        String Str2 = new String("ASD");

        System.out.print("相等:" );
        System.out.println(Str1.intern());

        System.out.print("相等:" );
        System.out.println(Str2.intern());
    }
}

Java_ StringBuilder类

基本概念

1. 由于String类描述的字符串内容是个常量不可改变，当需要在Java代码中描述大量类似的字符串时，只能单独申请和存储，此时会造成内存空间的浪费

2. 为了解决上述问题，可以使用java.lang.StringBuilder类和java.lang.StringBuffer类来描述字符序列可以改变的字符串，如：“ab”。

3. StringBuffer类是从jdk1.0开始存在，属于线程安全的类，因此效率比较低。

4. StringBuilder类是从jdk1.5开始存在，属于非线程安全的类，效率比较高。

5. StringBuilder类常用的构造方法

   方法声明	功能介绍
   StringBuilder()	使用无参方式构造对象，容量为16
   StringBuilder(int capacity)	根据参数指定的容量来构造对象，容量为参数指定大小
   StringBuilder(String str)	根据参数指定的字符串来构造对象，容量为：16+字符串长度

   String s = new String("我喜欢学习"); // 定义 s 的值以后,就不能被修改了
   StringBuffer buffer = new StringBuffer("我喜欢学习");  // 还能被修改
   buffer.append("数学"); // 此时 buffer 的变为 "我喜欢学习数学"
   

6. StringBuilder类常用的成员方法

   方法声明	功能介绍
   int capacity()	用于返回调用对象的容量
   int length()	用于返回字符串的长度，也就是字符的个数
   StringBuilder insert(int offset, String str)	插入字符串并返回调用对象的引用，就是自己。
   StringBuilder append(String str)	追加字符串
   StringBuilder deleteCharAt(int index)	将当前字符串中下标为index位置的单个字符删除
   StringBuilder delete(int start，int end)	删除字符串
   StringBuilder replace(int start，int end，String str)	替换字符串
   StringBuilder reverse()	字符串反转

7. 当append和insert时，如果原来value数组长度不够，可扩容

8. 返回值的设计

   1. StringBuilder的很多方法的返回值均为StringBuilder类型。这些方法的返回语句均为：return this。
   2. 上述这些方法在对StringBuilder所封装的字符序列进行改变后又返回了该对象的引用。基于这样设计的目的在于可以连续调用

String,StringBuffer,StringBuilder之间的区别:

1. String:是不可变的字符序列
2. StringBuffer:可变字符序列,效率低,线程安全
3. StringBuilder:可变字符序列,效率高,线程不安全
4. 作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder会改变其值
5. StringBuilder的很多方法的返回值均为StringBuilder类型。这些方法的返回语句均为：return this。这些方法在对StringBuilder所封装的字符序列进行改变后又返回了该对象的引用。基于这样设计的目的在于可以连续调用。

Java_正则表达式

1. 正则表达式本质就是一个“规则字符串”，可以用于对字符串数据的格式进行验证，以及匹配、查找、替换等操作。该字符串通常使用^运算符作为开头标志，使用$运算符作为结尾标志，当然也可以省略。
2. 正则表达式的规则

正则表达式	说明
[abc]	可以出现a、b、c中任意一个字符
[^abc]	可以出现任何字符，除了a、b、c的任意字符
[a-z]	可以出现a、b、c、……、z中的任意一个字符
[a-zA-Z0-9]	可以出现az、AZ、0~9中任意一个字符
.	任意一个字符（通常不包含换行符）
\d	任意一个数字字符，相当于[0-9]
\D	任意一个非数字字符
\s	空白字符，相当于[\t\n\x0B\f\r]
\S	非空白字符
\w	任意一个单词字符，相当于[a-zA-Z_0-9]
\W	任意一个非单词字符
X?	表示X可以出现一次或一次也没有，也就是0 ~ 1次
X*	表示X可以出现零次或多次，也就是0 ~ n次
X+	表示X可以出现一次或多次，也就是1 ~ n次
X{n}	表示X可以出现恰好 n 次
X{n，}	表示X可以出现至少 n 次，也就是>=n次
X{n，m}	表示X可以出现至少 n 次，但是不超过 m 次，也就是>=n并且<=m次

正则表达式相关的方法

方法名称	方法说明
boolean matches(String regex)	判断当前正在调用的字符串是否匹配参数指定的正则表达式规则
String[] split(String regex)	参数regex为正则表达式，以regex所表示的字符串为分隔符，将字符串拆分成字符串数组
String replace(char oldChar, char newChar)	使用参数newChar替换此字符串中出现的所有参数oldChar
String replaceFirst(String regex, String replacement)	替换此字符串匹配给定的正则表达式的第一个子字符串
String replaceAll(String regex,String replacement)	将字符串中匹配正则表达式regex的字符串替换成replacement

Java_Java8之前的日期相关类

System类的概述

1. java.lang.System类:Java.lang.System类中提供了一些日期有用的类字段和方法。
2. 常用的方法:

方法声明	功能介绍
static long currentTimeMillis()	返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差

Date类的概述

1. java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒，可以精确到毫秒。

2. 常用的方法

   方法声明	功能介绍
   Date()	使用无参的方式构造对象，也就是当前系统时间
   Date(long date)	根据参数指定毫秒数构造对象， 参数为距离1970年1月1日0时0分0秒的毫秒数
   long getTime()	获取调用对象距离1970年1月1日0时0分0秒的毫秒数
   void setTime(long time)	设置调用对象为距离基准时间time毫秒的时间点

   package Java_9;
   import java.util.Date;
   public class Java_DateAPI {
       public static void main(String[] args) {
           Date date = new Date();
           System.out.println(date);
           System.out.println(System.currentTimeMillis());
           System.out.println(date.getTime());
           Date date1 = new Date(date.getTime());
           System.out.println(date1.getTime());
           System.out.println(date1.toString());
       }
   }
   

** SimpleDateFormat类**

1. java.text.SimpleDateFormat类主要用于实现日期和文本之间的转换

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

3. java.text.SimpleDateFormat:允许进行格式化：日期到文本、解析：文本到日期

4. 常用的方法

   方法声明	功能介绍
   SimpleDateFormat()	使用无参方式构造对象
   SimpleDateFormat(String pattern)	根据参数指定的模式来构造对象，模式主要有: y-年 M-月 d-日H-时 m-分 s-秒
   final String format(Date date)	用于将日期类型转换为文本类型
   Date parse(String source)	用于将文本类型转换为日期类型

5. public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。
   

Date date = new Date(); // 产生一个Date实例
// 产生一个formater格式化的实例
        SimpleDateFormat formater = new SimpleDateFormat();
        System.out.println(formater.format(date));// 打印输出默认的格式
        SimpleDateFormat formater2 = new SimpleDateFormat("yyyy年MM月dd日 EEE HH:mm:ss");
        System.out.println(formater2.format(date));
        try {
// 实例化一个指定的格式对象
            Date date2 = formater2.parse("2008年08月08日 星期一 08:08:08");
// 将指定的日期解析后格式化按指定的格式输出
            System.out.println(date2.toString());
        } catch (ParseException e) {
            e.printStackTrace();
        }

Calendar类

1. java.util.Calender类主要用于描述特定的瞬间，取代Date类中的过时方法实现全球化。
2. 该类是个抽象类，因此不能实例化对象，其具体子类针对不同国家的日历系统，其中应用最广泛的是GregorianCalendar（格里高利历），对应世界上绝大多数国家/地区使用的标准日历系统。
3. 常用的方法

方法声明	功能介绍
static Calendar getInstance()	用于获取Calendar类型的引用
void set(int year, int month, int date, int hourOfDay, int minute, int second)	用于设置年月日时分秒信息
Date getTime()	用于将Calendar类型转换为Date类型
void set(int field, int value)	设置指定字段的数值
void add(int field, int amount)	向指定字段增加数值

Java8中的日期相关类

Java8日期类的由来

1. JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：
   1. Date类中的年份是从1900开始的，而月份都从0开始。
   2. 格式化只对Date类有用，对Calendar类则不能使用。
   3. 非线程安全等

Java8日期类的概述

1. Java 8通过发布新的Date-Time API来进一步加强对 日期与时间的处理。
2. java.time包：该包日期/时间API的基础包。
3. java.time.chrono包：该包提供对不同日历系统的访问。
4. java.time.format包：该包能够格式化和解析日期时间对象。
5. java.time.temporal包：该包包含底层框架和扩展特性。
6. java.time.zone包：该包支持不同时区以及相关规则的类。

** LocalDate类的概述**

1. java.time.LocalDate类主要用于描述年-月-日格式的日期信息，该类不表示时间和时区信息。

2. 常用的方法

   方法声明	功能介绍
   static LocalDate now()	在默认时区中从系统时钟获取当前日期

LocalTime类

1. java.time.LocalTime 类主要用于描述时间信息，可以描述时分秒以及纳秒。
2. 常用的方法

方法声明	功能介绍
static LocalTime now()	从默认时区的系统时间中获取当前时间
static LocalTime now(ZoneId zone)	获取指定时区的当前时间

LocalDateTime类

1. java.time.LocalDateTime类主要用于描述ISO-8601日历系统中没有时区的日期时间，如2007-12-03T10:15:30。
2. 常用的方法

方法声明	功能介绍
static LocalDateTime now()	从默认时区的系统时间中获取当前日期时间
static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second)	根据参数指定的年月日时分秒信息来设置日期时间
int getYear()	获取年份字段的数值
int getMonthValue()	获取1到12之间的月份字段
int getDayOfMonth()	获取日期字段
int getHour()	获取小时数
int getMinute()	获取分钟数
int getSecond()	获取秒数
LocalDateTime withYear(int year)	设置为参数指定的年
LocalDateTime withMonth(int month)	设置为参数指定的月
LocalDateTime withDayOfMonth(int dayOfMonth)	设置为参数指定的日
LocalDateTime withHour(int hour)	设置为参数指定的时
LocalDateTime withMinute(int minute)	设置为参数指定的分
LocalDateTime withSecond(int second)	设置为参数指定的秒
LocalDateTime plusYears(long years)	加上参数指定的年
LocalDateTime plusMonths(long months)	加上参数指定的月
LocalDateTime plusDays(long days)	加上参数指定的日
LocalDateTime plusHours(long hours)	加上参数指定的时
LocalDateTime plusMinutes(long minutes)	加上参数指定的分
LocalDateTime plusSeconds(long seconds)	加上参数指定的秒
LocalDateTime minusYears(long years)	减去参数指定的年
LocalDateTime minusMonths(long months)	减去参数指定的月
LocalDateTime minusDays(long days)	减去参数指定的日
LocalDateTime minusHours(long hours)	减去参数指定的时
LocalDateTime minusMinutes(long minutes)	减去参数指定的分
LocalDateTime minusSeconds(long seconds)	减去参数指定的秒

LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

Instant类

1. java.time.Instant类主要用于描述瞬间的时间点信息。
2. 常用的方法

方法声明	功能介绍
static Instant now()	从系统时钟上获取当前时间
OffsetDateTime atOffset(ZoneOffset offset)	将此瞬间与偏移量组合以创建偏移日期时间
static Instant ofEpochMilli(longepochMilli)	根据参数指定的毫秒数来构造对象，参数为距离1970年1月1日0时0分0秒的毫秒数
long toEpochMilli()	获取距离1970年1月1日0时0分0秒的毫秒数

DateTimeFormatter类

1. java.time.format.DateTimeFormatter类主要用于格式化和解析日期。
2. java.time.format.DateTimeFormatter类：提供了三种格式化方法：预定义的标准格式,本地化相关的格式,自定义的格式
3. 常用的方法

方法声明	功能介绍
static DateTimeFormatter ofPattern(String pattern)	根据参数指定的模式来获取对象
String format(TemporalAccessor temporal)	将参数指定日期时间转换为字符串
TemporalAccessor parse(CharSequence text)	将参数指定字符串转换为日期时间

预定义的标准格式:ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
本地化相关的格式:如：ofLocalizedDateTime(FormatStyle.LONG)
自定义的格式:如：ofPattern(“yyyy-MM-dd hh:mm:ss”)