Object类 日期时间类 System类 StringBuilder类 包装类 学习笔记

一 . Object和Objects类

1.1 Object类

---

 1.1.1 概述:

Object类式java语言中的根类,简单说的就是所有类的父类,它中描述的所有方法子类都可以使用.

如果一个类没有特别指定继承其他类,那么默认继承自Object类.例如:

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

根据JDK源代码及Object类API文档, Object类当中包含的方法有11个,今天讲2个.

• public String toString() : 返回该对象的字符串表示
• pubilc boolean equals(Object  obj) : 指其他某个对象是否与此对象"相等".

 

1.1.2 toString方法

• public String toString() : 返回该对象的字符串表示           (默认返回的是地址值)

toString方法返回该对象的字符串表示,该字符串内容就是类型+@+内存地址.

由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表示形式,所以我们一般重写此方法.

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //省略构造方法与Getter Setter
}

在InterlliJ IDEA中,可以使用ALT+Insert,选择toString生成.

代码演示:

public class ToStringDemo {
    public static void main(String[] args) {
        //创建Person对象
        Person p = new Person("红红不知所措",23);
        //输出p
        System.out.println(p);
        System.out.println(p.toString());
    }
}

输出结果:

1.1.3 equals方法

• pubilc boolean equals(Object  obj) : 指其他某个对象是否与此对象"相等".         

调用成员方法equals 并指定参数的另一个对象,则可以判断这两个对象是否与此对象相同.这里的"相同"有默认和自定义两种.

• 默认比较地址:如果没有重写equals方法,那"=="比较的就是地址是否相同
• 自定义比较内容:重写了equals方法,"=="比较其内容.

代码演示:

public class EqualsDemo {
    public static void main(String[] args){
        // 创建Person对象
        Person p1 = new Person("黄黄",18);
        Person p2 = new Person("黄黄",18);
        Person p3 = new Person("黄黄",19);
        // 比较是否相等
        System.out.println(p1.equals(p2));
        System.out.println(p1.equals(p3));
    }
}

没有重写equals方法的结果:

false

false

重写equals方法的结果:

true

false

1.2 Objects

---

1.2.1 概述

在JDK7添加了一个Objects工具类,它提供了一些方法来操作对象,它由静态方法组成.

1.2.2 常用方法

 

• public static boolean equals(Object a,Object  b) :判断两个对象是否相等.
• public static <T> T requireNonNull(T obj): 检查指定对象obj不为空,如果为null,则抛出异常,否则返回本身.
• public sratic boolean nonNull(Object obj): 判断指定对象是否为null , 不为空返回true , 反之亦然.
• public sratic boolean isNull(object obj) :判断指定对象obj是否为null, 为null返回true, 反之亦然.

代码演示:

 public class ObjectsDemo {
    public static void main(String[] args) {
       // 创建两个学生对象
        Student s1 = new Student("小白");
        Student s2 = new Student("小白");
        System.out.println(s1);
        System.out.println(s2);
        // 判断两个对象是否相等
        System.out.println(Objects.equals(s1,s2));
        // requireNonNull方法
        System.out.println(Objects.requireNonNull(s1));
        s1 = null;
        // nonNull方法
        System.out.println(Objects.nonNull(s1));
        // isNull方法
        s2 = null;
        System.out.println(Objects.isNull(s2));
    }
}
class Student {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }
}

二. 日期时间类

2.1 Date类

---

2.1.1 概述

Date是时间日期类 , 用来获得时间和日期信息。不支持国际化.

查阅API可以发现他部分方法已经过时,但是还有些未过时的.

• public Date() 分配Date对象并初始化此对象,获得当前时间
• public Date(long date) :分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元
  （epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

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
    }
}

2.1.2 常用方法

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

public class DateDemo01 {
    public static void main(String[] args){
        // 创建日期对象
        Date d = new Date();
        // Sun Jul 29 09:58:10 CST 2018 ==> China Standard Time
        // 2018‐07‐29 09:58:10
        // 2018/07/29 09:58:10
        System.out.println(d);
        // 获得当前时间的毫秒值：1532829685562
        System.out.println(d.getTime());
        // 根据毫秒值创建日期对象
        Date d2 = new Date(1000L);
        // Thu Jan 01 08:00:01 CST 1970
        System.out.println(d2);
    }
}

