java自学笔记(day06),归纳总结自:B站千锋教育
Object类
- 超类、基类,所有类的直接或间接父类,位于继承树的最顶层。
- 任何类,如果没有书写extends显式继承某个类,都默认直接继承Object类,否则为间接继承。
- Object类中所有定义的方法,是所有对象都具备的方法。
- Object类型可以存储任何对象。
- 作为参数,可接受任何对象。
- 作为返回值,可返回任何对象。
getClass()方法
public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用:通过用于判断两个引用中实际存储对象类型是否一致。
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("yangge", 18);
Student s2 = new Student("wangge", 20);
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2){
System.out.println("s1和s2属于同一个类型");
}else{
System.out.println("s1和s2不属于同一个类型");
}
}
}
hashCode()方法
public int hashCode(){}
返回该对象的哈希码值。
哈希值根据对象的地址或 字符串或数字使用hash算法计算出来的int类型的数值。
一般情况下相同对象返回相同哈希码。
System.out.println("hashCode()方法结果如下:");
System.out.println("s1.hashCode() = "+s1.hashCode());
System.out.println("s2.hashCode() = "+s2.hashCode());
Student s3 = s1;
System.out.println("s3.hashCode() = "+s3.hashCode());
hashCode()方法结果如下:
s1.hashCode() = 1163157884
s2.hashCode() = 1956725890
s3.hashCode() = 1163157884
toString()方法
public String toString(){}
返回该对象的字符串表示(表现形式)
可以根据程序需求覆盖该方法,如:展示对象各个属性值。
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
System.out.println(s1.toString());
equals()方法
- public boolean equals(Object obj){}
- 默认实现为(this == obj),比较两个对象地址是否相同。
- 可进行覆盖,比较两个对象的内容是否相同。
- equals()方法覆盖步骤
- 比较两个引用是否指向同一个对象
- 判断obj是否为null
- 判断两个引用指向的实际对象类型是否一致
- 强制类型转换
- 依次比较各个属性值是否相同
@Override
public boolean equals(Object obj) {
//1.判断两个对象是否是一个引用
if (this == obj){
return true;
}
//2.判断obj是否为null
if (obj == null){
return false;
}
//3.instanceof 判断对象是否某种类型
if (obj instanceof Student){
//4.强制类型转换
Student s = (Student) obj;
//5.比较熟悉
if (this.name.equals(s.getName()) && this.age == s.getAge()){
return true;
};
}
return false;
}
Student s4 = new Student("zhangsan", 15);
Student s5 = new Student("zhangsan", 15);
System.out.println(s4.equals(s5));
finalize()方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列。
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象。
- 垃圾回收:由GC销毁垃圾对象,释放数据存储空间。
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象。
- 手动回收机制:使用System.gc();通知JVM执行垃圾回收。
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"对象被回收了");
}
new Student("aaa",18);
new Student("bbb",18);
new Student("ccc",18);
new Student("ddd",18);
new Student("eee",18);
new Student("fff",18);
System.gc();
包装类
基本数据类型所对应的引用数据类型。
Object可统一所有数据,包装类的默认值为null。
包装类对应
基本数据类型 | 包装类型 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
类型转换与装箱、拆箱
JDK1.5之后有自动装箱和拆箱,可以从生成的class文件中看出<
public class Demo1 {
public static void main(String[] args) {
//类型转换:装箱,基本类型转为引用类型的过程
//基本类型
int num1 = 18;
//使用Integer类创建对象
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
System.out.println("装箱");
System.out.println(integer1);
System.out.println(integer2);
//类型转换:拆箱,引用类型转为基本类型的过程
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
System.out.println("拆箱");
System.out.println(num2);
//JDK1.5之后,提供自动装箱和拆箱
int age = 30;
//自动装箱
Integer integer4 = age;
System.out.println("自动装箱");
System.out.println(integer4);
//自动拆箱
int age2 = integer4;
System.out.println("自动拆箱");
System.out.println(age2);
}
}
基本类型和字符串转换
System.out.println("========基本类型和字符串之间的转换==========");
//基本类型和字符串之间转换
//1.基本类型转为字符串
int n1 = 15;
//1.1使用+号
String str1 = n1+"";
//1.2使用Integer的toString()方法
String str2 = Integer.toString(n1,16);
System.out.println(str1);
System.out.println(str2);
//2.字符串转为基本类型
String str3 = "12";
//使用Integer.parseXXX()方法
int n2 = Integer.parseInt(str3);
System.out.println(n2);
//3.boolean字符串形式转为基本类型;"true" ---> true, 非"true" ---> false
String str4 = "true";
boolean b1 = Boolean.parseBoolean(str4);
System.out.println(b1);
- 8种包装类提供不同类型间的转换方式:
- Number父类中提供的6个共性方法。
- parseXXX()静态方法。
- valueOf()静态方法。
- 注意:需保证类型兼容,否则抛出NumberFormatException异常。
Integer缓冲区(理解)
- Java预先创建了256个常用的整数包装类型对象。
- 在实际应用当中,对已创建的对象进行复用。
重点理解Integer.valueOf()
public class Demo2 {
public static void main(String[] args) {
//整数缓冲区面试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1 == integer2);//false
Integer integer3 = Integer.valueOf(100);//自动装箱Integer.valueOf()
Integer integer4 = Integer.valueOf(100);
System.out.println(integer3 == integer4);//true
Integer integer5 = Integer.valueOf(200);
Integer integer6 = Integer.valueOf(200);
System.out.println(integer5 == integer6);//false
}
}
String类概述(重点)
- 字符串是常量,创建之后不可改变。
- 字符串字面值存储在字符串池中,可以共享。
- String s = “Hello”; 产生一个对象,字符串池中存储。
- String s = new String(“Hello”); //产生两个对象,堆、池各存储一个。
public class Demo3 {
public static void main(String[] args) {
String name = "Hello"; //"Hello"常量存储在字符串池中,
name = "zhangsan"; //"zhangsan"赋值给name变量,给字符串赋值的时候并没有修改数据,而是重新开辟空间
String name2 = "zhangsan";
//演示字符串的另一种创建方式,new String();
String str = new String("java");
String str2 = new String("java");
System.out.println(str == str2); //false
System.out.println(str.equals(str2)); //true
}
}
String的常用方法
public int length():返回字符串的长度
String str = "java是最好的编程语言!";
System.out.println(str.length()); //13
public char charAt(int index):根据下标获取字符
System.out.println(str.charAt(str.length()-1));// !
public boolean contains(String str):判断当前字符串中是否包含str
System.out.println(str.contains("j")); //true
public char[] toCharArray():将字符串转为数组
String str2 = "java是最好的编程语言,java真香~";
System.out.println(Arrays.toString(str2.toCharArray())); //[j, a, v, a, 是, 最, 好, 的, 编, 程, 语, 言, ,, j, a, v, a, 真, 香, ~]
public int indexOf(String str):查找str首次出现的下标,存在则返回该下标;不存在则返回-1
System.out.println(str2.indexOf("java")); //0
System.out.println(str2.indexOf("java",5));//13,因为从第二位开始,后得到java的首字母j位于13号位置,所以返回。
public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引
System.out.println(str2.lastIndexOf("va")); //15
public String trim():去掉字符串前后的空格
String str3 = " Hello World ";
System.out.println(str3.trim()); //Hello World
public String toUpperCase(),toLowerCase():将小写转成大写或大写转成小写
System.out.println(str3.toUpperCase()); // HELLO WORLD
System.out.println(str3.toLowerCase()); // hello world
public boolean endWith(String str),startWith(String str):判断字符串是否以str结尾或以str开始
String str4 = "hello.java";
System.out.println(str4.endsWith(".java")); //true
System.out.println(str4.startsWith("he")); //true
public String replace(char oldChar, char newChar):将旧字符串替换成新字符串
String str5 = "我爱java,一天不用IDEA写java就难受";
System.out.println(str5.replace("java","php")); //我爱php,一天不用IDEA写php就难受
public String[] split(String str):根据str做拆分
String str6 = "java is the best porgraming languae in the world,java xiang";
String[] arr = str6.split("[ ,]+");//[]代表供选择的,+代表可以有多个
for (String string: arr) {
System.out.println(string);
}
//java
//is
//the
//best
//porgraming
//languae
//in
//the
//world
//java
//xiang
补充两个方法equals()、compareTo();比较大小
equals()
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2)); //false
System.out.println(s1.equalsIgnoreCase(s2)); //true
compareTo()两个字符串比较大小实质上是比较其在编码表的位置
String s3 = "abc"; //a的ASCII值为97
String s4 = "xyz"; //x的ASCII值为120
System.out.println(s3.compareTo(s4)); //比大小
String s5 = "abc";
String s6 = "abcd";
System.out.println(s5.compareTo(s6)); //比长度
String案列演示
package com.commonclass;
/*
* 需求:
* 已知String str = "this is a text";
* 1.将str中的单词单独取出来
* 2.将str中的text替换为practice
* 3.在text前面插入一个easy
* 4.将每个单词的首字母改为大写
* */
public class Demo5 {
public static void main(String[] args) {
String str = "this is a text";
//1.将str中的单词单独取出来
String[] arr = str.split(" ");
for (String string: arr) {
System.out.println(string);
}
//2.将str中的text替换为practice
System.out.println(str.replace("text","practice"));
//3.在text前面插入一个easy
System.out.println(str.replace("text","easy text"));
//4.将每个单词的首字母改为大写
for(int i = 0; i < arr.length; i++){
char first = arr[i].charAt(0); //获取到数组元素的首字母
char upperfirst = Character.toUpperCase(first); //将数组元素的首字母转为大写
String news = upperfirst+arr[i].substring(1); //将数组元素首字母与其后续拼接在一起
System.out.println(news);
//This
//Is
//A
//Text
}
}
}
可变字符串
StringBuffer:可变长字符串,JDK1.0提供,运行效率慢、线程安全
package com.commonclass;
/*
* StringBuffer和StringBuilder的使用
* 和String的区别:1.效率比String高;2.比String节省内存
* */
public class Demo6 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//1.append();追加
sb.append("java世界第一秀");
System.out.println(sb.toString()); //java世界第一秀
sb.append("java真香");
System.out.println(sb.toString()); //java世界第一秀java真香
sb.append("java不错");
System.out.println(sb.toString()); //java世界第一秀java真香java不错
//2.insert();添加
sb.insert(0, "我在最前面");
System.out.println(sb.toString()); //我在最前面java世界第一秀java真香java不错
//3.replace();替换
sb.replace(0, 4, "hello"); //遵循左包含原则,eg:[20,30);
System.out.println(sb.toString()); // hello面java世界第一秀java真香java不错
//4.delete();删除
sb.delete(0, sb.length()); //输出为空
System.out.println(sb.toString());
System.out.println(sb.length()); //0
}
}
StringBuilder:可变长字符串,JDK5.0提供,运行效率快、线程不安全
package com.commonclass;
/*
* StringBuffer和StringBuilder的使用
* 和String的区别:1.效率比String高;2.比String节省内存
* */
public class Demo6 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
//1.append();追加
sb.append("java世界第一秀");
System.out.println(sb.toString()); //java世界第一秀
sb.append("java真香");
System.out.println(sb.toString()); //java世界第一秀java真香
sb.append("java不错");
System.out.println(sb.toString()); //java世界第一秀java真香java不错
//2.insert();添加
sb.insert(0, "我在最前面");
System.out.println(sb.toString()); //我在最前面java世界第一秀java真香java不错
//3.replace();替换
sb.replace(0, 4, "hello"); //遵循左包含原则,eg:[20,30);
System.out.println(sb.toString()); // hello面java世界第一秀java真香java不错
//4.delete();删除
sb.delete(0, sb.length()); //输出为空
System.out.println(sb.toString());
System.out.println(sb.length()); //0
}
}
验证StringBuilder效率高于String
package com.commonclass;
/*
* 验证StringBuilder效率高于String
* */
public class Demo7 {
public static void main(String[] args) {
long start = System.currentTimeMillis();
String string = "";
for (int i = 0; i < 99999; i++) {
string += i;
}
System.out.println(string);
long end = System.currentTimeMillis();
System.out.println("用时:" + (end - start)); //用时:34695
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 99999; i++) {
sb.append(i);
}
System.out.println(sb.toString());
long end2 = System.currentTimeMillis();
System.out.println("用时:" + (end2 - start)); //用时:31
}
}
BigDecimal类
double、float类型存储的是近似值!此时对于精度运算有需求的,需要借助BigDecimal
public class Demo8 {
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1 - d2); //0.09999999999999998
double result = (1.4 - 0.5) / 0.9;
System.out.println(result); //0.9999999999999999
}
}
- 位置:java.math包中。
- 作用:精确计算浮点数。
- 创建方式:BigDecimal bd = new BigDecimal(“1.0”);
- 方法:
- BigDecimal add(BigDecimal bd) 加
- BigDecimal subtract(BigDecimal bd) 减
- BigDecimal multiply(BigDecimal bd) 乘
- BigDecimal divide(BigDecimal bd) 除
- 除法:divide (BigDecimal bd, int scal, RoundingMode mode)
- 参数scal:指定精确到小数点后几位。
- 参数mode:
- 指定小数部分的取舍模式,通常采用四舍五入的模式。
- 取值为BigDecimal.ROUND_HALF_UP。
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1); //0.1
//加法
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2); //1.9
//乘法
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3); //0.90
//除法
//double result = (1.4 - 0.5) / 0.9;
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(r4); //1
BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
System.out.println(r5); //6.67
Date类
- Date类表示特定的瞬间,精确到毫秒。Date类中的大部分方法都已经被Calendat类中的方法所取代。
- 时间单位
- 1秒 = 1000毫秒
- 1毫秒 = 1000微秒
- 1微秒 = 1000纳秒
package com.commonclass;
import java.util.Date;
public class Demo9 {
public static void main(String[] args) {
//1.创建Date对象
Date date1 = new Date();
System.out.println(date1.toString());
System.out.println(date1.toLocaleString()); //2021-2-27 14:35:51
//昨天
Date date2 = new Date(date1.getTime() - (24 * 60 * 60 * 1000));
System.out.println(date2.toLocaleString()); //2021-2-26 14:35:51
//2.方法 after、before
boolean b1 = date1.after(date2);
System.out.println(b1); //true
boolean b2 = date1.before(date2);
System.out.println(b2); //false
//比较compareTo();
int d = date2.compareTo(date1);
System.out.println(d); //-1
//比较是否相等equals();
boolean b3 = date1.equals(date2);
System.out.println(b3); //false
}
}
Calendar类
-
所述
Calendar
类是一个抽象类,可以为在某一特定时刻和一组之间的转换的方法calendar fields
如YEAR
,MONTH
,DAY_OF_MONTH
,HOUR
,等等,以及用于操纵该日历字段,如获取的日期下个星期。时间上的瞬间可以用毫秒值表示,该值是从1970年1月1日00:00 00:00.000 GMT(Gregorian)的Epoch的偏移量。该类还提供了用于在包外部实现具体日历系统的其他字段和方法。 这些字段和方法定义为
protected
。与其他区域设置敏感的类一样,
Calendar
提供了一种类方法getInstance
,用于获取此类型的一般有用的对象。Calendar
的getInstance
方法返回一个Calendar
对象,其日历字段已使用当前日期和时间进行初始化:-
Calendar rightNow = Calendar.getInstance();
-
-
Calendat提供了获取或设置各种日历字段的方法。
-
构造方法
- protected Calendar(); 由于修饰符是protected,所以无法直接创建该对象。
-
其他方法
方法名 | 说明 |
---|---|
static Calendar getInstance() | 使用默认时区和区域获取日历 |
void set(int year, int month, int date, int hourofday, int minute, int second) | 设置日历的年、月、日、时、分、秒 |
int get(int field) | 返回给定日历字段的值。字段比如:年、月、日等 |
void setTime(Date date) | 用给定的Date设置此日历的时间。Date-Calendar |
Date getTime() | 返回一个Date表示此日历的时间。Calendar-Date |
void add(int field, int amount) | 按照日历的规则,给指定字段添加或减少时间量 |
long getTimeInMillies() | 毫秒为单位返回该日历的时间值 |
package com.commonclass;
import java.util.Calendar;
public class Demo10 {
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
System.out.println(calendar.getTimeInMillis());
//2.获取时间信息
//获取年
int year = calendar.get(Calendar.YEAR);
//获取月,月份从0-11
int month = calendar.get(Calendar.MONTH);
//日
int day = calendar.get(Calendar.DAY_OF_MONTH); //Date
//小时
int hour = calendar.get(Calendar.HOUR_OF_DAY); //HOUR12小时制,HOUR_OF_DAY24小时制
//分钟
int minute = calendar.get(Calendar.MINUTE);
//秒
int second = calendar.get(Calendar.SECOND);
System.out.println(year+"年" +(month+1)+"月" +day+"日 "+hour+":"+minute+":"+second);
//3.修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH, 6); //改变此月份的某一日子
//calendar2.set(Calendar.DAY_OF_MONTH, 30); 此时月份改为3月2日,因为2021年的2月只有28天
System.out.println(calendar2.getTime().toLocaleString());
//4.add方法修改时间
calendar2.add(Calendar.HOUR, -1); //减去一个小时
System.out.println(calendar2.getTime().toLocaleString());
//5.补充方法
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);
System.out.println(min);
}
}
SimpleDateFormat类
- SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
- 进行格式化(日期 -> 文本)、解析(文本 -> 日期)。
- 常用的时间模式字母
字母 | 日期或时间 | 示例 |
---|---|---|
y | 年 | 2019 |
M | 年中月份 | 08 |
d | 月中天数 | 10 |
H | 1天中小时数(0-23) | 22 |
m | 分钟 | 16 |
s | 秒 | 59 |
S | 毫秒 | 367 |
package com.commonclass;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo11 {
public static void main(String[] args) throws ParseException {
//1.创建SimpleDateFormat对象 y年 M月
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
//2.创建Date
Date date = new Date();
//3.格式化date (把日期转成字符串)
String str = sdf.format(date);
System.out.println(str);
//4.解析 (把字符串转成日期)
Date date2 = sdf.parse("1998/09/01");
System.out.println(date2);
}
}
System类
- System系统类,主要用于获取系统的属性数据和其他操作,构造方法私有的
方法名 | 说明 |
---|---|
static void arraycopy(…) | 复制数组 |
static long currentTimeMillis(); | 获取当前系统时间,返回的是毫秒值 |
static void gc(); | 建议JVM赶快启动垃圾回收器回收垃圾 |
static void exit (int status); | 推出JVM,如果参数是0表示正常推出JVM,非0表示异常推出JVM |
package com.commonclass;
import java.util.Arrays;
public class Demo12 {
public static void main(String[] args) {
//1.arraycopy:数组的复制
//src:源数组
//srcPos:从那个位置开始复制0
//dest:目标数组
//destPos:目标数组的位置
//length:复制的长度
int arr[] = {13, 15, 18, 25, 36, 78, 92, 100};
int[] dest = new int[8];
System.arraycopy(arr, 0, dest, 0, arr.length);
for (int i = 0; i < dest.length; i++){
System.out.println(dest[i]);
}
//Arrays.copyOf(original, newLength)
//2.System.currentTimeMillis()可用于计时
long start = System.currentTimeMillis();
for (int i = -999999; i < 999999; i++){
for (int j = -999999; j < 999999; j++){
int result = i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时:"+(end - start));
//3.static void gc();
Student s1 = new Student("wangge", 25);
Student s2 = new Student("sange", 25);
new Student("haiyan", 25);
new Student("haiwa", 25);
new Student("haiwang", 25);
System.gc(); //告诉垃圾回收器回收
//4.退出JVM
System.exit(0);
System.out.println("程序结束了.......");
}
}
总结
- 内部类:
- 在一个类的内部再定义一个完整的类。
- 成员内部类、静态内部类、局部内部类、匿名内部类。
- Object类
- 所有类的直接或间接父类,可以存储任何对象。
- 包装类:
- 基本数据类型所对应的引用数据类型,可以使Object统一所有数据。
- String类
- 字符串是常量,创建之后不可改变,字面值保存在字符串池中,可以共享。
- BigDecimal:
- 可精确计算浮点数
- Date
- 特定时间
- Calendar
- 日历
- SimpleDateFormat
- 格式化时间
- System
- 系统类