一 . 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; } }