Java14-常用类：字符串，日期类，比较器

一：字符串：String

1.概述：

String：字符串，使用一对""引起来表示。

1.String 声明为final的，不可被继承

2.String 实现了Serializable接口：表示字符串是支持序列化的。

实现了Comparable接口：表示String 可以比较安心

3.String 内部定义了final char[] value 用于存储字符串数据

4.String :代表不可变的字符序列。简称：不可变性。

体现：1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value

进行赋值

2.当对现在的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的

value进行赋值

3.当调用String的replace（)方法，修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

5.通过字面量的方式（区别于new给一个字符串赋值，此时的字符串值声明在字符串常量池中）

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

2.string的不可变性

2.1 说明

1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值

2.当对现在的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的

value进行赋值

3.当调用String的replace（)方法，修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

2.2代码举例：

@Test

public void test1(){

String s1="abc";//字面量的定义方式

String s2="abc";

System.out.println(s1==s2)//比较s1和s2的地址值

s1="hello";

System.out.println(s1)//hello

System.out.println(s2)//abc

String s3="abc";

s3+="def";

System.out.println(s3)//abcdef

System.out.println(s2);

String s4="abc";

String s5=s4.replace('a','m');

System.out.println(s4);//abc

System.out.println(s5);//mbc

3.String实例化的不同方式

3.1 方式说明：

方式一：通过字面量定义的方式

方式二：通过new +构造器的方式

3.2代码举例

//通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区的字符串常量池中

String s1="javaEE";

String s2="javaEE";

//通过new+构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值

String s3= new String("javaEE");

String s4= new String("javaEE");

System.out.println.println(s1==s2);//true

System.out.println.println(s1==s3);//false

System.out.println.println(s1==s4);//false

System.out.println.println(s3==s4);//false

3.3面试题：

String s= new String("abc");方式创建对象，在内存中创建几个对象？

两个，一个是堆空间中的new结构，另一个是char[]对应的常量池中的数据："abc"

3.4图示

4.字符串拼接方式赋值的对比：

4.1说明

1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量

2.只要其中一个是变量，结果就在堆中。

3.如果拼接的结果调用intern()方法，返回值就在常量池中

4.2代码举例

String s1=""javaEE;

String s2="hadoop";

String s3="javaEEhadoop";

String s4="javaEE"+"hadoop";

String s5=s1+"hadoop";

String s6="javaEE"+s2;

String s7=s1+s2;

System.out.println(s3==s4);//ture

System.out.println(s3==s5);//false

System.out.println(s3==s6);//false

System.out.println(s3==s7);//false

System.out.println(s5==s6);//false

System.out.println(s5==s7);//false

System.out.println(s6==s7);//false

String s8=s6.intern();//返回值得到的s8使用的常量值中已经存在的"javaEEhadoop"

System.out.println(s3==s8);//true

5.常用方法：

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 equalsIgnoreCase(String anotherString):与equals方法类似，忽略大小写

String concat(String str):将指定字符串连接到此字符串的结尾。等价于用“+”

int compareTo(String anotherString):比较两个字符串的大小

String substring(int beginIndex):返回一个新的字符串，它是此字符串从begin'Index开始截取到最后的一个子字符串

String substring(int beginIndex，int endInedx):返它是此字符串从begin'Index开始截取到endIndex(不包含)的一个子字符串

boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束

boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始

boolean startsWith(String prefix，int toffset):测试此字符串从指定索引开始的字符串，是否以指定的前缀开始

int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引

int indexOf(String str，int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引,并从指定的索引开始

int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引

int lastIndexOf(String str，int fromIndex):返回指定子字符串在此字符串中最右边出现处的索引,并从指定的索引开始

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

替换：

String replace(char oldchar,char newChar ):返回一个新的字符串，它是通过newChar替换此字符串中出现的oldChar得到的

String replace(charSequence target,charSequence replacement ):使用指定的字面值替换序列替换此字符串所匹配字面值目标序列的子字符串。

String repalceAll(String regex,String replacment):使用给定的replacment 替换此字符串所匹配给定的正则表达式的子字符串

String repalceFirst(String regex,String replacment):使用给定的replacment 替换此字符串所匹配给定的正则表达式的第一个子字符串

匹配：

boolean mathces (String regex):告知此字符串是否匹配给定的正则表达式

切片：

String[] split(String regex):根据给定正则表达式的匹配拆分此字符串

String[] split(String regex，int limit):根据匹配给定的正则表达式来拆分此字符串，最多不超过limit 个，如果超过了，剩下的全部都放到最后一个元素中

6 String 与其他结构的转换

6.1 与基本类型/包装类之间的转换

String---》基本数据类型，包装类调用包装类的静态方法：parseXxx（str）

基本数据类型，包装类---》String :调用String重载的valueOf(xxx)

6.2 与字符数组之间的转换

String ---》char[]:调用String的toCharArray()

char[]---》String:调用String的构造器

@Test

public void test1(){

String str1="abc123";

char[] charArray= str1.toCharArray();

for(int i=0;i<charArray.length;i++){

System.out.println(charArray[i]);

char[] arr =new char[]{'h','e','l','l','o'};

String str2=new String(arr);

System.out.println(str2);

}

6.3与字节数组之间的转换

编码：String--》byte[]:调用String的getBytes（）

解码：byte[]--》String:调用String的构造器

编码：字符串--》字节（看的懂--》看不懂的二进制数据）

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

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

@Test

public void test2()throws UnsupportedEncodingException{

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));

System.out.println("**************");

String str2= new String(bytes);//使用默认的字符集进行解码

System.out.println（str2)；

String str3=new String(gbks);

System.out.println（str3)；//出现乱码，原因：编码集和解码集不一致

