java基础（6）常用API

1 Object类

`java.lang.Object`类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类， 那么默认则继承自Object类。例如：

public class MyClass /*extends Object*/ {
// ...
}

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。这里以其中的2个为例：

* `public String toString()`：返回该对象的字符串表示。
* `public boolean equals(Object obj)`：指示其他某个对象是否与此对象“相等”。

1.1 toString方法

toSttring方法：`public String toString()`：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，没有什么意义。

而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

//自定义一个名为toString的类
public class toString {
    String name;
    int id;

//重写toString方法
    @Override
    public String toString(){
        return "toString{name="+name+",id="+id+"}";//返回值是一个字符串，按照自己的需要拼接成自定义的该类的字符串信息
    }
}

//测试
public class testToSring {
    public static void main(String[] args) {

        System.out.println(new toString());
    }
}

//Output
toString{name=null,id=0}

//这个是编译器自动重载所写的toString，可以看到就是字符串拼接，拼接类的名字和成员变量信息
@Override
    public String toString() {
        return "toString{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }

1.2 equals方法

public boolean equals(Object obj)

1.2.1 默认地址比较:

如果自定义类中没有覆盖重写equals方法，那么Object类中默认进行`==`运算符的对象地址比较，只要不是同一个对象，结果必然为false。

public class myEquals {
    String name;
    int age;
}

public class myEquealsTest {
    public static void main(String[] args) {
        myEquals m1 = new myEquals();
        myEquals m2 = new myEquals();

        System.out.println(m1.equals(m2));
        System.out.println("=========");
        m2 = m1;//将m1赋予m2
        System.out.println(m1.equals(m2));
    }
}

//Output
false
=========
true

1.2.2 重写equals方法-对象内容比较

比如String类就重写了该方法：

//Java 源码，对字符串的内容进行比较
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

如果我自定义了一个Person类，需要进行内容比较，也需要重写equals方法

public class Person {
    private String name;
    private int age;

    @Override//IDEA中按住alt+Insert选择重写equals方法
    public boolean equals(Object o) {
        // 如果对象地址一样，则认为相同
        if (this == o)
            return true;
        // 如果参数为空，或者类型信息不一样，则认为不同。使用反射技术，判断o是否为Person类型
        if (o == null || getClass() != o.getClass())
            return false;
        // 转换为当前类型
        Person person = (Person) o;
        // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
        return age == person.age && Objects.equals(name, person.name);
    }
}

上述代码充分考虑了对象是否为本身、为空、类型不一致等问题。

注意：

代码中有这句话：
Objects.equals(name, person.name)

Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。

Objects类的作用：String类的两个对象比较的时候，防止抛出空指针异常。

~~~java源码
public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}
~~~
源码解读：

为什么上述源码只判断了Object a是否为空呢？

首先： null是不能调用方法的（null表示没有创建对象，没有在队内存中分配空间）,会抛出空指针异常。

所以源码中先判断a不为空，再用a来调用equals方法，所以不需要判断b是否为空。

下面是一个例子：

import java.util.Objects;

public class Demo03Objects {
    public static void main(String[] args) {
        String s1 = "abc";
        //String s1 = null;
        String s2 = "abc";
        //boolean b = s1.equals(s2); // 抛出NullPointerException异常，因为 null是不能调用方法的,会抛出空指针异常
        //System.out.println(b);
        /*
            Objects类的equals方法:对两个对象进行比较,防止空指针异常
            public static boolean equals(Object a, Object b) {
                return (a == b) || (a != null && a.equals(b));
            }
         */
        boolean b2 = Objects.equals(s1, s2);
        System.out.println(b2);

    }
}

2 Date类

2.1 Date类概述

/*
    java.util.Date:表示日期和时间的类
    类 Date 表示特定的瞬间，精确到毫秒。
    毫秒:千分之一秒 1000毫秒=1秒
    特定的瞬间:一个时间点,一刹那时间
    2088-08-08 09:55:33:333 瞬间
    2088-08-08 09:55:33:334 瞬间
    2088-08-08 09:55:33:334 瞬间
    ...
    毫秒值的作用:可以对时间和日期进行计算
    2099-01-03 到 2088-01-01 中间一共有多少天
    可以日期转换为毫秒进行计算,计算完毕,在把毫秒转换为日期

    把日期转换为毫秒:
        当前的日期:2088-01-01
        时间原点(0毫秒):1970 年 1 月 1 日 00:00:00(英国格林威治)
        就是计算当前日期到时间原点之间一共经历了多少毫秒 (3742767540068L)
    注意:
        中国属于东八区,会把时间增加8个小时
        1970 年 1 月 1 日 08:00:00

    把毫秒转换为日期:
        1 天 = 24 × 60 × 60 = 86400 秒  = 86400 x 1000 = 86400000毫秒
 */
