Java基础--常用类API

Objects类

重写toString方法

package tools.Object;
import java.util.Objects;

public class Person {
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 直接打印对象的地址值没有意义，重写Object类的toString()方法
    // 看一个类重写了toString方法没有，直接打印这个类的对象的名字即可
    @Override
    public String toString() {
        return "Person{" +"name='" + name + '\'' +", age=" + age +'}';
    }
}


package tools.Object;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

/*
    java.lang.Object类
    类Object是类层次结构的根类，每个类都使用Object作为父类
    所有对象(包括数组)都实现这个类的方法
 */
public class Demo01toString {
    public static void main(String[] args) {
        Person person = new Person("张三",18);
        System.out.println(person.toString());

        // 看一个类重写了toString方法没有，直接打印这个类的对象的名字即可
        System.out.println(person);
        Random r = new Random();
        System.out.println(r);  //没重写
        Scanner sc = new Scanner(System.in);
        System.out.println(sc); //重写过了
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        System.out.println(list);
    }
}

重写equals方法

package tools.Object;
import java.util.Objects;
public class Person {
    private String name;
    private int age;
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 默认比较两个对象的地址值，没有实际意义
     * 所以要重写equals方法，比较两个对象的属性值
     * 问题： 隐藏一个多态
     * 多态的弊端：无法使用子类特有的内容
     * Object obj =  p2 = new Person("古力娜扎",19);
     * 解决： 可以使用向下转型（强转）把obj类型转换为Person
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;     //向下强制转型
        return getAge() == person.getAge() &&
                Objects.equals(getName(), person.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getAge());
    }
}

package tools.Object;
public class Demo02equals {
    public static void main(String[] args) {

        Person p1 = new Person("迪丽热巴",18);
        Person p2 = new Person("迪丽热巴",18);
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p1.equals(p2));;
    }
}

日期时间类

Date类

package tools.Date;
import java.util.Date;
/**
 * java.util.Date:表示日期和时间的类
 * 毫秒：千分之一秒
 * 日期转换为毫秒：
 *      时间原点：0ms(1970年1月1日 00:00:00)
 *      一天： 24 * 60 * 60  = 86400秒 = 86400 * 1000 ms = 86400 000 ms
 *      注意：中国属于东八区， 时间原点：0ms(1970年1月1日 08:00:00)
 * 毫秒转换为日期：
 */
public class Demo01Date {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());     //获取当前系统时间
        demo01();
        demo02();
        demo03();
    }

    public static void demo03(){
        Date date = new Date();
        System.out.println(date.getTime());
    }
    public static  void demo02(){
        Date date = new Date(0L);
        System.out.println(date);
        Date date2 = new Date(1595339870947L);
        System.out.println(date2);
    }
    public static void demo01(){
        Date date = new Date();
        System.out.println(date);   // Tue Jul 21 21:56:20 CST 2020
    }
}

DateFormat类

package tools.Date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * java.text.DateFormat: 是日期/时间格式子类的抽象
 * java.text.SimpleDateFormat extends DateFormat
 */

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

    /**
     * 使用DateFormat类中的方法format,把日期格式转换为文本
     * 使用步骤：
     *  1.创建SimpleFormat对象，构造方法中指定传递的模式
     *  2.调用SimpleFormat对象中的方法，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串模式的字符串
     */
    private static void demo01(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = new Date();
        String d = sdf.format(date);
        System.out.println(date);
        System.out.println(d);
    }

    /**
     *  将文本解析为日期
     *  1.创建SimpleFormat对象，构造方法中指定传递的模式
     *  2.用SimpleFormat对象中的方法，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串模式的字符串
     */
    public static void demo02() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = sdf.parse("2020年07月22日 19时36分11秒"); //会抛出异常
        System.out.println(date);
    }
}

练习题

package tools.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
// 练习题：
/*
    1. Scanner类中的方法next获取出生日期
    2. 使用dataFormat类中的parse方法将出生日期解析为Date格式
    3. 将Date格式的出生日期转换为毫秒值
    4. 将当前日期转换为毫秒值
    5. 作差
    6.将毫秒值差值转换为天 s/1000/60/60/24
 */
