自学Java一段时间了，今天开始写博客，之后会陆续把之前的内容补发。
01.第一章：Object类_概述：
（1）.java.lang.Object类：使用时不需要导包；Java中任何的"类"包含数组都继承自“Object”。
Object类是所有引用类型的父类。
（2）.Object类中定义了很多方法，给子类继承；有很多方法我们子类可以重写。
02.第一章：Object类_toString方法：
（1）.toString()方法是Object类中定义的，作用：打印对象的属性。
（2）.它在Object类中的默认实现打印：全名限定的类名 + "@" + 十六进制的地址(对我们来说无意义);
（3）.如果我们想打印“对象的属性”就需要：重写此方法；
（4）.示例代码：
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
......//快捷键：alt + insert --> t --> 回车 --> 回车
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Demo {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("黄渤");
stu.setAge(22);
System.out.println(stu);
}
}
(5).其它说明：Java类库中的绝大部分类(ArrayList、String、Scanner类....)
都已经重写了：toString()方法。
03.第一章：Object类_equals方法：
1).equals方法也是Object类中定义的方法，作用：比较两个对象的所有属性；
2).equals方法在Object类中的默认实现，使用：== 判断，判断两个对象的地址是否一样(对于我们无意义)；
3).我们需要重写此方法，用于：比较两个对象的所有属性值是否一样；
4).示例代码：
public class Student {
private String name;
private int age;
.....
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override//快捷键:alt + insert --> e --> next --> 回车 --> 回车
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
}
public class Demo {
public static void main(String[] args) {
Student stu1 = new Student(“孙红雷”, 18);
Student stu2 = new Student("黄渤", 19);
Student stu3 = new Student("黄渤", 19);
System.out.println("自己判断：");
System.out.println(stu2.getName().equals(stu3.getName()) &&
stu2.getAge() == stu3.getAge());
System.out.println("使用equals方法：");
System.out.println(stu2.equals(stu3));//true
System.out.println(stu2 == stu3);//false
}
}
5).注意：Idea的快捷键会同时生成equals()和hashCode()方法，删掉hashCode()即可；
04.第一章：Object类_Objects类：
1).java.util.Objects(类):使用时要导包；作用：“对象”操作的工具类；里面包含了一些对“对象”操作的一些“静态”方法。
2).Objects类中的equals(Object obj1 , Object obj2):可以判断obj1和obj2两个对象是否“相等”，它内部也基于被判断对象内部的equals()的实现。它内部增加了“空指针的验证”，可以有效的防止“空指针异常”。
3).示例代码：
public class Demo {
public static void main(String[] args) {
Student stu1 = null;
Student stu2 = new Student(“孙红雷”,18);
System.out.println(stu1.equals(stu2));//如果stu1为null，运行时会抛出”空指针异常”
System.out.println(Objects.equals(stu1,stu2));//有效的防止：stu1为null的情况
}
}
05.第二章：日期和时间类_Date类：
1).java.util.Date(类):表示一个日期和时间，精确到毫秒；
注意：java.sql.Date(是java.util.Date的子类)，不要使用这个类，在导包时注意；
2).构造方法：
1).Date():使用当前系统时间构造一个Date对象；
3).常用方法：
1).public long getTime():获取从1970年01月01日开始到此Date对象所表示的时间的一个“毫秒值”；
2).public void setTime(long m):设置此date对象为一个m毫秒值；
06.第二章：日期和时间类DateFormat类将Date转换为String：
1).java.text.DateFormat(抽象类):它可以对日期进行“格式化”。它是“抽象类”，我们可以直接使用它的子类：java.text.SimpleDateFormat(类):
2).子类SimpleDateFormat的构造方法：
1).SimpleDateFormat(String pattern):使用一个“模式字符串”来构造一个SimpleDateFormat对象；
3).成员方法：
1).public String format(Date date):将一个Date对象转换为String象；
4).示例代码：
public class Demo {
public static void main(String[] args) {
//1.创建一个Date对象
Date date = new Date();
System.out.println(date);//英文格式，我们看不懂
//2.创建一个SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”);
//3.将Date对象转换为String
String dateStr = sdf.format(date);
System.out.println(dateStr);//2018年08月11日 10:22:33
}
}
5).“模式”说明：
1).y : 代表“年”；
2).M : 代表“月”；
3).d : 代表“日”；
4).H : 代表“小时”；
5).m : 代表“分钟”；
6).s : 代表“秒”；
07.第二章：日期和时间类DateFormat类将String转换为Date：
1).示例代码：
public class Demo {
public static void main(String[] args) throws ParseException {
String str = “2018-08-11”
//1.创建一个SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);
//2.将String转换为Date
Date date = sdf.parse(str);
//3.验证结果
System.out.println(date);
}
}
08.第二章：日期和时间类练习1转换字符串的日期格式：
1).需求：将“2018-08-11”格式串转换为“2018年08月11日”格式：
2).代码实现：
public class Demo {
public static void main(String[] args) throws ParseException {
//需求：将“2018-08-11”格式串转换为“2018年08月11日”格式
String str = “2018-08-11”;//str(2018-08-11) –> Date –> str(2018年08月11日)
//1.创建一个SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);
Date date = sdf.parse(str);
//2.将date对象转换为”yyyy年MM月dd日”的格式
SimpleDateFormat sdf2 = new SimpleDateFormat(“yyyy年MM月dd日”);
String str2 = sdf2.format(date);
//3.验证结果
System.out.println(str2);
}
}
09.第二章：日期和时间类练习2计算来到世界多少天：
1).需求：从控制台接收用户的生日，然后程序为其计算出：你来到世界一共多少天
2).代码实现：
public class Demo {
public static void main(String[] args) throws ParseException {
//需求：从控制台接收用户的生日，然后程序为其计算出：你来到世界一共多少天。
//1.从控制台接收生日
Scanner sc = new Scanner(System.in);
System.out.println(“请输入你的生日，格式：yyyy-MM-dd:”);
String strDate = sc.next();//”1992-08-11”
//2.将String转换为Date
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);
Date date1 = sdf.parse(strDate);
long m1 = date1.getTime();
//3.获取当前系统时间的毫秒值；
long m2 = new Date().getTime();
//4.计算差值
System.out.println(“你一共来到世界：” + ((m2 - m1) / 1000 / 3600 / 24) + ” 天”);
}
}
10.第二章：日期和时间类_Calendar（日历）类：
1).java.util.Calendar(抽象类):它是抽象类，我们可以使用它的静态方法，getInstance()来获取它的一个子类对象；
2).常用方法：
1).public int get(int field):获取某个字段的值；
2).public void set(int field,int value):设置指定字段的值；
3).public void add(int field,int value):将指定的字段的值增加value。
3).示例代码：
public class Demo {
public static void main(String[] args) {
//1.获取一个Calendar的子类对象
Calendar c = Calendar.getInstance();
//2.获取年、月、日、小时、分钟、秒、星期几
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);
int week = c.get(Calendar.DAY_OF_WEEK);//返回值1–7，分别代表：星期日，星期一，星期二，星期三….星期六
System.out.println(year + “-” + month + “-” + day + ” ” + hour + “:” + minute + “:” + second);
System.out.println(getWeek(week));
//将c对象设置为2019年
c.set(Calendar.YEAR,2099);
week = c.get(Calendar.DAY_OF_WEEK);
System.out.println(“2099年的今天是：” + getWeek(week));
//计算班长出生那天是星期几
c.set(Calendar.YEAR,1994);
c.set(Calendar.MONTH,6 - 1);
c.set(Calendar.DAY_OF_MONTH,1);
week = c.get(Calendar.DAY_OF_WEEK);
System.out.println(“班长出生那天是：” + getWeek(week));
//重新获取日历对象
c = Calendar.getInstance();
//计算180天后，是几月几号
c.add(Calendar.DAY_OF_MONTH,180);
System.out.println(c.get(Calendar.YEAR) + “年” + (c.get(Calendar.MONTH) + 1) + “月” + c.get(Calendar.DAY_OF_MONTH) + “日”);
}
*//查表法：获取中文的星期表示*
public static String getWeek(int w){
String[] weekArray = {“星期日”,”星期一”,”星期二”,”星期三”,”星期四”,”星期五”,”星期六”};
return weekArray[w - 1];
}
}**
11.第三章：System类_作用及常用方法：
1).java.lang.System(类):包含了一些实用的静态方法；
2).常用方法：
1).public static void arraycopy(Object src,//原数组
int srcPos,//原数组的起始位置
Object dest,//目标数组
int destPos,//目标数组的起始位置
int length //复制长度
)：复制数组
示例代码：
public static void main(String[] args) {
int[] arr = {1,2,34,324,32,1,432,4,31,432,452,14,215,43,421,43,5};
int[] arr2 = new int[arr.length];
System.arraycopy(arr,0,arr2,0,arr.length);
//验证
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
}
2).public static long currentTimeMillis()：获取当前系统时间的毫秒值；
等同于：new Date().getTime()。
作用：计算代码的执行时间；
示例代码：
int[] arr = new int[10000000];
long start = System.currentTimeMillis();
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
long end = System.currentTimeMillis();
System.out.println(“执行时间：” + ( end - start) + ” 毫秒”);
12.第四章：StringBuilder类_回顾String类的不可变性：
public static void main(String[] args) {
String s1 = "Hello";
s1 = "World";
System.out.println(s1);//World(改变的是s1的地址)
//面试题
String s2 = "呵呵";
String s3 = "呵呵";
System.out.println(s2 == s3);//true-地址相同
String s4 = "呵呵";
String s5 = new String("呵呵");
System.out.println(s4 == s5);//false
System.out.println(s4.equals(s5));//true
String s6 = "呵";
String s7 = "呵";
String s8 = "呵" + "呵";//编译后就是：s8 = "呵呵";
String s9 = s6 + "呵";//产生新地址
String s10 = "呵" + s7;//产生新地址
String s11 = "呵呵";
System.out.println(s4 == s8);//true
System.out.println(s4 == s9);//false
System.out.println(s4 == s10);//false
System.out.println(s4 == s11);//true
//对String进行+操作，会很浪费空间；
String s12 = "Hello";
s12 = s12 + "World";
System.out.println(s12);
}
13.第四章：StringBuilder类_概述及常用方法：
1).java.lang.StringBuilder(类):它常用来代替字符串的"+"运算符，进行多字符串连接的。
2).当进行“字符串连接”时，使用string以及+运算符，会产生很多的垃圾，降低程序的效率,所以以后当需要进行字符串连接时，可以使用：StringBuilder类；
3).StringBuilder的工作原理：它内部有一个“缓存区(字符数组)”，当进行字符串连接时，会将新字符串添加到这个缓冲区末尾，但StringBuilder对象只有一个。
4).StringBuilder的构造方法：
1).StringBuilder(String s):
2).StringBuilder():
5).常用方法：
1).public StringBuilder append(各种类型) : 将各种类型数据转换为String，并添加到当前StringBuilder对象的末尾。
6).示例代码：
public class Demo {
public static void main(String[] args) {
int[] arr = {1,2,42,43,243,532,43};
System.out.println(printArray(arr));
String s1 = "Hello";
s1 = s1 + 10;
s1 = s1 + 3.14;
System.out.println(s1);//整个过程会产生很多垃圾
StringBuilder bld = new StringBuilder();
bld.append("Hello");
bld.append(10);
bld.append(3.14);
System.out.println(bld.length());//整个过程只有一个StringBuilder对象
System.out.println(bld.toString());
}
//编写方法，将int[]转换为String
public static String printArray(int[] arr){
StringBuilder s = new StringBuilder("[");
for (int i = 0; i < arr.length; i++) {
s.append(arr[i]);
if(i < arr.length - 1){
s.append(" ,");
}else{
s.append(" ]");
}
}
return s.toString();
}
}
14.第四章：String类和StringBuilder类的区别小结：
1).String表示一个“字符串”，是“不可变的”；
String s = "Hello";
2).StringBuilder不能表示一个字符串，它只是一个字符串的**工具类**，内部是“可变的”。
StringBuilder bld = "Hello";//错误
StringBuilder bld = new StringBuilder("Hello");//OK的
当需要做“字符串连接时”，建议使用“StringBuilder”：
String s1 = "Hello";
s1 = s1 + 10;
s1 = s1 + 3.14;
System.out.println(s1);//整个过程会产生很多垃圾
StringBuilder bld = new StringBuilder();
bld.append("Hello");
bld.append(10);
bld.append(3.14);
System.out.println(bld.length());//整个过程只有一个StringBuilder对象
System.out.println(bld.toString());
15.第五章：包装类_概念：
1).Java中四类八种的基本类型都对应有“包装类”：
基本类型 包装类
------------------------------------------------------
byte Byte
short Short
int Integer(名字特殊)
long Long
float Float
double Double
char Character(名字特殊)
boolean Boolean
2).每种包装类：
1).都可以存储一个此种类型的数据；
2).内部都包含的大量的对此种数据进行操作的一些实用方法;
16.第五章：包装类_常见应用：
1).将String类型转换为某种类型：
String ageStr = "24";
int age = Integer.parseInt(ageStr);
System.out.println(age);
任何的包装类(**除Character**)，都有：parseXxxx(String s):
Byte --> parseByte(String s);
Short --> parseShort(String s):
Integer --> parseInt(String s);
Long --> parseLong(String s):
...
2).将某种类型的数据转换为String:
int age = 24;
String s = Integer.toString(age);
System.out.println(s);
任何的包装类，都有：toString(此种类型数据),可以将这种类型的数据转换为String类型；
Byte --> toString(byte b);
Short --> toString(short s);
Integer --> toString(int i);
17.第五章：包装类_装箱和拆箱：
Integer intObj = new Integer(10);//这样很麻烦；
从JDK5以后：
//1.自动装箱：将基本类型转换为“包装类型”：使用方便，等同于基本类型；
Integer intObj = 10;
//2.自动拆箱：将“包装类型”自动转换为“基本类型”
int b = intObj;
-------------------------------------------------------------------------
1).自动装箱的应用：
ArrayList<Integer> intList = new ArrayList<>();
intList.add(10);//自动装箱
intLits.add(5);//自动装箱
intList.add(12);//自动装箱
for(int i = 0;i < intList.size();i++){
int n = intList.get(i);//自动拆箱
}
2).意义：自动装箱和自动拆箱将“基本类型”和“包装类型”等同使用，使用起来比较方便。
学习目标总结：
01.能够说出Object类的特点
它是Java所有类的父类，包括：类库中的类，我们自己定义的类，数组
02.能够重写Object类的toString方法
1).toString()方法的作用：打印对象的属性；
2).怎么重写：
public String toString(){
return “类名 属性名 = ” + 属性 + ….;
}
03.能够重写Object类的equals方法
1).equals()方法的作用：比较两个中的所有的属性；
2).怎么重写：
public boolean equals(Object obj){
….
}
04.能够使用日期类输出当前日期
Date date = new Date();
System.out.println(date);
05.能够使用将日期格式化为字符串的方法
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);
String str = sdf.format(date);
…
06.能够使用将字符串转换成日期的方法
String str = “2018-08-11”;
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);
Date date = sdf.parse(str);//注意：抛异常
….
07.能够使用System类的数组复制方法
int[] arr = {1,23,4,32,43254,23};
int[] arr2 = new int[arr.length];
System.arraycopy(arr,
0,
arr2,
0,
arr.length);
08.能够使用System类获取当前毫秒时刻值
long start = System.currentTimeMillis();
…
long end = System.currentTimeMillis();
09.能够说出使用StringBuilder类可以解决的问题
StringBuilder是可变的，它用来做：字符串拼接；提高效率；
10.能够使用StringBuilder进行字符串拼接操作
StringBuilder bld = new StringBuilder(“[“);
for(int i = 0 ; i < arr.length ; i++){
bld.append(arr[i]);
…
}
11.能够说出8种基本类型对应的包装类名称
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
12.能够说出自动装箱、 自动拆箱的概念
1.自动装箱：基本类型–>包装类型
Integer intObj = 10;
2.自动拆箱：包装类型–>基本类型
int a = intObj;
intObj++;
13.能够将字符串转换为对应的基本类型
String ageStr = “24”;
int age = Integer.parseInt(ageStr);
各种数据类型.parseXxxx(String)
14.能够将基本类型转换为对应的字符串
int a = 10;
String str = Integer.toString(a);
…