public class Demo01Date {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());//获取当前系统时间到1970 年 1 月 1 日 00:00:00经历了多少毫秒
    }
}

2.2 Date类的构造方法

2.2.1 空参数构造

public class MyDateTest {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());

        demo01();
    }

    /*
       Date类的空参数构造方法
       Date() 获取当前系统的日期和时间
    */
    private static void demo01() {
        Date date = new Date();
        System.out.println(date);//Sun Jan 20 16:57:40 CST 2019，直接打印date，不是一个地址，说明Date类重写了toString方法

    }
}

2.2.2 带参数构造

public class MyDateTest {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());

        demo02();
    }

    /*
        Date类的带参数构造方法
        Date(long date) :传递毫秒值,把毫秒值转换为Date日期
     */
    private static void demo02() {
        Date date = new Date(1547974660147L);
        System.out.println(date);// Sun Jan 20 17:00:23 CST 2019
    }
}

2.2.3 getTime方法

////

Date类中的多数方法已经过时，常用的方法有： * `public long getTime()` 把日期对象转换成对应的时间毫秒值。

public class MyDateTest {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());

        demo03();
    }

  /*
        long getTime() 把日期转换为毫秒值(相当于System.currentTimeMillis()方法)
          返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
     */
    private static void demo03() {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);
    }
}

2.3 DateFormate类和SimpleDateFormate类

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。

日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期 -> 文本）、解析（文本-> 日期）和标准化。

将日期表示为 Date 对象，或者表示为从 GMT（格林尼治标准时间）1970 年 1 月 1 日 00:00:00 这一刻开始的毫秒数。

DateFormat类：是一个抽象类

要格式化一个当前语言环境下的日期，可使用某个静态工厂方法：

  myString = DateFormat.getDateInstance().format(myDate);

//使用示例

Date date = new Date();//可以不填参数，默认为系统当前时间
        String myString = DateFormat.getDateInstance().format(date);
        System.out.println(myString);//2019-1-20

        Date date2 = new Date(10120133110L);//也可以传入毫秒值
        String myString2 = DateFormat.getDateInstance().format(date2);
        System.out.println(myString2);//1970-4-28

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类`java.text.SimpleDateFormat`。

这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

* `public SimpleDateFormat(String pattern)`：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

//SimpleDateFormat的格式化方法使用示例
public class MyDateFormateTest1 {
    public static void main(String[] args) {
        // 第1步.创建SimpleDateFormat对象，构造方法中传递指定的模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd/ HH/mm/ss/");//第一种格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");//第二种格式

        //第2步.创建Date对象，将其传入SimpleDateFormat的format方法，按照构造方法中指定的模式，将Date对象转换成符合模式的字符串（文本）
        Date date = new Date();
        Date date2 = new Date(123456789L);
        String myString1 = sdf.format(date);
        String myString2 = sdf2.format(date2);
        System.out.println(myString1);//   2019/01/20/ 19/56/07/
        System.out.println(myString2);//   1970年01月02日 18时17分36秒
    }
}

//SimpleDateFormat的解析方法parse使用示例

//Java中该parse方法的源码，按照该源码写代码
public Date parse(String source) throws ParseException
    {
        ParsePosition pos = new ParsePosition(0);
        Date result = parse(source, pos);
        if (pos.index == 0)
            throw new ParseException("Unparseable date: \"" + source + "\"" ,
                pos.errorIndex);
        return result;
    }

//使用parse方法的步骤：
//第一步：创建SimpleDateFormat对象,构造方法中传递指定的模式
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
//第二步：String format(Date date)  按照指定的模式,把Date日期,格式化为符合模式的字符串
String source = new String("1990-10-10 10-20-20");//如果这里输入的字符串的模式不符合上面的模式，就会抛出异常
Date returnDate = new Date();
try {
    returnDate = sdf3.parse(source);
} catch (ParseException e) {
    e.printStackTrace();
}
System.out.println(returnDate);

