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);
    }
}