Java基础（09）— 常用类

常用类

Object类

• java.lang.Object 是Java语言的根类，即所有类的父类

• Object类中包含11个方法如下

  

equals

• public boolean equals(Object obj)，判断两个对象是否"相同"，"相同"有静默和自定义两种方式。

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

  • 对象内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，可以覆盖重写equals方法进行

    import java.util.Objects;
    public class Person {
        private String name; 
        private int age; 
        @Override 
        public boolean equals(Object o) { 
            // 如果对象地址一样，则认为相同 
            if (this == o) return true; 
            // 如果参数为空，或者类型信息不一样，则认为不同 
            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); 
        } 
    }
    

toString

• public String toString()，返回该对象的字符串，也就是该对象的内存地址

  • 快捷键 Alt + insert ，选toString。

  • 在使用输出语句输出对象名时，其实通过该对象调用了toString()

    public class Person {
        private String name;
        private int age;
        /*
        开发中经常需要按照对象的属性得到相应的字符串表现形式，因此需要重写toString()
        */
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

Objects

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

  • public static boolean equals(Object a，Object b)，判断两个对象是否相等

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

日期时间类

Date

• java.util.Date，标识特定的瞬间，精确到毫秒。

• 常用的方法

  • public Date()，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）

  • public Date(long date)，分配Date对象并初始化对象，以表示自从标准基准时间（称为"万年历"epoch，即1970年1月1日00:00:00）以来的指定毫秒数

    /*
    ※ 由于我们处于东八区，所以我们的基准时间为1970年1月一日08:00:00
    简单来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自
    定义毫秒时刻。例如：
    */
    import java.util.Date; 
    public class Demo01Date { 
        public static void main(String[] args) { 
        // 创建日期对象，把当前的时间 
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018  
        // 创建日期对象，把当前的毫秒值转成日期对象 
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970 
    	} 
    }
    /*
    tips:在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串
    */
    

  • public long getTime()，把日期对象转换成对应的时间毫秒值

DateFormat

• java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日企和文本之间的转换，也就是可以早Date对象与String对象之间进行来回转换

  • public String format(Date date)，按照指定的格式，从Date对象转换为String对象
  • public Date parse(String source) ，按照指定的格式，从String对象转换为Date对象

• 构造方法

  • 由于DateFormat为抽象类，不能直接使用，所以需要常 用的子类 java.text.SimpleDateFormat。这个类需要一个模式（格式） 来指定格式化或解析的标准

  • public SimpleDateFormat(String pattern) ，用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，代表日期时间的自定义格式。

    标识字母（区分大小写）	含义
    y	年
    M	月
    d	日
    H	时
    m	分
    s	秒

    import java.text.DateFormat; 
    import java.text.SimpleDateFormat; 
    public class SimpleDateFormat { 
        public static void main(String[] args) {
            //获取当前日期
            Date date = new Date();
            //指定格式
            DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
            //按照指定的格式，从Date对象转换为String对象
            String str = df.format(date);
            System.out.println(str);//2020年08月01日
            //按照指定的格式，从String对象转换为Date对象
    		Date parse = null;
            try {
                parse = df.parse(str);
            } catch (ParseException e) { //ParseException 解析异常可抛可try
                e.printStackTrace();
            }
            System.out.println(parse);
            
        }
    }
    

练习

• 请使用日期时间相关的API，计算出一个人已经出生了多少天。

  • 获取当前时间对应的毫秒值

  • 获取自己出生日期对应的毫秒值

  • 两个时间相减（当前时间– 出生日期）

    public static void main(String[] args) throws ParseException {
        daysOfBirth();
    }
    public static void daysOfBirth() throws ParseException {
        System.out.println("请输入出生日期，格式 YYYY-MM-DD");
        Scanner scanner = new Scanner(System.in);
        String birthdayString = scanner.next();
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = format.parse(birthdayString);
        Date todayDate = new Date();
        long birthdaySecond = birthdayDate.getTime();
        long todaySecond = todayDate.getTime();
        long second = todaySecond - birthdaySecond;
        if(second < 0){
            System.out.println("还未出生？？输入错了！");
        }else{
            System.out.println(second/1000/60/60/24);
        }
    }
    

Calendar

• java.util.Calendar 是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。 日历类就是方便获取各个时间属性的

• 获取方式

  • Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象

    import java.util.Calendar; 
    public class CalendarInit { 
        public static void main(String[] args) { 
            //public static Calendar getInstance() ：使用默认时区和语言环境获得一个日历
            Calendar cal = Calendar.getInstance(); 
        } 
    }
    

• Calendar类中提供很多成员常量即方法

  • 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对象。

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

• get/set方法

  • get方法用来获取指定字段的值，set方法用来设置指定字段的值

    import java.util.Calendar; 
    public class GetCalendar { 
        public static void main(String[] args) { 
            // 创建Calendar对象 
            Calendar cal = Calendar.getInstance(); 
            // 设置年 
            int year = cal.get(Calendar.YEAR); 
            // 设置月 
            int month = cal.get(Calendar.MONTH) + 1; 
            // 设置日 
            int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH); 
            System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); 
        } 
    }
    

    import java.util.Calendar; 
    public class SetCalendar {
        public static void main(String[] args) {
            Calendar cal = Calendar.getInstance(); 
            // 2020 年1月17日 
            cal.set(Calendar.YEAR, 2020); System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); 
        } 
    }
    