2.4 Calendar类

2.4.1 Calendar抽象类获取对象的方法

Calendar 类是一个抽象类，无法创建对象使用。里面有一个静态方法getInstance()，该方法返回了一个Calendar子类对象：

public class myCalendar {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();//Calendar.getInstance()直接返回一个Calendar的子类对象。
                                                    // 父类，接收子类对象，存在多态
        System.out.println(calendar);
        //java.util.GregorianCalendar[time=1547987922275,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=0,WEEK_OF_YEAR=4,WEEK_OF_MONTH=4,DAY_OF_MONTH=20,DAY_OF_YEAR=20,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=38,SECOND=42,MILLISECOND=275,ZONE_OFFSET=28800000,DST_OFFSET=0]
    }
}

//返回了一组诸如 YEAR，MONTH，DAY_OF_MONTH，HOUR等的日历字段

2.4.2 Calendar类的常用成员方法

根据Calendar类的API文档，常用方法有：

- `public int get(int field)`：返回给定日历字段的值。
- `public void set(int field, int value)`：将给定的日历字段设置为给定值。
- `public abstract void add(int field, int amount)`：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
- `public Date getTime()`：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

//field：
Calendar类中提供很多成员常量，代表给定的日历字段：

| 字段值 | 含义 |
| ------------ | -------------------- |
| YEAR | 年 |
| MONTH | 月（从0开始，可以+1使用） |
| DAY_OF_MONTH | 月中的天（几号） |
| HOUR | 时（12小时制） |
| HOUR_OF_DAY | 时（24小时制） |
| MINUTE | 分 |
| SECOND | 秒 |
| DAY_OF_WEEK | 周中的天（周几，周日为1，可以-1使用） |

//使用示例

public class MyCalendar2 {
    public static void main(String[] args) {
        //获取日历对象对应的的日期
        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(year +"月" +month+"月" +day+"日");//2019月1月20日

        //设置日历中某个字段的值
        c.set(1234,2,5);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH)+1;
        day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(year +"月" +month+"月" +day+"日");//1234月3月5日

        //在日历对象上增加年月日
        c.add(Calendar.YEAR,23);
        c.add(2,1);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH)+1;
        day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(year +"月" +month+"月" +day+"日");//1257月4月5日

        //获取日历对象对应的日期
        Date date = c.getTime();
        System.out.println(date);//Thu Apr 05 21:02:53 CST 1257
    }
}

3 System类

import java.util.Arrays;

public class MySystem {
    public static void main(String[] args) {
        demo01();
        demo02();
    }

    //System.currentTimeMillis()方法
    private static void demo01() {
        long t0 = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
        long t1 = System.currentTimeMillis();

        System.out.println(t1-t0);
    }

    //System.arraycopy()方法
    private static void demo02() {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.out.println("复制后"+Arrays.toString(dest));
        System.arraycopy( src, 1, dest, 0, 3);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }//2 3 4 9 10
        //还可以使用Arrays类中的toString方法打印
        System.out.println("复制后"+Arrays.toString(dest));//复制后[2, 3, 4, 9, 10]
    }
}

4 StringBuilder类

4.1 字符串拼接问题

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

~~~java
public class StringDemo {
public static void main(String[] args) {
String s = "Hello";
s += "World";
System.out.println(s);
}
}
~~~
其实总共产生了三个字符串，即`"Hello"`、`"World"`和`"HelloWorld"`。引用变量s首先指向`Hello`对象，最终指向拼接出来的新字符串对象，即`HelloWord` 。

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。底层是一个被final修饰的量。

如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用`java.lang.StringBuilder`类。

4.2  StringBuilder概述

StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

底层也是一个数组，但是没有被final修饰，可以改变长度。

4.3 构造方法

根据StringBuilder的API文档，常用构造方法有2个：

- `public StringBuilder()`：构造一个空的StringBuilder容器。
- `public StringBuilder(String str)`：构造一个StringBuilder容器，并将字符串添加进去。

public class MyStringBuilder {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println("不带参数构造字符串："+sb1);

        StringBuilder sb2 = new StringBuilder("abssssweweweweeeeeeee");
        System.out.println("带参数构造字符串："+sb2);
    }
}

//Output

不带参数构造字符串：
带参数构造字符串：abssssweweweweeeeeeee

4.4 Append方法和toString方法

