常用类

一、Objects类

1、Objects 与 Object 区别

Object 是 Java 中所有类的基类，位于java.lang包。

Objects 是 Object 的工具类，位于java.util包。它从jdk1.7开始才出现，被final修饰不能被继承。它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

2、常用方法

equals

equals方法是判断两个对象是否相等。

在比较两个对象的时候，Object.equals方法容易抛出空指针异常。

Object.equals方法内调用的是return (this == obj)。String类中是依据字符串内容是否相等来重定义了equals方法。

Objects.equals方法中已经做了非空判断，所以不会抛出空指针异常，它是null-save空指针安全的，而且也可以简化代码。

  public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }

requireNonNull

检查指定类型的对象引用不为空null。当参数为null时，抛出空指针异常。设计这个方法主要是为了在方法、构造函数中做参数校验。

   public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

二、Math类

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

//四舍五入
Math.round(-100.5)  = -100
//向下取整
Math.floor(3.5) = 3
//向上取整
Math.ceil(3.5) = 4

三、Arrays类

Arrays 是JDK提供的操作数组的工具类，array类提供了动态创建和访问 Java 数组的方法。
arrays此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

主要有一下几种用法。

toString：数组转换字符串

sort：对数组进行升序排列

fill：所有元素赋特定值

equals：判断数组是否相等

copyOf：对数组复制  （可以用来扩容数组，arr = copyOf(arr,newLenth)）

binarySearch:查询数组下标(二分查找)

asList:数组转换成集合

四、BigInteger类、BigDecimal类

BigInteger：

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

BigInteger提供所有Java的基本整数操作符的对应物，并提供 java.lang.Math的所有相关方法。另外，BigInteger还提供以下运算：模算术、GCD计算、质数测试、素数生成、位操作以及一些其他操作。

构造器： BigInteger(String val)：根据字符串构建 BigInteger对象

BigDecimal：

要求数字精度比较高，用到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)

五、关于操作时间的API

1、System类

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

2、java.util.Date类

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

 构造器

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

Date(long date)：创建指定时间的Date对象

常用方法

getTime()：返回自1970年1月1日00：00：00GMT以来此Date对象表示的毫秒数

tostring()：把此Date对象转换为以下形式的 String：

• dow mon dd
• hh: mm:ss zzz yyyy

其中：doW是一周中的某一天（Sun，Mon，Tue，Wed，Thu，Fri，Sat），zzz是时间标准。 其它很多方法都过时了

3、SimpleDateFormat类

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

它允许进行格式化：日期→文本、解析：文本→日期

格式化：

SimpleDateFormat()：默认的模式和语言环境创建对象

public SimpleDateFormat(String pattern)：该构造方法可以用参数 pattern指定的格式创建一个对象，该对象调用：public String format(Datedate)：方法格式化时间对象date

使用：

    

4、Calendar类

是一个抽象类，提供了操作日历字段（YEAR、MONTH、DAY_OF_MONTH)的方法

Calendar无法直接创建对象，但是有个静态方法getInstance()，返回一个Calendar类的一个子类的对象

常用方法：

set(int field, int value):将给定日历字段设定为给定值

Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, 6666);
c.set(Calendar.MONTH, 66);
c.set(Calendar.DATE, 6);

c.set(8888, 88, 8);// 一个重载的方法，同时设置年月日

另一个设置的方法是setTime(Date date); 直接传入一个Date对象

int get(int field):返回给定日历字段的值： 

Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);

int month = c.get(Calendar.MONTH);// 西方的月份0-11，中国月份1-12

 add(int field, int amount): 根据日历的规则，为给定的日历字段添加或者减去指定的时间量

Calendar c = Calendar.getInstance();
c.add(Calendar.YEAR, 10);// 年增加了10年
c.add(Calendar.YEAR, -11);// 年减少了11年

getTime(): 返回一个表示此Calendar时间值对应的Date对象（从0到现在的毫秒值对应的Date对象）

getActualMaxmun(int field):获得指定日历字段的最大值

Calendar c = Calendar.getInstance();
c.getActualMaxmun(Calendar.DAY_OF_YEAR)//一年有多少天
c.getActualMaxmun(Calendar.DAY_OF_MONTH)//当前这个月有多少天

 

六、String类

1、概述：

String类声明为final，不可被继承

String类实现了serializable接口：字符串支持序列化。

String类实现了comparable接口：可比较大小。

通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串声明在字符串常量池中。字符串常量池中不会存储内容相同的字符串。

String内部是final的char[]数组,是不可变的。当对字符串重新赋值、进行连接操作或者更改时，需要重新指定内存区域赋值。原来的内存区域不会被回收，会一直在那，当有另一个字符串需要相同的内容时，就直接给它。

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

2、String对象的创建

String str = "hello";
String str = new String();
String str = new String("hello");
String str = new String(char[] a);
...

前两种创建方式的区别：

//常量池中不能有重复的数据
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(s1 == s3);//false
System.out.println(s1 == s4);//false
System.out.println(s3 == s4);//false

String s =  new String("abc"), 创建了两个对象，一个是堆中new的结构，另一个是常量池中的"abc"

3、String的不同拼接操作

常量与常量的拼接，结果在常量池中，且常量池中只有一个相同内容的常量。

