java学习笔记——常用类
一、Object类
1.Object是所有Java类的父类，Object类是java中唯一没有父类的类
2.如果在类的声明的时候没有显示的通过extends去继承谁，默认会继承Object类
3.Object类的作用就是提供一些公用的属性和方法
常用的方法
- equals(Object obj):比较两个对象的地址值是否相等
- getClass():返回此 Object的运行时类
Person p = new Person();
// 通过反射动态获取当前类的父类
System.out.println(p.getClass().getSuperclass());
- hashCode():返回该对象的哈希值
- toString():打印的是对象在堆里面的地址值
4 ==和equals的区别（面试题）
==：比较运算符
- 可以使用在基本数据类型和引用数据类型
- 如果比较基本数据类型，比较的是两个变量的值是否相等
- 如果比较引用数据类型，比较的是两个对象在堆里面的地址值是否相等，两个对象是否指向同一个对象实例
equals()
- equals是一个方法
- 它只能对引用数据类型进行比较
- equals重写前和==没区别，重写后有区别
- object类里面是这么定义的
public boolean equals(Object obj){
return (this == obj);
}
- 发现它还是通过 == 进行两个对象的比较，object定义的equals方法和 == 的作用一样，实际比较的是两个对象的地址值是否相等
- 像String、Date、File、包装类等等都重写了equals方法，重写以后，比较的不再是地址值了，而是比较两个对象的“实体内容”是否相等
- 通常情况下，我们自己定义的类是没有重写equals方法的，如果要比较两个实体内容是否相等，需要重写equals方法
- 一般情况下都会进行重写，比较两个对象的实体内容是否相等
5 toString（） 方法
- 当我们创建完一个对象以后，我们要输出对象的引用，实际上就是调用了当前对象的toString方法
- object类中是这么定义的
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
- （3）像String、Date、File、包装类都重写了toString方法，重写后的返回是当前类的实体内容
- （4）如果自己定义的类需要返回实体内容的话，需要重写
public class TestObject {
public static void main(String[] args) {
Person p = new Person();
// 比较基本数据类型 ==
int a = 10;
int b = 20;
double d = 10.0;
System.out.println(a==b);// false
System.out.println(a==d);// true
Person pp = new Person();
Person p1 = new Person();
Person p2=pp;
System.out.println(pp==p1);// false
System.out.println(pp==p2);// true
Person p3 = new Person("张三",18);
Person p4 = new Person("张三",18);
System.out.println(p3==p4);// false
System.out.println(p3.equals(p4));// false
String str = new String("张三");
String str1 = new String("张三");
System.out.println(str.equals(str1));// true
System.out.println("=======toString方法========");
Person p5 = new Person("李四",20);
System.out.println(p5.toString());// 地址值
String str2 = new String("张三");
System.out.println(str2.toString());
}
}
二、String类
String字符串，使用""引起来
- String通过final关键字修饰，不能被继承
- String字符串都是常量
- 字符串代表不可变的序列
- 体现：
1.当对字符串重新赋值时，需要重新指定一个内存区域进行赋值，不能直接在原有的值的基础上进行赋值
2.当现在有的字符串进行连接操作的时候，也要重新指定一个内存区域进行赋值，不能直接在原有的值的基础上进行赋值 - 创建字符串有两种方式
第一种方式：通过字面量定义的方式 String a = “aaa”
第二种方式：通过new构造方法进行创建 String str = new String(“aaa”); - 面试题：String str = new String(“str”)，这种方式在内存中创建了几个对象?
两个对象，一个堆里面的，一个字符串常量池里面的 - 结论：
1.常量（字面量）与常量拼接结果在常量池
2.如果其中一个是变量，结果就在堆里面
public class Demo1 {
@Test
public void test(){
String s1 = "abc";
String s2 = "abc";
s2="asc";
//System.out.println(s1==s2);// false
String s3 = "abc";
s3 += "ddd";
System.out.println(s3);
}
@Test
public void test1(){
// 第一种方式：通过字面量的方式创建字符串
String s1 = "javaEE";
String s2 = "javaEE";
// 第二种：通过构造方法创建字符串，在堆里面开辟了空间
String s3 = new String("javaEE");
String s4 = new String("javaEE");
System.out.println(s1==s2);// true
System.out.println(s1.equals(s2));// true
System.out.println(s1==s3);// false
System.out.println(s1==s4);// false
System.out.println(s3==s4);// false
System.out.println(s3.equals(s4));// true
Person p = new Person("张三",12);
Person p1 = new Person("张三",12);
System.out.println(p.getName().equals(p1.getName()));// true
System.out.println(p.getName()==p1.getName());// true
}
@Test
public void test2(){
String s1 = "Hello";
String s2 = "Java";
String s3 = "HelloJava";
String s4 = "Hello"+"Java";
String s5 = s1+"Java";
String s6 = "Hello"+s2;
String s7 = s1+s2;
System.out.println(s3==s4);// true 两个字面量连接
System.out.println(s3==s5);// false s5相当于new了
System.out.println(s3==s6);// false
System.out.println(s3==s7);// false
System.out.println(s5==s6);// false
System.out.println(s5==s7);// false
System.out.println(s6==s7);// false
}
}
}
-
字符串对象操作
1.public int length()：返回字符串的长度
2.public char charAt(int index)：返回指定索引位置的字符，字符串索引从0开始
3.public boolean equals(Object anObject)：比较两个字符串的实体内容是否相等
4.public int indexOf(String s)：返回字符串s在当前字符串中首次出现的位置，如果没有返回-1
5.public int indexOf(String s ,int startpoint)：返回字符串s从startpoint开始首次出现的位置，如果没有返回-1
6.public int lastIndexOf(String s)：返回字符串s在当前字符串中最后一次出现的位置，如果没有返回-1
7.public int lastIndexOf(String s ,int startpoint)：返回字符串s从startpoint开始最后一次出现的位置，如果没有返回-1
8.public boolean startsWith(String prefix)：判断是不是以字符串prefix开头
9.public boolean endsWith(String suffix)：判断是不是以字符串suffix结尾
10.String toLowerCase() ：将 String 中的所有字符转换为小写
11.String toUpperCase() ：将 String 中的所有字符转换为大写
12.boolean isEmpty() ：判断是否是空字符串
13.public boolean contains(String anotherString)：判断当前字符串中是否包含字符串anotherString -
字符串对象修改
1.public String substring(int startpoint)：根据startpoint进行截取字符串，返回截取后的字符串
2.public String substring(int start,int end)：根据坐标start开始截取，到end结束，包含start不包含end位置字符（包含头，不包含尾）
3.pubic String replace(char oldChar,char newChar)：把字符oldChar替换成newChar
4.public String trim()：去掉字符串左右的空格
5.public String concat(String str)：拼接字符串
6.public String[] split(String regex)：根据字符regex对当前字符串进行拆分，返回一个字符数组 -
StringBuffer类的常用方法
1.构造StringBuffer() StringBuffer(int size) StringBuffer(String str)2.添加
StringBuffer append(data); StringBuffer insert(index data);3.删除
StringBuffer delete(start,end)：包含头，不含尾 StringBuffer deleteCharAt(int index)：删除指定位置的元素4.查找
char charAt(index); int indexOf(string) int lastIndexOf(string)5.修改
StringBuffer replace(start,end,string); void setCharAt(index,char); -
StringBuffer、String 、StringBuilder三者区别（面试题）
(1) String：不可变序字符列，如果要修改字符串的值，不是在原有字符串值的基础上修改,而是重新分配一块内存区域
(2) StringBuffer：可变字符序列，在原有字符串的基础上进行修改，线程安全，效率低
(3) StringBuilder：可变字符序列，在原有字符串的基础上进行修改，线程不安全，效率高
(4)StringBuffer、String 、StringBuilder三者效率：StringBuilder > StringBuffer > String
三、封装类和包装类
1.封装类的原因：
- 基本数据类型的局限性太小了，只是一个类型，没办法写一些业务逻辑，封装成类，就会有类的特征，就可以使用面向对象，就可以在类里面定义业务逻辑，对一些东西进行限制，可以定义一些很好的功能
针对八种基本定义相应的引用类型——封装类
| 基本数据类型 | 封装类 |
|---|---|
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
2.包装类
-
java提供了8种基本数据类型，每个基本数据类型对应一个包装类，使基本数据类型的变量可以有类的特征
-
作用：对基本数据类型、包装类、String进行类型转换
-
装箱和拆箱（可手动或自动）（面试题）
装箱：基本数据类型转成对应的包装类
拆箱：包装类转成对应的基本数据类型
public class WrapperTest {
// 基本数据类型->包装类：调用包装类的构造方法，手动转换
// 装箱：基本数据类型转成包装类
// 拆箱：包装类转成基本数据类型
@Test
public void test(){
int num1 = 10;
//System.out.println(num1.toString());有错，是基本数据类型，不是类，不能封装这些方法
Integer int1 = new Integer(num1);
System.out.println(int1.toString());
Integer int2 = new Integer("1212");// 前提字符串必须是数字
System.out.println(int2);
boolean a = true;
Boolean b= new Boolean(a);
System.out.println(b);
// boolean有点特殊，只有值为true才是true，别的默认都是false
Boolean b1 = new Boolean("qwd");
System.out.println(b1);// false
// 手动拆箱：包装类转成基本数据类型，通过调用包装类xxxValue（）方法
Integer i2 = new Integer(12);
int num2 = i2.intValue();
}
/**
* jdk5.0 新特性：自动装箱和自动拆箱
*/
@Test
public void test1(){
int num1 = 10;
// 基本数据类型转成包装类 --自动装箱
Integer i1 = num1;
// 包装类转成基本数据类型
Integer i2 = 30;
int num2 = i2;// 自动拆箱
}
// 基本数据类型、包装类->String之间的类型转换
@Test
public void test2(){
// 把整数转成String类型
int num = 10;
// 方式1
String str = num+"";
// 方式2 ：转成谁就去谁里面找方法，转成String就去String里面找方法
// 调用String的valueOf()方法
int num1 = 20;
String str1 = String.valueOf(num1);
}
// String类型->包装类、基本数据类型的转换:调用包装类parseXxx（String s)方法
@Test
public void test3(){
String str = "123";// 必须是数字
// 把String转成Integer，Integer自动拆箱转成int
int num = Integer.parseInt(str);
double d = Double.parseDouble(str);
}
}
四、Date & DateFormat类
1.Date类可以获取当前系统时间，通过调用Date类的无参构造方法创建的对象可以获取本地当前的时间
- java.util.Date类：java.aql.Date类型（是java.util.Date的子类）
- java.aql.Date类型对应的是数据库的日期类型
2.SimpleDateFormat可用来实现日期的格式化
- public SimpleDateFormat(String pattern)：使用参数pattern指定的格式创建一个对象
- public String format(Date date)：按照构造方法中指定的pattern格式化时间对象date（根据定义的时间格式把日期对象转成一个字符串）
3.parse()：可以把一个时间类型的字符串转成一个date对象
public class DateTest {
@Test
public void test(){
// 获取当前系统时间,java.sql用于映射和数据库相关的时间段，如果和数据库无关，用Java.util
Date date = new Date();
System.out.println(date);
// 用SimpleDateFormat实现日期的格式化
// format:根据定义的时间格式把日期对象转成一个字符串
SimpleDateFormat sdf = new SimpleDateFormat();// 自带的格式
String date1 = sdf.format(date);
System.out.println(date1);
// 可以自定义时间格式
// yyyy-MM-dd HH:mm:ss 年-月-日 时：分：秒
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date2 = sdf1.format(date);
System.out.println(date2);
// 把日期字符串转成date
// parse():可以把一个时间类型的字符串转成一个date对象
try {
// 因为不知道输入的字符串是否是时间格式的，所以要加异常处理
Date date4 = sdf1.parse("2021-02-06 15:34:00");
System.out.println(date4);
} catch (ParseException e) {
e.printStackTrace();
}
}
}
五、日历类
Calender是一个抽象基类，主要用于完成日期字段之间相互操作的功能
1.获取Calendar实例的方法
- 方法1：使用Calendar.getInstance()方法
- 方法2：调用它的子类GregorianCalendar的构造器
2 常用方法
-
一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来获得想要的时间信息
-
set(int field,int amount)：设置系统的时间
-
add()：在原有天数的基础上增加或减少
public class TestCalendar {
@Test
public void test(){
Calendar calendar = Calendar.getInstance();// 创建了一个日历对象
// get()方法
// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月 返回的是 0-11 月
int month = calendar.get(Calendar.MARCH) + 1;
// 获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);// 获取这个月的第几天
// 获取时
int hour = calendar.get(Calendar.HOUR_OF_DAY);
// 获取分
int minute = calendar.get(Calendar.MINUTE);
// 获取秒
int se = calendar.get(Calendar.SECOND);
// 获取星期
System.out.println(year+"-"+month+"-"+day+" "+hour+":"+minute+":"+se);
// set():设置
System.out.println(Calendar.DAY_OF_MONTH);// 本月的第几天
// 获取本月的天数，把本月的天数改成8
calendar.set(Calendar.DAY_OF_MONTH,8);
int day1 = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(day1);
// add()：在原有天数的基础上增加或减少
calendar.add(Calendar.DAY_OF_MONTH,2);
day1 = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(day1);
}
}
六、jdk8.0新增的时间类（获取当前时间用的最多的）
1.LocalDate：日期类
2.LocalTime：时间类
3.LocalDateTime：日期和时间类（常用）
4.now()获取当前日期，时间信息
5.getxxx():获取相关的属性
6.DateTimeFormatter（针对于LocalDate类）：日期格式化，相当于SimpleDateFormat（针对于Date类）
public class LocalDateTest {
@Test
public void test(){
// now()获取当前日期，时间，日期+时间
LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDate);
System.out.println(localTime);
System.out.println(localDateTime);
// getxxx():获取相关的属性
System.out.println(localDateTime.getDayOfMonth());// 获取当月的第几天
System.out.println(localDateTime.getDayOfWeek());// 获取周几
System.out.println(localDateTime.getMonth());// 获取月份
System.out.println(localDateTime.getMonthValue());
System.out.println(localDateTime.getMinute());
// DateTimeFormatter（针对于LocalDate类）日期格式化，相当于SimpleDateFormat（针对于Date类）
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 格式化
String str = dateTimeFormatter.format(localDateTime);
System.out.println(str);
// 把一个时间类型的字符串转成时间格式，了解
TemporalAccessor accessor = dateTimeFormatter.parse("2021-02-06 16:15:38");
System.out.println(accessor);
}
}