Java常用类，String、Arrays工具类、日期API、Java比较器

Java中的常用类

一、String

1.1 概述

• String类代表字符串，Java中所有字符串字面值(“abc”)都作为该类的实例
• String是一个final类(不可被继承)，代表不可变的字符序列
• 字符串是常量，用双引号引起来表示。它们的值在创建后不能被修改
• String对象的字符内容是存储在一个字符数据vlaue[]中
• String类实现了Serializable接口：表示字符串支持序列化
• 实现了Comparable接口：即String可以比较大小

1.2 不可变性

• 通过字面量的方式(区别去new)给一个字符串赋值，此时的字符串值声明在字符串常量池中
• 字符串常量池中不会存储相同内容的字符串
• 不可变性：
  • 当对字符串重新赋值时，需要重新指定内存区域赋值，不会在原有的value进行赋值
  • 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不会在原有的value中赋值

1.3 字符串实例化

• String str=“hello”;

• String s1=new String();

• String s2=new String(String original);

• String s3=new String(char[] a);

• String s4=new String(char[] a,int startIndex,int count);

• String str1="abc"和String str2=new String(“abc”)的区别

public class StringTest {
    @Test
    public void testString(){
        String s1="JavaEE";
        String s2="JavaEE";

        String s3=new String("JavaEE");
        String s4=new String("JavaEE");
        System.out.println(s1==s2) ;//true
        System.out.println(s3==s4);//false
        System.out.println(s1==s3);//false
    }
}

• 常见面试题

  public class StringTest {
      @Test
      public void testString(){
          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);//true
          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=s5.intern();//返回值为常量池中字符串的地址
          System.out.println(s3 == s8);//true
      }
  }
  

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

1.4 常用方法

• int length()：返回字符串长度：return value.length
• char chatAt(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)：返回一个新的字符串，它是此字符串的从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)：返回指定子字符串在此字符串中最右边出现处 的索引

1.5 可变字符序列

• String、StringBuffer、StringBuilder三者的区别：

  • StringBuffer和StringBuilder都是可变的字符序列
  • StringBuffer是线程安全的，效率偏低
  • StringBuilder是线程不安全的，效率高
  • 三者底层都使用char型数组存储

• 源码分析：

  • String底层是用final修饰的char型数组存储字符
  • StringBuffer底层创建了一个长度为16的char型数组

  //当初始化时传入参数，则底层创建该参数长度+16的一个char型数组
  public StringBuffer(String str) {
      super(str.length() + 16);
      append(str);
  }
  

  • StringBuffer的length()方法

  StringBuffer s = new StringBuffer("abc");
  System.out.println(s.length());//长度为3
  

  • 扩容：若添加的数组底层数组不能存放，则需要扩容。扩容为原来数组长度二倍并且+2，将原数组中的数组复制到新数组中

二、日期和时间

2.1 JDK8之前

• System.currentTimeMillis()返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差

    @Test
    public void test(){
        System.out.println(System.currentTimeMillis());
    }

2.2 Date类

1. java.util.Date类

   • 空参构造器Date()：

   @Test
   public void test(){
       Date date = new Date();
       System.out.println(date);//Tue Jul 28 12:43:12 CST 2020
       //获取当前Date对象的时间戳
       System.out.println(date.getTime());//1595911392711
   }
   

   • 构造器二：创建指定时间的Date对象

   @Test
   public void test2(){
       Date date = new Date(1595911392711L);
       System.out.println(date);//Tue Jul 28 12:43:12 CST 2020
   }
   

2. java.sql.Date类

   • java.sql.Date该类对应数据库中的Date类型

2.3 SimpleDateFormat类

2.3.1 概述

• Date类的API不易于国家化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类
• 它允许进行格式化：如期—>文本、解析：文本—>日期
• 格式化：
  • SimpleDateFormat()：默认的模式和语言环境创建对象
  • public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定格式创建一个对象
  • public String format(Date data)：方法格式化时间对象date
• 解析：
  • public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期

2.3.2 代码演示

    @Test
    public void testSimpleDateFormat() throws ParseException {
        //使用默认的格式化方式
        SimpleDateFormat dateFormat = new SimpleDateFormat();
        Date d = new Date();
        String s = dateFormat.format(d);
        System.out.println(s);//20-7-30 上午11:15
        //使用指定的格式化方式
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String s1 = format.format(d);
        System.out.println(s1);//2020-07-30 11:18:11
        //将字符串解析为日期
        Date parse = format.parse("2020-07-30 11:10:10");
        System.out.println(parse);//Thu Jul 30 11:10:10 CST 2020
    }

三、Arrays工具类

• 该类中封装了常用操作数组的方法
• boolean equals(int[] a,int[] b)：判断两个数组是否相等
• String toString(int[] a)：输出数组信息
• void fill(int[] a,int val)：将指定值填充到数组中
• void sort(int[] a)：对数组进行排序
• int binarySearch(int[] a,int key)：对排序后的数组进行二分查找检索指定的值

四、Java比较器

4.1 概述

• Java中的对象，正常情况下，只能比较：==或!=，若需要对多个对象进行排序，则需要两个接口中的一个：Comparable或Comparator
• 例如String、包装类等都实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象的规则
• 重写compareTo(obj)的规则：
  • 如果当前对象this大于形参对象obj，则返回正整数
  • 如果当前对象this小于形参对象obj，则返回负整数
  • 如果当前对象this等于形参对象obj，则返回0

4.2 代码演示

public 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 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 0;
            }
        }
        throw new RuntimeException("传入的类型错误！！！");
    }
}

4.3 Comparator

• Comparator接口：定制排序
• 当元素的类型没有实现Java.lang.Comparable接口而又不方便修改代码，或者实现了Comparable接口的排序规则不适合当前的操作，则可以考虑使用Comparator的对象来排序
• 重写compare(Object o1，Object o2)方法，比较o1和o2的大小

public class ComparableTest {
    public static void main(String[] args) {
        String[] arr=new String[] {"B","F","E","A","M","C"};
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //从大到小
                return -o1.compareTo(o2);
            }
        });
        System.out.println(Arrays.toString(arr));//[M, F, E, C, B, A]
    }
}