String str4=new String(gbks,"gbk");

System.out.println（str4)；//没有出现乱码，原因：编码集和解码集一致

6.4与StringBuffer，StringBuilder 之间的转换

String--》StringBuffer，StringBuilder:调用StringBuffer，StringBuilder的构造器

StringBuffer，StringBuilder--》String 1调用String的构造器 2调用StringBuffer，StringBuilder的toString（）

7.JVM中字符串常量池存放的位置说明：

jdk1.6（jdk6.0）：字符串常量池存储在方法区（永久区）

jdk1.7：字符串常量池存储在堆空间

jdk1.8：字符串常量池存储在方法区（元空间）

8.常见算法题目的考查：

1.将一个字符串进行反转。将字符串中指定部分进行反转。比如："abcdefg"反转为"abfedcg"

方法1：
public String stringRerverse(String str, int startIndex, int endIndex) {

    char[] chars = str.toCharArray();
    for (int x = startIndex, y = endIndex; x < y; x++, y--) {
        char temp = chars[x];
        chars[x] = chars[y];
        chars[y] = temp;


    }
    return new String(chars);


}
方法2：
public String stringRerverse2(String str, int startIndex, int endIndex) {
    String strRerverse=str.substring(0,startIndex);
    for(int y=endIndex;y>=startIndex;y--){
        strRerverse+=str.charAt(y);
    }
    strRerverse+=str.substring(endIndex+1);
    return strRerverse;
}
方法3：
public String stringRerverse3(String str, int startIndex, int endIndex) {
    StringBuilder builder =new StringBuilder(str.length());
    //第一步：
    builder.append(str.substring(0,startIndex));
    for(int y=endIndex;y>=startIndex;y--){
        builder.append(str.charAt(y));


    }
    builder.append(str.substring(endIndex+1));
    return builder.toString();
}

2.获取一个字符串在另一个字符串中出现的次数，比如：获取“ab”在“abddddeeeabddddeeeabddddeeabd”中出现的次数

方法1：

public  int getCount(String mainStr,String  subStr){
      int  mainLength= mainStr.length();
      int  subLength= subStr.length();
      int count=0;
      int index=0;
      if(mainLength>subLength){
          while((index=mainStr.indexOf(subStr))!=-1){
              count++;
              mainStr=mainStr.substring(index+subLength);

          }

      return count;
      }
      return 0;



}
方法2：
public int getCount2(String mainStr,String  subStr) {
    int mainLength = mainStr.length();
    int subLength = subStr.length();
    int count = 0;
    int index = 0;
    if (mainLength > subLength) {
        while ((index = mainStr.indexOf(subStr, index)) != -1) {
            count++;
            index += subLength;

        }

        return count;
    }
    return 0;
}

二：日期类

1.java.util.Date 和java.sql.Date 类，java.sql.Date 类是java.util.Date的子类

public void test1(){
    //java.util.Date
    //构造器1：Date（）,创建一个应当当前时间的Date对象
    Date  date = new Date();
    System.out.println(date);
    //getTime()返回long 型毫秒数
    long time = date.getTime();
    System.out.println(time);
    //构造器2：Date（）,创建一个指定毫秒数的Date对象
    Date date2 =new Date(1683983578676L);
    System.out.println(date2);
   // java.util.Date  转换为java.sql.Date
    java.sql.Date date3 = new java.sql.Date(date.getTime());
    System.out.println(date3);
    System.out.println(date3.getClass());

}

2.calender 类：日历类，抽象类

@Test
public void test2(){
    //实例化
    Calendar cal = Calendar.getInstance();
    //常用方法：
    //get()
    int i = cal.get(Calendar.DAY_OF_MONTH);
    System.out.println(i);
    int i1 = cal.get(Calendar.DAY_OF_WEEK);
    System.out.println(i1);
    //set(),修改属性
    cal.set(Calendar.DAY_OF_MONTH,15);
     i = cal.get(Calendar.DAY_OF_MONTH);
    System.out.println(i);

    //getTime() 日历类--》Date类
    Date time = cal.getTime();
    System.out.println(time);
    //setTime():Date类--》日历类
    Date date = new Date();
    cal.setTime(date);
    int days =cal.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);


}

3.SimpleDateFormat：日期的格式化和解析