public class DemoTest {
    public static void main(String[] args) throws ParseException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的出生日期：yyyy-MM-dd");
        String birthdayDateString = scanner.next();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd");
        Date birthdayDate = sdf.parse(birthdayDateString);
        long birthdayDateTime = birthdayDate.getTime();
        long todayTime = new Date().getTime();
        long time =  todayTime - birthdayDateTime;
        System.out.println(time/1000/60/60/24);
    }
}

Calendar类

package tools.Date;
import java.util.Calendar;
import java.util.Date;

/**
 * java.util.Calendar类：日历类
 * Calendar类是一个抽象类，里面提供了很多操作日历字段的方法（YEAR\MONTH\DAY_OF_MONTH\HOUR)
 * Calendar类无法直接创建对象使用、里面有一个静态方法getInstance()，该方法返回了Calendar类的子类对象
 */
public class Demo03Calaendar {
    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
        demo04();
        demo05();
    }
    public static void demo01(){
        System.out.println("demo01-----------------");
        Calendar c = Calendar.getInstance();
        System.out.println(c);
    }
    public static void demo02(){
        System.out.println("demo02-----------------");
        Calendar c = Calendar.getInstance();
        //get方法
        System.out.println(c.get(Calendar.YEAR) );  //年
        System.out.println(c.get(Calendar.MONTH)+1); //月：西方的月份0-11
        System.out.println(c.get(Calendar.DATE));  //日
    }
    public static void demo03(){
        System.out.println("demo03-----------------");
        Calendar c = Calendar.getInstance();
        //set方法
        c.set(Calendar.YEAR,2021);
        c.set(2021,2,30);
        System.out.println(c.get(Calendar.YEAR) );  //年
        System.out.println(c.get(Calendar.MONTH)+1); //月：西方的月份0-11
        System.out.println(c.get(Calendar.DATE));  //日
    }
    public static void demo04(){
        System.out.println("demo04-----------------");
        Calendar c = Calendar.getInstance();
        //add方法 add(int field, int amount)
        // field： 指定的日历字段
        // amount: 增加或减少指定的值
        System.out.println(c.get(Calendar.YEAR) );  //年
        c.add(Calendar.YEAR,2);
        System.out.println(c.get(Calendar.YEAR) );  //年
        System.out.println(c.get(Calendar.MONTH) );  //年
        c.add(Calendar.MONTH,-3);
        System.out.println(c.get(Calendar.MONTH) );  //年
    }
    public static void demo05(){
        System.out.println("demo05-----------------");
        // getTime方法  把日历对象转换为日期对象
        Calendar c = Calendar.getInstance();
        Date date = c.getTime();
        System.out.println(date);
    }
}

System类

package tools.System;
import java.util.Arrays;

public class DemoSystem {
    public static void main(String[] args) {
        //demo01();
        demo02();
    }
    public static void demo01(){
        //currentTimeMillis()方法
       long start = System.currentTimeMillis();
        for (int i = 0; i <9999 ; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("程序共耗时："+ (end-start) +"毫秒。");
    }
    public static void demo02(){
        // arraycopy()方法
        /**
         * public static void arraycopy(Object src, int srcPos,Object dest,int destPos,int length)
         *  src - 源数组。
         *  srcPos - 源数组中的起始位置。
         *  dest - 目标数组。
         *  destPos - 目的地数据中的起始位置。
         *  length - 要复制的数组元素的数量。
        */
        int[] src = {1,2,3,4,5};
        int[] dest= {6,7,8,9,10};
        System.arraycopy(src,0,dest,0,3);
        System.out.println(Arrays.toString(dest));
    }
}

StringBuilder类

package tools.StringBuilder;

public class DemoStringBuilder {
    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
    }
    public static void demo01(){
        // 构造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:" + bu1);  //空字符
        StringBuilder bu2 = new StringBuilder("abcde");
        System.out.println("bu2:" + bu2);
    }
    public static void demo02(){
        // append()方法  添加任意数据类型的数据
        // append()方法返回的是this,调用方法的对象此处this=bua
        StringBuilder bua = new StringBuilder();
        System.out.println("bua:" + bua);
        bua.append(1);
        bua.append("abc");
        bua.append(false);
        bua.append(bua);
        System.out.println("bua:" + bua);

        bua.append("1").append(2).append("中");// 链式编程
        System.out.println("bua:" + bua);
    }
    public static void demo03(){
        // toString()方法： StringBuilder和String相互转换
        //      String-->StringBuilder  StringBuilder的构造方法
        //      StringBuilder-->String  StringBuilder的toString方法
        String str = "hello";
        StringBuilder bu  = new StringBuilder(str);
        System.out.println("bu:" + bu );
        bu.append("world");
        str = bu.toString();
        System.out.println("str:" +str );
    }
}