2. 2  DateFormant类

2.2.1 概述

DateFormat 是一个日期格式化类,抽象类，不能直接创建该类的对象，只能创建子类对象。

作用:完成日期和文本之间的转换,也就是Date对象与String对象之间的来回转换.

• 格式化 : 将日期对象转换为字符串
• 解析 : 将日期字符串转换为日期对象

2.2.2 构造方法

• public SimpleDateFormat(String pattern) : 指定日期模式创建日期格式化对象.
• public SimpleDateFormat() : 创建日期格式化对象，使用默认的日期模式.

参数pattern是一个字符串，代表日期时间的自定义格式。

 2.2.3 格式规则

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

2.2.4 常用方法

• public String format(Date date) : 将日期对象格式化为字符串： Date ==> String
• public Date parse(String source) : 将字符串转换为日期对象： String ==> Date
• public void appyPattern(String pattern) : 修改日期模式

代码演示一:

public class DateFormatDemo01 {
    public static void main(String[] args){
        // 创建日期对象
        Date d = new Date();
        // 创建日期格式化对象:使用默认的日期模式
        // 2018‐07‐29 09:58:10
        SimpleDateFormat sdf = new SimpleDateFormat();
        // 修改日期模式
        sdf.applyPattern("yyyy/MM/dd HH:mm:ss");
        // 创建日期格式化对象:指定日期模式
        // SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        // 将日期对象格式化为字符串
        String dStr = sdf.format(d);
        // 2018/7/29 上午10:16
        // 2018‐07‐29 09:58:10
        // 2018/07/29 09:58:10
        System.out.println(dStr);
    }
}

代码演示二:

/**
    字符串转换日期对象的步骤
        * 创建日期格式化对象并指定日期模式
            * SimpleDateFormat sdf = new SimpleDateFormat("yyyy‐MM‐dd HH:mm:ss");
        * 调用日期格式化对象的parse方法将字符串转换为日期对象
            * Date d = sdf.parse(str);
 */
public class DateFormatDemo02 {
    public static void main(String[] args) throws ParseException {
        // 日期字符串
        String str = "2018‐07‐29 10:26:23";
        // 创建日期格式化对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy‐MM‐dd HH:mm:ss");
        // 将字符串转换为日期对象
        Date d = sdf.parse(str);
        System.out.println(d);
    }
}

2.3 Calendar 类

2.3.1 概念

是一个日历类，通过日历类可以获得日期和时间信息, 也是一个抽象类，不能直接创建该类的对象，只能使用子类。

 支持国际化.

2.3.2 获取方式

• public static Calendar getInstance() :通过调用Calendar类的静态方法获得日历对象

代码演示:

import java.util.Calendar;
public class Demo06CalendarInit {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
    }   
}

2.3.3 常用方法

• public abstract void add(int field, int value) 将指定日历字段的值在当前基础上偏移一个值value

        * value：正数，向后偏移
        * value：负数，向前偏移

• public void set(int field, int value) : 修改指定日历字段的值为value.
• public void set(int year,int month,int date)  :修改年月日.
• public int get(int field)  :根据日历字段获得对应的值。 常见的日历字段：年月日时分秒.
• public long getTimeInMillis()  :获得当前时间的毫秒值.
• public Date getTime() :获得日期对象.

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

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

代码演示:

public class CalendarDemo01 {
    public static void main(String[] args){
        // 获得日历对象
        Calendar c = Calendar.getInstance(); // new GregorianCalendar();
        // 获得日期对象
        Date date = c.getTime();
        // 获得当前毫秒值：1532834069126
        System.out.println(date.getTime());
        // 修改年月日
        c.set(2018, 10, 18);
       /* // 修改年份
        c.set(Calendar.YEAR, 2000);
        // 修改月份
        c.set(Calendar.MONTH, 12);
        // 修改日
        c.set(Calendar.DATE, 32);*/
       // 将指定日历字段的值在当前基础上偏移一个值value
       c.add(Calendar.YEAR, ‐1);
        // 获得年
        int year = c.get(Calendar.YEAR);
        // 获得月
        int month = c.get(Calendar.MONTH) + 1;
        // 获得日
        int day = c.get(Calendar.DATE);
        // 获得时分秒
        int hour = c.get(Calendar.HOUR);
        int minute = c.get(Calendar.MINUTE);
        int second = c.get(Calendar.SECOND);
        System.out.println(year);
        System.out.println(month);
        System.out.println(day);
        System.out.println(hour);
        System.out.println(minute);
        System.out.println(second);
    }
}

三. System类

3.1 概述

类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文
档中，常用的方法有：

• public static long currentTimeMillis()  :获得当前时间的毫秒值的.
• public static void gc() :通知垃圾回收器回收垃圾对象。(对象没有任何引用变量指向时就会变成垃圾对象).
• public static void exit(int status) : 退出JVM，终止程序运行 (0：正常退出) (‐1：异常退出).
• public static Properties getProperties()  : 获得操作系统的属性信息，比如操作系统名称.
• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) : 数组复制

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

代码演示:

public class SystemDemo01 {
    public static void main(String[] args){
        // 获得当前时间的毫秒值的
        // test01();
        // 通知垃圾回收器回收垃圾对象。
        // test02();
        // 退出JVM，终止程序运行
        // test03();
        // 获得操作系统的属性信息，比如操作系统名称
        // test04();
        // 数组拷贝
        test05();
    }
    /*
        public static long currentTimeMillis()
        * 获得当前时间的毫秒值的                  */
    private static void test01() {
        long start = System.currentTimeMillis();
        for (int i = 0; i <100000 ; i++) {
            System.out.println("i = "+ i);
        }
        System.out.println(System.currentTimeMillis() ‐ start)
    }

    /*
     public static void gc() ==> garbage collect 垃圾回收器
        * 通知垃圾回收器回收垃圾对象。
        * 对象没有任何引用变量指向时就会变成垃圾对象。
     */
    private static void test02() {
        for (int i = 0; i <10 ; i++) {
            // 创建学生对象
            new Student();
            // 通知垃圾回收器回收垃圾对象。
            System.gc();
        }
    }
    /*
        public static void exit(int status)
            * 退出JVM，终止程序运行
     */
    private static void test03() {
        for (int i = 0; i <10 ; i++) {
            System.out.println(i);
            if (i == 5){
                // 退出JVM，终止程序运行
                System.exit(0);
            }
        }
    }
    /*
        public static Properties getProperties()
            * 获得操作系统的属性信息，比如操作系统名称
     */
    private static void test04() {
        Properties info = System.getProperties();
        // 获得操作系统的名字
        System.out.println(info.getProperty("os.name"));
        // 搜狗输入法网站  http:///www.sougou/com
        // windows
        // mac
    }
        /*
    public static void arraycopy(Object src, int srcPos,
        Object dest, int destPos, int length)
        * 数组复制
        * src：源数组
        * srcPos：源数组的起始索引
        * dest：目标数组
        * destPos：目标数组的起始索引
        * length：要拷贝的元素个数
     */
    private static void test05() {
        // 定义一个整型数组：源数组
        int[] src = {1,2,3,4,5,6,7};
        // 定义一个整型数组：目标数组
        int[] dest = new int[7];
        // 数组拷贝
        System.arraycopy(src, 1, dest, 2, 5);
        System.out.println(Arrays.toString(dest)); //结果[0, 0, 2, 3, 4, 5, 6]
    
}

四. StringBuilder类

4.1 字符串拼接问题

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

由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。

为了解决这问题可以使用 java.lang.StringBuilder类.

4.2 StringBuilder概述

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

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动
维护数组的扩容。(默认16字符空间，超过自动扩充)

4.3 构造方法

• public StringBuilder() :创建可变字符串，默认数组长度是16
• public StringBuilder(String str) :将不可变字符串转换为可变字符串，默认数组长度是16

代码演示:

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
    }
}

