1.Object类
java.lang.object类是java语言中的根类,即所有类的父类,object中描述的所有方法子类都可以使用,在对象实例化的时候,最终找的父类就是object。
如果一个类没有特别指定其父类,那么默认继承自Object类。例如:
public class MyClass /* extends Object*/{
//......
}
1.1 toString 方法
public String toString():返回该对象的字符串表示。
toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型+@+内存地址值。由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它 。如果不希望使用toString方法的默认行为,则可以对它进行覆盖重写。例如:
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法(当输出一个对象名输出的是内容的时候,那么一定是重写了toString方法)
1.2 equals 方法
public boolean equals(Object obj):指示其他某个对象是否与此对象"相等"(Object类的equals方法默认比较的是两个对象的地址值,若想比较两个对象的属性则必须对equals方法进行覆盖重写)举例如下:
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);
}
}
2.日期时间类
2.1 Date类
java.util.Date类:表示特定的瞬间,精确到毫秒
- public Date() :分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒)(此Date对线表示当前时间)
- public Date(long date):分配Date对象并初始化此对象,(此对象表示的是指定的时间)以表示自从标准基准时间(称为“历元(epoch)”,即1970年1月1日00:00:00 GMT)以来的指定毫秒数。(由于我们处于东八区,所以我们的基准时间为1970年1月1日8时0分0秒。 )
- 一般来说,使用无参构造,可以自动设置当前系统时间的毫秒时刻;指定long类型的构造参数,可以自定义毫秒时刻。
public class Demo01 {
public static void main(String[] args) {
// 输出当前时间
System.out.println(new Date());//Sat Aug 11 15:26:27 CST 2018
//将当前的毫秒值转化为日期对象
System.out.println(new Date(0L));//Thu Jan 01 08:00:00 CST 1970
}
}
在使用println方法时,会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写,所以结果为指定格式的字符串。
常用方法:public long getTime():把日期对象转换成对应的时间毫秒值;
public static void main(String[] args){
System.out.println(new Date().getTime());//1533972591632
}
2.2 DateFormat类
java.text.DateFormat是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以再Date对象和String对象之间进行来回转换
- 格式化:按照指定的格式,从Date对象转换为String对象
- 解析:按照指定的格式,从String对象转换为Date对象
由于DateFormat为抽象类,不能直接使用,所以需要常用的子类 java.text.SimleDateFormat。这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为:
- public SimpleDateFormat(String pattern):用给定的模式和默认语言环境的日期格式符号来构造SimpleDateFormat (其中pattern是一个字符串,代表时间的自定义格式)
格式规则(常用的格式规则为ges)
标识字母(必须区分大小写) | 含义 |
yyyy | 年 |
MM | 月 |
dd | 日 |
HH | 时 |
mm | 分 |
ss | 秒 |
创建SimpleDateFormat对象的代码如下:
public static void main(String[] args) {
//对应的日期格式为:2018-08-08 14:14:14
DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//对应的日期格式为:2018年08月08日 14时14分14秒
DateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
}
常用方法:
- public String format(Date date):将Date对象格式化为字符串
- public Date parse(String source):将字符串解析为Date对象。
foarmat方法:
public static void main(String[] args) {
// 创建日期格式化对象,在获取格式化对象时可以指定其格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String format = sdf.format(new Date());
System.out.println(format);//2018-08-11 15:50:53
}
parse方法:
public static void main(String[] args) throws ParseException {
String str = "2018-08-11 15:50:53";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date parse = sdf.parse(str);
System.out.println(parse);//Sat Aug 11 15:50:53 CST 2018
}
练习:
//计算一个人出生了多少天,还能活多少天
public class Demo02Test01 {
public static void main(String[] args) throws ParseException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的出生日期;yyyy-MM-dd ");
String birthdayDateString = sc.next();
System.out.println("请输入您的最终日期;yyyy-MM-dd ");
String endDateTime = sc.next();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date birthdayDate = sdf.parse(birthdayDateString);
Date endDate = sdf.parse(endDateTime);
long birthdayDateTime = birthdayDate.getTime();
long endDateTime1 = endDate.getTime();
long nowTime = new Date().getTime();
long time1 = nowTime - birthdayDateTime;
long time2 = endDateTime1 - nowTime;
System.out.println("您已经活了" + (time1 / 1000 / 60 / 60 / 24) + "天");
System.out.println("您还能活" + (time2 / 1000 / 60 / 60 / 24) + "天");
}
}
2.3Calendar类
java.uitl.Calendar是日历类,在Date之后出现,替换掉了Date的许多方法。该类将所有可能用到的时间信息封装为静态成员变量,方便获取。日历类就是方便获取各个时间属性的。
获取方式:Calendar为抽象类,由于语言敏感性,Calendar类在创建对象时并非直接创建,而是通过静态方法创建,返回子类对象,如下:
Calendar 静态方法
- public static Calendar gerInstance():使用默认时区和语言环境获得一个日历
public class Demo01 {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
}
}
常用方法:
- public int get(int field):返回给定日历字段的值。
- public coid set(int field,int vaule):将给定的日历字段设置为给定值
- public abstaract void add(int field ,int amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量。
- public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象
Calendar类中提供很多成员常量,代表给定的日历字段:
字段值 | 含义 |
---|---|
YEAR | 年 |
MONTH | 月(从0开始,可以+1使用) |
DAY_OF_MONTH | 月中的天(几号) |
HOUR | 时(12小时制) |
HOUR_OF_DAY | 时(24小时制) |
MINUTE | 分 |
SECOND | 秒 |
DAY_OF_WEEK | 周中的天(周几,周日为1,可以-1使用) |
常用方法演示代码如下:
//get/set方法
//若不用set方法,控制台输出为当前日期
public class Demo01 {
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 + "日");//2018年8月8日
}
}
//使用set方法,可以随意设置日期
public class Demo01 {
public static void main(String[] args) {
// 创建Calendar对象
Calendar cal = Calendar.getInstance();
// 设置年
cal.set(Calendar.YEAR,2020);//改变当前年份
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 + "日");//2020年8月8日
}
}
//add方法
public class Demo01{
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年8月8日
// 使用add方法
cal.add(Calendar.DAY_OF_MONTH, 3); // 加3天
cal.add(Calendar.YEAR, -7); // 减7年
cal.add((Calendar.MONTH,+3);// 加3月
System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2011年11月11日;
}
}
//getTime方法
public class Demo03 {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
System.out.println(date); //Sat Aug 08 14:14:14 CST 2018
}
}
3.System类
java.lang.System类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作,在System类的API文档中,常用的方法有:
- public static long currentTimeMillis:返回以毫秒为单位的当前时间。
- public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length ):将数组中指定的数据拷贝到另一个数组中。
currentTimeMillis方法:就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值
public class SystemDemo01 {
public static void main(String[] args) {
//获取当前时间毫秒值
System.out.println(System.currentTimeMillis()); // 1516090531144
}
}
arraycopy方法:
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]
public class Demo1 {
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);
/*代码运行后:两个数组中的元素发生了变化
src数组元素[1,2,3,4,5]
dest数组元素[1,2,3,9,10]
*/
}
}
4.StringBuilder类
4.1 字符串拼接问题
由于String类的对象内容不可改变,所以每当进行字符串拼接时,总是会在内存中创建一个新的对象。例如:
public class StringDemo {
public static void main(String[] args) {
String s = "Hello";
s += "World";
System.out.println(s);
}
}
这种拼接既耗时,又浪费空间。为了解决这一问题,我们可以使用java.lang.StringBuilder类 (主要解决String拼接性能的问题)
StringBuilder又称为可变字符序列,它是一个类似于 String 的字符串缓冲区,通过某些方法调用可以改变该序列的长度和内容。原来StringBuilder是个字符串的缓冲区,即它是一个容器,容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。它的内部拥有一个数组用来存放字符串内容,进行字符串拼接时,直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。
构造方法:
- public StringBuilder :构造一个空的StringBuilder容器
- public StringBuilder(String str):构造一个StringBuilder容器,并将字符串添加进去
public class Demo03 {
public static void main(String[] args) {
StringBuilder str = new StringBuilder();
System.out.println(str);
StringBuilder str2 = new StringBuilder("helloworld");
System.out.println(str2);
}
}
常用方法:
- public StringBuilder append():添加任意类型数据的字符串形式,并返回当前对象自身
- public String tostring():将当前StringBuilder对象转换为String对象
- 二者相互转换的目的是为了调用指定类的特有方法;
- reverse()方法;把StringBuilder里面的内容进行反转;
public class Demo03 {
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);
}
}
在这里StringBuilder已经重写了tostring方法
public class Demo03 {
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.包装类
Java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:
基本类型 | 对应的包装类(位于java.lang包中) |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
5.2 装箱与拆箱
基本类型与对应的包装类对象之间,来回转换的过程称为”装箱“与”拆箱“:
-
装箱:从基本类型转换为对应的包装类对象。
-
拆箱:从包装类对象转换为对应的基本类型。
用Integer与 int为例:
基本数值---->包装对象
Integer i = new Interger(4);//使用构造函数函数
Integer i2 = new Interger.value(4);//使用包装类中的valueOf方法
包装对象---->基本数值
int num = i.intValue();
5.3自动装箱与自动拆箱
由于我们经常要做基本类型与包装类之间的转换,从Java 5(JDK 1.5)开始,基本类型与包装类的装箱、拆箱动作可以自动完成。例如:
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边:将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后,再次装箱,把基本数值转成对象。
5.3 基本类型与字符串之间的转换
基本类型转换为String
基本类型转换String总共有三种方式:
1.直接拼接空字符串:如:34+"";
2.包装类的静态方法: toString(基本类型数据);
注意:静态的toString和从Object继承过来的普通成员方法toString没有关系;
3.String类的静态方法: valueOf(基本类型数据);
String转换成对应的基本类型
除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型:
-
public static byte parseByte(String s):将字符串参数转换为对应的byte基本类型
-
public static byte parseByte(String s):将字符串参数转换为对应的short基本类型。
-
public static short parseShort (String s):将字符串参数转换为对应的int基本类型。
-
public static int parseInt(String s):将字符串参数转换为对应的long基本类型。
-
public static float parseFloat (String s):将字符串参数转换为对应的float基本类型。
-
public static double parseBouble(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异常。