@Test
public void test3() throws ParseException {
   SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
   Date date = new  Date();
    //格式化：即把日期转化为string
    String format = sdf.format(date);
    System.out.println(format);
    //解析：把字符串转换为日期
    Date parse = sdf.parse(format);
    java.sql.Date date1 =new java.sql.Date(parse.getTime());
    System.out.println(date1);
    
}

4.LocalDate ， LocalTime ，LocalDateTime jdk8的日期类，LocalDateTime比较常用

@Test
public void test4(){
    //获取当前日期
    LocalDate now = LocalDate.now();
    System.out.println(now);
    //获取当前日期+时间
    LocalDateTime dateTime = LocalDateTime.now();
    System.out.println(dateTime);
    //of():设置指定的年月日，时分秒，没有偏移量
    LocalDateTime localDateTime = LocalDateTime.of(2022, 04, 05,10,10,30);
    System.out.println(localDateTime);
    //getXX()
    int dayOfMonth = localDateTime.getDayOfMonth();
    System.out.println(dayOfMonth);
    int dayOfYear = localDateTime.getDayOfYear();
    System.out.println(dayOfYear);

    //体现不可变性
    LocalDate localDate = now.withDayOfMonth(22);
    System.out.println(now);
    System.out.println(localDate);
    
}

5 DateTimeFormat ：类似SimpleDateFormat：日期的格式化和解析

@Test
public void test5(){

    //实例化
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM--dd hh:mm:ss");
    LocalDateTime now = LocalDateTime.now();
    //格式化日期  日期---》字符串
    String format = dateTimeFormatter.format(now);
    System.out.println(dateTimeFormatter);
    System.out.println(format);
    //解析 字符串-->日期
    TemporalAccessor parse = dateTimeFormatter.parse(format);
    System.out.println(parse);
    System.out.println(parse.getClass());
    
}

三：比较器Compareble 和Comparator

1.使用说明：

java中的对象，正常情况下，只能进行比较：==或者！=，不能使用>或<,但是

在开发场景中，我们需要对多个对象进行排序，言外之意：就需要比较对象的大小，如何实现？使用两个接口中的任意一个：Comparable或Comparator

2.代码举例说明（Comparable）：

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

    public Goods() {
    }

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

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods){
            Goods good = (Goods)o;
            if(this.price>good.price){
                return 1;
            }else if ((this.price<good.price)){
                return -1;
            }else{
                return -this.name.compareTo(good.name);
            }


        }
        throw new RuntimeException("输入类型不匹配！");
    }
}

public class CompareTest {
    @Test
    public void test1(){
        String [] arr =new String [] {"FF","BB","EE","AA"};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println("****************************");
        Goods[] arr1 =new Goods[5];
        arr1[0]= new Goods("lianxiangmouse",44);
        arr1[1]= new Goods("xiaomi",14);
        arr1[2]= new Goods("Micrsoft",64);
        arr1[3]= new Goods("dell",54);
        arr1[4]= new Goods("huawei",64);
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
    }



}

3.代码举例说明（Comparator）：

class Good {
    private String name;
    private double price;

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    public Good() {
    }

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

    @Override
    public String toString() {
        return "Good{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }


}

public class ComparetorTest {



     @Test
    public void test1(){
         Good[] arr1 =new Good[5];
         arr1[0]= new Good("lianxiangmouse",44);
         arr1[1]= new Good("xiaomi",14);
         arr1[2]= new Good("Micrsoft",64);
         arr1[3]= new Good("dell",54);
         arr1[4]= new Good("huawei",64);
         Arrays.sort(arr1, new Comparator() {
             @Override
             public int compare(Object o1, Object o2) {
            if(o1 instanceof Good && o2 instanceof Good){
                Good g1 = (Good)o1;
                Good g2 = (Good)o2;
                if(g1.getPrice()>g2.getPrice()){
                    return -1;
                }else if(g1.getPrice()<g2.getPrice()){
                    return 1;
                }else{
                    return g1.getName().compareTo(g2.getName());
                }

            }
            throw new RuntimeException("类型不匹配");
             }
         });
         System.out.println(Arrays.toString(arr1));



     }
}

4.两种排序方式比较：

》Comparable 接口方式一旦一定，保证Comparable接口实现类的对象放在任何位置都可以比较

》Comparator接口属于临时性的比较

四：其他常用类

1.System类：

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

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

》方法：

native long currentTimeMillis（）

void eixt（int stutaus）

void gc（）

String getProperty（String key）

2.Math类：

》java.lang.Math 提供了一系列用于科学计算的静态方法，其方法的参数或返回值为double类型

3.BigInteger 类和BigDecimal类

1.说明：

》java.math包的BIgInteger 可以表示不可变的任意精度的整数

》要求数字精度比较高，就用java.math.BigDecimal

2.代码举例：

@Test
public void test1(){
    BigInteger b1 =new BigInteger("12433241123");
    BigDecimal bd= new BigDecimal("12435.351");
    BigDecimal bd2= new BigDecimal("11");
    System.out.println(b1);
 System.out.println(bd.divide(bd2,BigDecimal.ROUND_HALF_UP));
    System.out.println(bd.divide(bd2,15,BigDecimal.ROUND_HALF_UP));

}