@学习记录
开始学习Java
遵从同学的指导，从Java se开始学习
黑马的JavaSE零基础入门
第一章 Object类
1.1 概述
1.2 toString方法
方法摘要
覆盖重写
day12-02 Object的toString方法
package day12.Demo01;
public class Demo01ToString {
public static void main(String[] args) {
// Person类默认继承了Object类，所以可以使用Object类中的toString方法
// 返回该对象的字符串表示
Person one = new Person("张三", 18);
String s = one.toString();
System.out.println(s);
// 直接打印对象的名字，就是调用对象的toString
System.out.println(one);
// 看一个类是否重写了toString，直接打印这个类的对象即可
// 如果没有，则打印的是对象的地址值
}
}
package day12.Demo01;
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方法
打印对象的属性（name, age）
*/
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", 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;
}
}
1.3 equals方法
方法摘要
默认地址值比较
对象内容比较
day12-03 Object的equals方法
package day12.Demo01;
public class Demo02Equals {
public static void main(String[] args) {
/*
Person类默认继承了Object类，所以可以使用Object类中的equals方法
用于比较对象是否相等
equals方法源码：
public boolean equals(Object obj) {
return (this == obj)
}
参数：
Object obj：可以传递任意的对象
== 比较运算符，返回的是一个布尔值 true / false
基本数据类型：比较的是值
引用数据类型：比较的是两个对象的地址值
*/
Person one = new Person("张三", 20);
Person two = new Person("李四", 22);
boolean b = one.equals(two);
System.out.println(b);
}
}
day12-04 重写Object的equals方法
package day12.Demo01;
public class Demo02Equals {
public static void main(String[] args) {
/*
Person类默认继承了Object类，所以可以使用Object类中的equals方法
用于比较对象是否相等
equals方法源码：
public boolean equals(Object obj) {
return (this == obj)
}
参数：
Object obj：可以传递任意的对象
== 比较运算符，返回的是一个布尔值 true / false
基本数据类型：比较的是值
引用数据类型：比较的是两个对象的地址值
*/
Person one = new Person("张三", 20);
Person two = new Person("张三", 20);
//
boolean b = one.equals(one);
System.out.println(b);
}
}
package day12.Demo01;
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方法
打印对象的属性（name, age）
*/
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
/*
Object类的equals方法，默认比较的是两个对象的地址值，没有意义
所以要重写equals方法，比较两个对象的属性（name,age）
问题：
隐含着一个多态
多态的弊端：无法使用子类特有的内容（属性和方法）
Object obj = two;
解决：可以使用向下转型（强转），把obj类型转换为Person
*/
// @Override
// public boolean equals(Object obj) {
// // 增加一个判断，传递的参数obj如果是this本身，直接返回true，提高程序效率
// if (obj == this) {
// return true;
// }
//
// // 增加一个判断，传递的参数obj如果是null，直接返回false,提高程序的效率
// if (obj == null) {
// return false;
// }
//
// // 增加一个判断，防止类型转换异常
// if (obj instanceof Person) {
// // 使用向下转型，把obj类型转换为Person
// Person person = (Person) obj;
// // 比较两个对象的属性，一个是this,一个是person
// boolean b = this.name.equals(person.name) && this.age == age;
// return b;
// }
//
// return false;
//
// }
@Override
public boolean equals(Object o) {
if (this == o) return true;
// getClass() != o.getClass() 使用反射技术，判断o是否是Person类型
// 等效于obj instanceof Person
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, 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;
}
}
1.4 Objects类
day12-05 Objects的equals方法
容忍空指针异常
package day12.Demo01;
import java.util.Objects;
public class Demo03Objects {
public static void main(String[] args) {
// String s1 = "abc";
String s1 = null;
String s2 = "abc";
// boolean equals = s1.equals(s2); // 空指针异常
// System.out.println(equals);
/*
Objects类的equals方法：对两个对象进行比较，防止空指针异常
public static boolean equals (Object a, Object b) {
return (a == b0 || （a != null && a.equals(b)）);
}
*/
boolean equals1 = Objects.equals(s1, s2);
System.out.println(equals1);
}
}
第二章 日期时间类
2.1 Date类
概述
常用方法
day12-06 毫秒值的概念和作用
package day12.Demo02;
/*
Date类，表示日期和时间的类
类Date表示特定的瞬间，精确到毫秒
毫秒：千分之一秒
特定的时间：一个时间点
毫秒值的作用：可以对时间和日期进行计算
将日期转换为毫秒进行计算，计算完毕，再把毫秒转换为日期
把日期转换为毫秒：
计算当前日期到时间原点（英国格林威治时间）之前一共经历了多少毫秒
注意：中国属于东八区，会把时间增加8个小时
把毫秒转换为日期：
1 天 = 86400000 毫秒
*/
public class Demo01Date {
public static void main(String[] args) {
System.out.println(System.currentTimeMillis()); // 获取当前系统时间一共到原点经历了多少毫秒，结果是L类型
}
}
day12-07 Date类的构造方法和成员方法
package day12.Demo02;
import java.util.Date;
public class Demo02Date {
public static void main(String[] args) {
demo01();
demo02();
demo03();
}
/*
Date类的空参数构造方法：
Date() 获取当前系统的日期和时间
*/
private static void demo01() {
Date date = new Date();
System.out.println(date); // 打印的不是地址是，Date类重写了toString方法
}
/*
Date类的带参数构造方法：
Date(long date) 传递毫秒值，把毫秒值转换为Date日期
*/
private static void demo02() {
Date date = new Date(0L);
System.out.println(date);
}
/*
long getTime() 把日期转换为毫秒，相当于System.currentTimeMillis()方法
*/
private static void demo03() {
Date date = new Date();
long time = date.getTime();
System.out.println(time);
}
}
2.2 DateFormat类
构造方法
格式规则
常用方法：
format方法
parse方法
day12-08 DateFormat类&SimpleDateFormat类介绍
day12-09 DateFormat类的format方法和parse方法
package day12.Demo03;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
java.text.DateFormat 时间/日期格式化子类的抽象类
作用：
格式化（也就是日期 -> 文本）、解析（文本 -> 日期）
成员方法：
String format(Date date) 按照指定的模式，把Date日期格式化为符合模式的字符串
Date parse(String source) 把符合模式的字符串，解析为Date日期
DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat的子类
java.text.SimpleDateFormat extends DateFormat
构造方法：
SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat
参数：
String pattern 传递指定的模式
模式：区分大小写的
y 年
M 月
d 日
H 时
m 分
s 秒
写对应的模式，把模式替换为对应的日期和时间
注意：模式中的字母不能更改，连接模式的符号可以改变
*/
public class DateFormat {
public static void main(String[] args) throws ParseException {
demo01();
System.out.println("=========================");
demo02();
}
/*
使用DateFormat类中的方法format,把日期格式化为文本
使用步骤：
1.创建SimpleDateFormat对象，构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的format方法，按照构造方法中指定的模式，把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);
}
/*
使用DateFormat类中的方法方法parse,把文本解析为日期
使用步骤：
1.创建SimpleDateFormat对象，构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串解析为Date日期
注意：parse方法声明了一个异常叫ParseException，如果字符串和构造方法的模式不一样，那么程序就会抛出此异常
处理方法：要么throws继续抛出这个异常，要么try catch自己处理
*/
private static void demo02() throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
Date date = sdf.parse("2021年01月07日 21时32分17秒");
System.out.println(date);
}
}
2.3 练习
day12-10 计算一个人的出生天数
package day12.Demo03;
import org.w3c.dom.ls.LSOutput;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
/*
练习：
使用日期时间相关的API，计算出一个人已经出生了多少天
分析：
1.使用Scanner类中的方法next获取出生日期
2.使用DateFormat类中的方法parse，把字符串的出生日期解析为Date格式的出生日期
3.把Date格式的出生日期转换为毫秒值，
4.获取当前的日期，转换为毫秒值
5.使用当前日期的毫秒值-出生日期的毫秒值
6.把毫秒值转换为天
*/
public class Demo02Test {
public static void main(String[] args) throws ParseException {
// 使用Scanner类中的方法next获取出生日期
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您的出生日期，格式为yyyy-MM-dd：");
String birthday = scanner.next();
// 使用DateFormat类中的方法parse，把字符串的出生日期解析为Date格式的出生日期
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
Date birthdayDate = sdf1.parse(birthday);
// 把Date格式的出生日期转换为毫秒值
long birthdayDateTime = birthdayDate.getTime();
// 获取当前的日期，转换为毫秒值
Date date = new Date();
long dateTime = date.getTime();
// 使用当前日期的毫秒值-出生日期的毫秒值
long time = dateTime - birthdayDateTime;
// 把毫秒值转换为天
System.out.println(time / 1000 / 60 / 60 / 24);
}
}
2.4 Calendar类
概念
获取方式
常用方法：
get/set方法
add方法
getTime方法
day12-11 Calendar类的介绍，获取对象的方式
package day12.Demo04;
import java.util.Calendar;
/*
java.util.Calendar类；日历类
Calendar类是一个抽象类，里面提供了很多操作日历字段的方法（YEAR、MOUTH、DAY_OF_MONTH、HOUR）
Calendar类无法直接创建对象使用，里面有一个静态方法getInstance()，该方法返回了Calendar类的子类对象
getInstance()使用默认时区和语言环境获得一个日历
*/
public class Demo01Calendar {
public static void main(String[] args) {
Calendar instance = Calendar.getInstance();
System.out.println(instance);
}
}
day12-12 Calendar类的常用成员方法
package day12.Demo04;
import java.util.Calendar;
import java.util.Date;
/*
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对象
成员方法的参数：
int field 日历类的字段，可以使用Calendar类的静态成员变量获取
public static final int YEAR = 1;
public static final int MONTH = 2;
public static final int DATE = 5;
public static final int DAY_OF_MONTH = 5;
public static final int HOUR = 10;
public static final int MINUTE = 12;
public static final int SECOND = 13;
*/
public class Demo02Calendar {
public static void main(String[] args) {
demo01();
System.out.println("==================");
demo02();
System.out.println("==================");
demo03();
System.out.println("==================");
demo04();
}
/*
public int get(int field); 返回给定日历字段的值
参数：传递指定的日历字段
返回值：日历字段代表的具体的值
*/
private static void demo01() {
// 使用getInstance()方法获取Calendar对象
Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);
System.out.println(year);
System.out.println("======================");
int month = calendar.get(Calendar.MONTH);
System.out.println(month); // 西方的月份0-11，东方的月份1-12
System.out.println("=======================");
int day = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
int date = calendar.get(Calendar.DATE);
System.out.println(date);
}
/*
public void set(int field, int value); 将给定的日历字段设置为给定值
参数：
int field 传递指定的日历字段
int value 给指定字段设置的值
*/
private static void demo02() {
// 使用getInstance()方法获取Calendar对象
Calendar calendar = Calendar.getInstance();
// 设置年为2000
calendar.set(Calendar.YEAR, 2000);
// 设置月为8
calendar.set(Calendar.MONTH, 8);
// 设置天为20
calendar.set(Calendar.DAY_OF_MONTH, 20);
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.MONTH));
System.out.println(calendar.get(Calendar.DATE));
System.out.println("===========================");
// 同时设置年月日，可以使用set的重载方法
calendar.set(2020, 10, 30);
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.MONTH));
System.out.println(calendar.get(Calendar.DATE));
}
/*
public abstract void add(int field, int amount); 根据日历的规则，为给定的日历字段添加或减去指定的时间量
把指定的字段增加/减少指定的值
参数：
int field 传递指定的日历字段
int amount 增加/减少指定的值
正数：增加
负数：减少
*/
private static void demo03() {
// 使用getInstance()方法获取Calendar对象
Calendar calendar = Calendar.getInstance();
// 把年增加2
calendar.add(Calendar.YEAR, 2);
System.out.println(calendar.get(Calendar.YEAR));
// 把月减少3
calendar.add(Calendar.MONTH, -3);
System.out.println(calendar.get(Calendar.MONTH));
}
/*
public Date getTime(); 返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象
b把日历对象转换为日期对象
*/
private static void demo04() {
// 使用getInstance()方法获取Calendar对象
Calendar calendar = Calendar.getInstance();
Date date = calendar.getTime();
System.out.println(date);
}
}
第三章 System类
3.1 currentTimeMIllis方法与练习
3.2 arraycopy方法与练习
day12-13 System类的常用成员方法
package day12.Demo05;
/*
java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
public static long currentTimeMillis(); 返回以毫秒为单位的当前时间
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length); 将数组中指定的数据拷贝到另一个数组中
*/
import java.util.Arrays;
public class Demo01System {
public static void main(String[] args) {
// demo01();
// System.out.println("===================");
demo02();
}
/*
public static long currentTimeMillis(); 返回以毫秒为单位的当前时间
用来测试程序的效果
练习：验证for循环打印数字1-9999所需要的时间（毫秒）
*/
private static void demo01() {
// 程序执行前获取一次毫秒值
long start = System.currentTimeMillis();
// 执行for循环
for (int i = 0; i < 9999; i++) {
System.out.println(i + 1);
}
// 程序执行完毕，再获取一次毫秒值
long end = System.currentTimeMillis();
// 计算得到程序耗时
long time = end - start;
System.out.println("程序所需时间为：" + time);
}
/*
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length); 将数组中指定的数据拷贝到另一个数组中
参数：
Object src 源数组
int srcPos 源数组中的起始位置（起始索引）
Object dest 目标数组
int destPos 目标数组中的起始位置
int length 要复制的数组元素的数量
练习：
将src数组中的前3个元素复制到dest数组的前3个位置上
复制元素前:scr数组元素[1，2，3，4，5]，dest数组元素[6，7，8，9，10]
复制元素后scr数组元素[1，2，3，4，5].dest数组元素[1，2，3，9，10]
*/
private static void demo02() {
// 定义源数组
int[] src = {
1, 2, 3, 4, 5};
// 定义目标数组
int[] dest = {
6, 7, 8, 9, 10};
System.out.println("复制前的数组：" + Arrays.toString(dest));
// 复制数组
System.arraycopy(src, 0, dest, 0, 3);
System.out.println("复制后的数组：" + Arrays.toString(dest));
}
}
第四章 StringBuilder类(字符串缓冲区，可以提高操作效率)
4.1 字符串拼接问题
4.2 StringBuilder概述
day12-14 StringBuilder的原理
4.3 构造方法
package day12.Demo06;
/*
java,lang.StringBuilder类：字符串缓冲区，可以提高字符串的效率
构造方法：
StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为16个字符
StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容
*/
public class Demo01StringBuilder {
public static void main(String[] args) {
// 空参数构造法
StringBuilder bu1 = new StringBuilder();
System.out.println(bu1);
StringBuilder bu2 = new StringBuilder("abc");
System.out.println(bu2);
}
}
4.4 常用方法
append方法
toString方法
day12-15 StringBuilder的构造方法和append方法
package day12.Demo06;
/*
StringBuilder的常用方法：
public StringBuilder append(...); 添加任意类型数据的字符串形式，并返回当前对象自身
*/
public class Demo02StringBuilder {
public static void main(String[] args) {
// 创建StringBuilder对象
StringBuilder builder = new StringBuilder();
// 使用append方法往StringBuilder中添加数据
// append方法返回的是this,调用方法的对象是builder，即this == builder
StringBuilder builder1 = builder.append("abc"); // 把builder的地址值赋给了builder1
System.out.println(builder);
System.out.println(builder1);
System.out.println(builder == builder1); // 比较的是地址值，true
System.out.println("================");
// 使用append方法无需接收返回值
builder.append("cde");
builder.append(8);
builder.append('木');
builder.append('@');
builder.append(false);
System.out.println(builder);
System.out.println("======================");
// 链式编程：方法返回值是一个对象，可以继续调用方法
builder.append("gvjfi").append('你').append(true);
System.out.println(builder);
}
}
day12-16 StringBuilder的toString方法
package day12.Demo06;
/*
StringBuilder和String可以相互转化：
StringBuilder --> String 可以使用StringBuilder的带参构造方法
StringBuilder(String str); 构造一个字符串生成器，并初始化为指定的字符串内容
String --> StringBuilder 可以使用StringBuilder的toString方法
public String toString(); 将当前StringBuilder对象转换为String对象
*/
public class Demo03StringBuilder {
public static void main(String[] args) {
// StringBuilder --> String
String str = "hello";
StringBuilder stringBuilder = new StringBuilder(str);
// 往StringBuilder中添加数据
stringBuilder.append("world");
System.out.println(stringBuilder);
// String --> StringBuilder
String s = stringBuilder.toString();
System.out.println(s);
}
}
第五章 包装类
5.1 概述
day12-17 包装类的概念
5.2 装箱与拆箱
day12-18 包装类_装箱与拆箱
package day12.Demo07;
/*
装箱：把基本类型的数据包装到包装类中（基本数据类型 --> 包装类）
1.构造方法
Integer(int value) 构造一个新分配的Integer对象，它表示指定的int值
Integer(String s) 构造一个新分配的Integer对象，它表示String参数所指示的int值
注意：传递的字符串，必须是基本类型的字符串，否则回抛出异常，例如："100" 正确；"a" 抛异常
2.静态方法
static Integer valueOf(int i) 返回一个表示指定int值的Integer实例
static Integer valueIf(String s) 返回保存指定的String值的Integer对象
拆箱：在包装类中取出基本类型的数据（包装类 --> 基本类型数据）
1.成员方法
int intValue() 以int类型返回该Integer值
*/
public class Demo01Integer {
public static void main(String[] args) {
// 装箱，构造方法
Integer integer = new Integer(20); // 方法上有横线，说明方法过时了
System.out.println(integer);
Integer integer1 = new Integer("30");
System.out.println(integer1);
// 静态方法
Integer integer2 = Integer.valueOf(40);
System.out.println(integer2);
Integer integer3 = Integer.valueOf("50");
System.out.println(integer3);
// 拆箱，成员方法
int value = integer.intValue();
System.out.println(value);
}
}
day12-19 包装类_自动装箱与自动拆箱
package day12.Demo07;
/*
自动装箱和自动拆箱：基本类型数据和包装类之间可以自动相互转换
JDK1.5之后出现的新特性
*/
import java.util.ArrayList;
public class Demo02Integer {
public static void main(String[] args) {
// 自动装箱：直接把int类型的整数赋值包装类
Integer integer = 1; // 相当于Integer integer = new Integer(1);
// 自动拆箱：integer是包装类，无法直接参与运算，可以自动转换为基本数据类型，再进行计算
integer = integer + 2; // 相当于 integer = integer.intValue() + 2;结果的赋值是有一个自动装箱
ArrayList<Integer> list = new ArrayList<>();
list.add(30); // 自动装箱，list.add(Integer.valueOf(30)); list.add(new Integer(30));
int i = list.get(0); // 自动拆箱,list.get(0).intValue();
}
}
5.3 基本类型与字符串之间的转换
基本类型转换为String
day12-20 包装类_基本类型与字符串类型之间的转换
package day12.Demo07;
/*
基本数据类型与字符串类型之间的相互转换：
基本类型 --> 字符串
1.基本类型的值+"" 最简单的方法（工作中常用）
2.包装类的静态方法toString(参数)，不是Object类的toString() 重载
static String toString(int i); 返回一个表示指定整数的String对象
3.String类的静态方法valueOf(参数)
static String valueOf(int i); 返回int参数的字符串表示形式
字符串 --> 基本类型
使用包装类的静态方法parseXXX("字符串");
Integer类：static int parseInt(String s)
Double类：static double parseDouble(String s)
*/
public class Demo03Integer {
public static void main(String[] args) {
// 基本类型 --> 字符串
int i = 100;
String s = i + "";
System.out.println(s + 200); // 字符串相加是字符串相连
System.out.println("=================");
String s1 = Integer.toString(200);
System.out.println(s1 + 300);
System.out.println("====================");
String s2 = String.valueOf(300);
System.out.println(s2 + 400);
System.out.println("====================");
// 字符串 --> 基本类型
int i1 = Integer.parseInt(s1);
System.out.println(i1);
}
}