包装类

概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

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

用Integer与 int为例：（看懂代码即可）
基本数值---->包装对象
Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
包装对象---->基本数值
int num = i.intValue();

自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

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

基本类型转换为String

基本类型转换String总共有三种方式，查看课后资料可以得知，这里只讲最简单的一种方式：
基本类型直接与””相连接即可；如：34+""
String转换成对应的基本类型
除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

• public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
  
• public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
  
• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
  
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
  
• public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
  
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
  
• public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。
  

代码使用（仅以Integer类的静态方法parseXxx为例）如：
public class Demo18WrapperParse {
   public static void main(String[] args) {
       int num = Integer.parseInt("100");
   }
}

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

package tools.包装类;
import java.util.ArrayList;

/*
    装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        构造方法:
            Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
            Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
                传递的字符串,必须是基本类型的字符串,否则会抛出异常 "100" 正确  "a" 抛异常
        静态方法:
            static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
            static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
    拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        成员方法:
            int intValue() 以 int 类型返回该 Integer 的值。
 */
public class Demo01Integer {
    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
    }
    public static void demo01(){
        // 装箱
        Integer in1 = new Integer(1);
        System.out.println(in1);
        Integer in2 = new Integer("1");
        System.out.println(in2);
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3);
        Integer in4 = Integer.valueOf("1");  // 不能是"a"，必须是基本数据类型
        System.out.println(in4);
        // 拆箱
        int i = in1.intValue();
        System.out.println(i);
    }

    /*
    自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换
    JDK1.5之后出现的新特性
    */
    public static void demo02(){
       /*自动装箱:直接把int类型的整数赋值包装类  Integer in = 1; 就相当于 Integer in = new Integer(1);*/
        Integer in  = 1;
        System.out.println(in);
        /*
            自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算
            in+2;就相当于 in.intVale() + 2 = 3
            in = in.intVale() + 2 = 3 又是一个自动装箱
         */
        in = in + 2;
        System.out.println(in);

        /* ArrayList集合无法直接存储整数,可以存储Integer包装类*/
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1); //-->自动装箱 list.add(new Integer(1));
        int a = list.get(0); //-->自动拆箱  list.get(0).intValue();
    }
     /*
        基本类型与字符串类型之间的相互转换
        基本类型->字符串(String)
        1.基本类型的值+""  最简单的方法(工作中常用)
        2.包装类的静态方法toString(参数),不是Object类的toString() 重载
            static String toString(int i) 返回一个表示指定整数的 String 对象。
        3.String类的静态方法valueOf(参数)
            static String valueOf(int i) 返回 int 参数的字符串表示形式。
        字符串(String)->基本类型
        使用包装类的静态方法parseXXX("字符串");
            Integer类: static int parseInt(String s)
            Double类: static double parseDouble(String s)
     */
    public static void demo03(){
        //基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1+"";
        System.out.println(s1+200);//100200

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

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

        //字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i-10);

        int a = Integer.parseInt("a");//NumberFormatException
        System.out.println(a);
    }
}