只要在拼接时，只要有一个是变量，结果就在堆中。(比如s1前面加一个final，s1也变成常量，s3==s4)

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

面试题：

因为String是不可变的

4、String常用方法

int length()：返回字符串的长度

char charAt(int index)：返回某索引的字符

boolean isEmpty()：字符串是否为空

String toUpperCase()：将string中所有字符串转化为大写

String toLowerCase()：将string中所有字符串转化为小写

String trim()：字符串前面和后面的空格，用于用户的账号登录

boolean equals(String s)：比较字符串内容是否相同

boolean equalsIgnoreCase(String s)：比较字符串大小，忽略大小写

String concat(Stringg s)：将s连接到尾部，等价于+

int compareTo(String s)：比较字符串的大小

String subString(int beginIndex)：从下标beginIndex开始的子字符串

String subString(int beginIndex, int endIndex)：[ beginIndex, endIndex) 区间的子字符串

boolean contains(String s)：目标串是否包含s

int IndexOf(String s)：目标串，第一次出现s的下标

String replace(old,new)：把old替换成new，可以是字符，也可以是字符串

5、string和其他类型的转换

String和基本数据类型，包装类之间的转换

//string -> 基本数据类型，包装类
String s1 = "123";
int num = Integer.parseInt(s1);
//基本数据类型，包装类 -> string
String s2 = String.valueOf(num);
String s3 = num + "";
System.out.println(s1 == s3);//false,s1在常量池中，s3在堆里

String和char[]之间的转换

//string -> char[]
String s1 = "123";
char[] c = s1.toCharArray();
//char[] -> string
char[] chars = new char[]{'h','e','l','l','o'};
String s2 = new String(chars);

String和byte[]之间的转换

//string -> byte[]
String s1 = "123";
byte[] b = s1.getBytes();
//byte[] -> string
String s = new String(b);

6、StringBuffer和stringBuilder

String：不可变的字符串序列，效率最差(频繁的改变字符串)

StringBuffer：可变的字符串序列，线程安全，效率低

stringBuilder：可变的字符串序列，线程不安全，效率高

常用方法（两者一样）：

append(xxx)：字符串拼接

reserve()：字符串反转

delete(int start ,int end)：删除指定位置上的字符串

insert(int index, xxx)：在指定位置上插入

setCharAt(int index,char c)：改变指定位置上的字符

replace(int start,int end, xxx)：[start,end)区间的字符串替换成其他的

其他例如：indexOf、substring、length用法一样

String拼接字符串效率最差的原因是：每次改变字符串都会新占用一片空间，并且原来的空间不会被回收。

二、比较器

1、说明

java的中的对象，正常情况下，只能进行比较只有等或者不等。但在开发中，我们需要对多个对象进行排序。

使用Comparable 或者 comparator接口

2、Comparable使用

像String、包装类等实现了Comparable接口，重写了compareTo()方法，给出了两个对象的比较方式。

重写compareTo()的规则:

     如果当前对象this大于形参对象，则返回正整数；

     如果当前对象this小于形参对象，则返回负整数；

     如果当前对象this等于形参对象，则返回零；

3、自定义类实现Comparable接口

对于自定义类来说如果要排序，需要实现Comparable接口，重写compareTo()方法。在compareTo()方法中指明如何排序

import java.util.Arrays;

public class Main
{
    public static void main(String[] args){
        Goods[] arr = new Goods[4];
        arr[0] = new Goods("鼠标",100);
        arr[1] = new Goods("耳机",50);
        arr[2] = new Goods("键盘",200);
        arr[3] = new Goods("显示屏",180);
        Arrays.sort(arr);
        
    }

}
//实现接口
class Goods implements Comparable{
    private String name;
    private double price;

    public Goods() {
        super();
    }
    public Goods(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }
    @Override
    public String toString() {
        return "Goods [nameString=" + name + ", price=" + price + "]";
    }
    //重写compareTo方法
    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods){
            Goods goods = (Goods)o;
            if(this.price > goods.price){
                return 1;
            }
            if(this.price < goods.price){
                return -1;
            }else {
                //如果价格一样比较，名字从高到低
                return -this.name.compareTo(goods.name);
            }
        }
        throw new RuntimeException("传入数据类型不一致");
    }

}

4、Comparator使用

当元素类型没有实现comparable接口，又不方便改代码；或者comparable接口的排序规则不是自己想要的，可以考虑使用Comparator的对象来排序

String[] s = new String[]{"AA","BB","CC","DD","EE"};
Arrays.sort(s,  new Comparator<String>(){
            
    @Override
    public int compare(String s1, String s2) {
        return -s1.compareTo(s2);//字符串从大到小
    }
});

Arrays.sort(arr, new Comparator<Goods>() {
    //产品的名称从低到高，再按价格从高到低
    @Override
    public int compare(Goods o1, Goods o2) {
        if(o1.getName().equals(o2.getName())){
            if(o1.getPrice() > o2.getPrice()){
                return -1;
            }
            if(o1.getPrice() < o2.getPrice()){
                return 1;
            }else {
                return 0;
            }
        }else{
            o1.getName().compareTo(o2.getName());
        }
    }
});