4.4 常用方法

• StringBuilder append(数据类型 变量名) :拼接内容 .
• String toString() :将可变字符串转换为不可变字符串 .

代码演示:

public class StringBuilderDemo01 {
    public static void main(String[] args){
        // 创建可变的字符串:创建长度为16的数组
        StringBuilder sb = new StringBuilder("xxx");
        // 拼接内容
        sb.append("hello").append("world");
        // 链式编程:当方法返回值是一个对象时可以继续调用对象的方法。
        sb.append("111").append(11).append(101.5);
        System.out.println(sb);
        /*String str = "";
        str += "hello";
        str += "world";
        System.out.println(str);*/
    }
    public static String xxx(){
        // 创建可变的字符串:创建长度为16的数组
        StringBuilder sb = new StringBuilder("xxx");
        // 拼接内容
        sb.append("hello").append("world");
        return sb.toString();
    }
}

五. 包装类

5.1 概述

• 包装类是一个可以将基本数据类型封装成对象的类则称为包装类。

• 八种基本数据类对应的包装类如下表

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

为什么需要包装类

• java语言是一个面向对象的语言，但不是纯面向对象的，因为Java中的基本数据类型是不属于对象，而在实际使用中经常需要将基本数据类型转化成对象，比如：集合的操作，如下代码所示:

// 创建集合存储整型数据
ArrayList<Integer> list = new ArrayList<>(); // 正确
ArrayList<int> list = new ArrayList<>(); // 错误，集合只能存储对象，不能存储基本数据类型

5.2 Integer包装概述

• 构造方法

Integer(int value);将一个整数value转换成整型包装类对象。

Integer(String s);将一个字符串数值转换成整型包装类对象。

• 成员方法

int intValue()；将包装类对象转换为基本数据类型整型。

static Integer valueOf(int num)；将基本数据整型转换为包装类对象

static int parseInt(String str)；把字符串转换为int值。

static String toString(int i)；将整数i转换成字符串

• 静态成员变量

Integer.MAX_VALUE：整数最大值

Integer.MIN_VALUE：整数最小值

public class IntegerDemo {
public static void main(String[] args) {    
// 创建整型包装类对象        
Integer in = new Integer("100");        
// 获得基本数据类型        
int price = in.intValue();        
System.out.println(price);        
       
// 直接将字符串数字转换整数        
System.out.println(Integer.parseInt("200"));        
System.out.println(Integer.toString(100)+1);         
System.out.println(100+"");        
       
Double dd = new Double("0.9");        
dd.doubleValue();        
       
double d = Double.parseDouble("0.9");        
System.out.println(d+1);        
       
String f = "true";        
boolean ff = Boolean.parseBoolean(f);        
if(ff) {        
System.out.println("条件成立");            
}        
System.out.println(Long.MAX_VALUE);        
System.out.println(Long.MIN_VALUE);          
}    
}

5.3 自动装箱与自动拆箱

5.3.1  自动装箱和自动拆箱概述

• 自动装箱: Java编译器自动将基本数据类型转换为对应的包装类类型的过程。
• 自动拆箱: Java编译器自动将包装类类型转换为对应基本数据类型的过程。
• 是JDK1.5的新特性。

代码演示:

public class Demo01 {
    public static void main(String[] args){
        // 创建集合对象
        ArrayList<Integer> list = new ArrayList<>();
        // 在JDK1.5之前添加元素
        list.add(Integer.valueOf(1));
        list.add(Integer.valueOf(2));
        // 在JDK1.5之后添加元素
        list.add(3); // list.add(Integer.valueOf(3))  自动装箱。
        list.add(4); // list.add(Integer.valueOf(4))  自动装箱。
        // 获得集合的元素
        int num = list.get(0); // 自动拆箱：list.get(0).intValue();
        int a = 100;
        Integer b = a;   // 自动装箱  Integer b = Integer.valueOf(a);
        Integer c= a + b; // 先将b拆箱，然后再执行加法运算，最后将结果装箱后赋值给c
        // Integer.valueOf(a + b.intValue());
        double d = 10.5;
        double dd = d;
    }
}