public static void main(String[] args) {
        //创建对象
        StringBuilder builder = new StringBuilder();
        //public StringBuilder append(任意类型)
        StringBuilder builder2 = builder.append("hello");
        //对比一下
        System.out.println("builder:"+builder);
        System.out.println("builder2:"+builder2);
        System.out.println(builder == builder2); //true
        // 可以添加 任何类型
        builder.append("hello");
        builder.append("world");
        builder.append(true);
        builder.append(100);
        // 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
        // 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
        //链式编程
        builder.append("hello").append("world").append(true).append(100);
        System.out.println("builder:"+builder);
    }

public class Demo16StringBuilder {
    public static void main(String[] args) {
        // 链式创建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 调用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }
}

5 包装类

5.1 包装类概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，

如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类。

| 基本类型    | 对应的包装类（是某一种类，位于java.lang包中，无需导包） |
| ------- | --------------------- |
| byte    | Byte                  |
| short   | Short                 |
| int     | **Integer**           |
| long    | Long                  |
| float   | Float                 |
| double  | Double                |
| char    | **Character**         |
| boolean | Boolean               |

5.2 装箱和拆箱

* **装箱**：从基本类型转换为对应的包装类对象。

* **拆箱**：从包装类对象转换为对应的基本类型。

/*
    装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        构造方法两种:
            Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
            Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
                传递的字符串,必须是基本类型（int double等是基本类型，String不是基本类型）的字符串,否则会抛出异常 "100" 正确  "a" 抛异常
        静态方法:
            static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
            static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
    拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        调用Integer类的成员方法:
            int intValue() 以 int 类型返回该 Integer 的值。
 */
public class Demo01Integer {
    public static void main(String[] args) {
        //装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        //构造方法
        Integer in1 = new Integer(1);//方法上有横线,说明方法过时了
        System.out.println(in1);//1 重写了toString方法

        Integer in2 = new Integer("1");
        System.out.println(in2);//1

        //静态方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3);

        //Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化异常
        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);

        //拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        int i = in1.intValue();
        System.out.println(i);
    }
}

5.3 自动装箱和自动拆箱

import java.util.ArrayList;

/*
    自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换
    JDK1.5之后出现的新特性
 */
public class Demo02Ineger {
    public static void main(String[] args) {
        /*
            自动装箱:直接把int类型的整数赋值包装类
            Integer in = 1; 就相当于 Integer in = new Integer(1);
         */
        Integer in = 1;

        /*
            自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,再进行计算
            in+2;就相当于 in.intVale() + 2 = 3
            in = in.intVale() + 2 = 3 又是一个自动装箱
         */
        in = in+2;

        ArrayList<Integer> list = new ArrayList<>();
        /*
            ArrayList集合无法直接存储整数,可以存储Integer包装类
         */
        list.add(1); //-->自动装箱 list.add(new Integer(1));

        int a = list.get(0); //-->自动拆箱  list.get(0).intValue();
    }
}

5.4 基本类型与字符串之间的转换

/*
    基本类型与字符串类型之间的相互转换
    一、基本类型->字符串(String)（三种方法）
        1.基本类型的值+""  最简单的方法(常用)
        2.包装类的静态方法toString(参数),不是Object类的toString() 重载
            static String toString(int i) 返回一个表示指定整数的 String 对象。
        3.String类的静态方法valueOf(参数)
            static String valueOf(int i) 返回 int 参数的字符串表示形式。
    二、字符串(String)->基本类型
　　　　包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：
        使用包装类的静态方法parseXXX("字符串");
            Integer类: static int parseInt(String s)
            Double类: static double parseDouble(String s)
 */
public class Demo03Integer {
    public static void main(String[] args) {
        //基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1+"";
        System.out.println(s1+200);//字符串和数字直接相加，是把数字当成了字符串，这是JAVA的装箱机制，最终相当于字符串的连接，

        String s2 = Integer.toString(100);
        System.out.println(s2+200);//

        String s3 = String.valueOf(100);
        System.out.println(s3+200);//100200

        //字符串(String)->基本类型
        int i = Integer.parseInt(s1); //s1应该是一个基本数据类型，而不能是字符串
        System.out.println(i-10);//90

        int a = Integer.parseInt("a");//NumberFormatException, 传入的应该是一个基本数据类型，而不能是字符串

  　　　　System.out.println(a); }

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出`java.lang.NumberFormatException`异常。