• add方法

  • add方法可以对指定日历字段的值进行加减操作，如果第二个参数为正数则加上偏移量，如果为负数则减去偏移量

    import java.util.Calendar; 
    public class AddCalendar { 
        public static void main(String[] args) { 
            Calendar cal = Calendar.getInstance(); 
            System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018 年1月17日
            // 使用add方法 
            cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天 
            cal.add(Calendar.YEAR, -3); // 减3年 
            System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015 年1月18日;
        } 
    }
    

• getTime方法

  • Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象

    import java.util.Calendar; 
    import java.util.Date; 
    public class CalendarGetTime { 
        public static void main(String[] args) { 
            Calendar cal = Calendar.getInstance(); 
            Date date = cal.getTime(); 
            System.out.println(date); // Tue Jan 16 16:03:09 CST 2018 
        } 
    }
    

---

• 小贴士
  • 西方星期的开始为周日，中国为周一。
  • 在Calendar类中，月份的表示是以0-11代表1-12月。
  • 日期是有大小关系的，时间靠后，时间越大。

---

System类

• java.lang.System，提供了大量的静态方法，可以获取与系统相关的信息或系统级操作

• 常用方法

  • public static long currentTimeMillis() ，返回以毫秒为单位的当前时间

    import java.util.Date; 
    public class SystemDemo { 
        public static void main(String[] args) { 
            //currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值
            System.out.println(System.currentTimeMillis()); // 1596435421468 
        } 
    }
    

    //练习：验证for循环打印数字1-9999所需要使用的时间（毫秒）
    public class SystemTest{ 
        public static void main(String[] args) { 
            long start = System.currentTimeMillis();
            for (int i = 0; i < 10000; i++) { 
                System.out.println(i);
            }
            long end = System.currentTimeMillis(); 
            System.out.println("共耗时毫秒：" + (end - start)); 
        } 
    }
    

  • public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ，将数组中指定的数据拷贝到另一个数组中

  • 数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数

    参数序号	参数名称	参数类型	参数含义
    1	src	Object	源数组
    2	srcPos	int	源数组索引起始位置
    3	dest	Object	目标数组
    4	destPos	int	目标数组索引起始位置
    5	length	int	复制元素个数

    /*
    练习：
        将src数组中前3个元素，复制到dest数组的前3个位置上复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]
    */
    import java.util.Arrays; 
    public class SystemArrayCopy {
        public static void main(String[] args) {
            int[] src = new int[]{1,2,3,4,5}; 
            int[] dest = new int[]{6,7,8,9,10}; 
            System.arraycopy( src, 0, dest, 0, 3); 
        } 
    }
    
    

StringBuilder类

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

  • 下面打印结果为helloworld，会误以为字符串长度改变了

  • 实际上时这段代码产生了三个字符串，即"hello","world","helloworld"

  • 由此可知，每次拼接就构建新的String对象，耗时浪费空间。因此 StringBuilder 出现了

    public static void main(String[] args) {
        String str = "hello";
        str += "world";
        System.out.println(str);
    }
    

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

• 内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容，StringBuilder会自动维护数组的扩容

• 构造方法

  • public StringBuilder() ，构造一个空的StringBuilder容器

  • public StringBuilder(String str) ，构造一个StringBuilder容器，并将字符串添加进去

    public class StringBuilderDemo { 
        public static void main(String[] args) { 
            StringBuilder sb1 = new StringBuilder(); 
            System.out.println(sb1); // (空白) 
            // 使用带参构造 
            StringBuilder sb2 = new StringBuilder("itcast"); 
            System.out.println(sb2); // itcast 
        } 
    }
    

• 常用方法

  • public StringBuilder append(...) ，添加任意类型数据的字符串形式，并返回当前对象自身

  • public String toString() ，将当前StringBuilder对象转换为String对象

    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 static void main(String[] args) { 
        // 链式创建 
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 调用方法 
        String str = sb.toString(); 
        System.out.println(str); // HelloWorldJava 
    }
    

• StrintgBuilder与StringBuffer的区别

  • String字符串常量，StrintgBuilder/StringBuffer 都是字符串变量

    StringBuilder	StringBuffer
    线程不安全，性能相对优越	线程安全，性能相对低下
    获取toString直接通过复制字符数组来构造字符串	每次获取toString都会使用缓冲区的toStringCache来构造字符串

    //StringBuilder
    @Override
    public String toString(){
        return new String(value,0,count);
    }
    
    //StringBuffer
    @Override
    public synchronized String toString(){
        if(toStringCache == null){
            toStringCache = Arrays.copyOfRange(value,0,count);
        }
    }
    

包装类

• Java提供了两个类型系统，基本类型与引用类型。

  • 使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能

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

    基本类型	包装类（ java.lang.*）
    byte	Byte
    short	Short
    int	Integer
    long	Long
    float	Float
    double	Double
    char	Character
    boolean	Boolean

• 拆箱与装箱

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

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

    //装箱
    Integer i = new Integer(4); //使用构造函数
    Integer it = Integer.valueOf(4); //使用包装类中的valueOf方法
    //拆箱
    int num = i.intValue();
    

  • 从JDK1.5 开始，基本类型与包装类的装箱、拆箱动作可以自动完成

    Integer i = 4; //自动装箱。相当于Integer i = Integer.valueOf(4);
    i = i + 5; //等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5; 
    //加法运算完成后，再次装箱，把基本数值转成对象。
    

  • 基本类型与String之间转换最简单的方式

    //--->String
    int num = 20;
    String age = num+"岁";
    

    /*
    public static byte parseByte(String s);
    public static short parseShort(String s);
    public static int parseInt(String s);
    public static long parseLong(String s);
    public static float parseFloat(String s);
    public static double parseDouble(String s);
    public static boolean parseBoolean(String s);
    */
    //--->基本类型
    int num = Integer.parseInt("100");