JAVA常用类

1. Object类

1.也叫超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
2.任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
3.Object类中所定义的方法，是所有对象都具备的方法。
4.Object类型可以存储任何对象。

• 作为参数，可接受任何对象。
• 作为返回值，可返回任何对象。

1.1 getClass()方法

public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用：通常用于判断两个引用中实际存储对象类型是否一致。

1.2 hashCode()方法

• public int hashCode(){}
• 返回该对象的哈希码值。
• 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
• 一般情况下相同对象返回相同哈希码。

1.3 toString()方法

• public String toString()(}
• 返回该对象的字符串表示（表现形式）。
• 可以根据程序需求覆盖该方法，如：展示对象各个属性值。

1.4 equals()方法

• public boolean equals(Object obj){}
• 默认实现为(this==obj)，比较两个对象地址是否相同。
• 可进行覆盖，比较两个对象的内容是否相同。

equals()方法覆盖步骤

• 比较两个引用是否指向同一个对象。
• 判断obj是否为null。
• 判断两个引用指向的实际对象类型是否一致。
• 强制类型转换。
• 依次比较各个属性值是否相同。

1.5 finalize()方法

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象。
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
• 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
• 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。

package com.hjb.common;

public class Student {
    private String name;
    private int age;
    public Student(){

    }
    //添加构造方法
    public Student(String name, int age) {
        super();
        this.name = name;
        this.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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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


    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");;
    }
}

package com.hjb.common;

public class TestStudent {
    public static void main(String[] args) {
        //1.getClass方法
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 22);

        //判断S1和S2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
        System.out.println("=====================================");

        //2.hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());

        System.out.println("=====================================");
        //3.toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());

        System.out.println("=====================================");
        //4.equals方法,判断两个对象是否相等
        System.out.println(s1.equals(s2));

        Student s4 = new Student("小明",17);
        Student s5 = new Student("小明",17);
        System.out.println(s4.equals(s5));

        System.out.println("=====================================");

    }
}

package com.hjb.common;

public class TestStudent2 {
    public static void main(String[] args) {
//        Student s1 = new Student("aaa", 20);
//        Student s2 = new Student("bbb", 20);
//        Student s3 = new Student("ccc", 20);
//        Student s4 = new Student("ddd", 20);
//        Student s5 = new Student("eee", 20);
        new Student("aaa", 20);
        new Student("bbb", 20);
        new Student("ccc", 20);
        new Student("ddd", 20);
        new Student("eee", 20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}

2. 包装类

• 基本数据类型所对应的引用数据类型。
• Object可统一所有数据，包装类的默认值是null。
  

2.1 类型转换，装箱和拆箱

package com.hjb.common.pack;

public class Demo01 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转换成引用类型
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println(integer1);
        System.out.println(integer2);
        System.out.println("===========================================");
        //类型转换：拆箱，引用类型转换成基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println(num2);
        System.out.println("===========================================");
        //JDK1.5之后，提供自动装箱和拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println(integer4);
        System.out.println("===========================================");
        //自动拆箱
        int age2 = integer4;
        System.out.println(age2);
    }
}

8种包装类提供不同类型间的转换方式：

• Number父类中提供的6个共性方法。
• parseXXX()静态方法。
• valueOf()静态方法。
  注意：需要保证类型兼容，否则抛出NumberFormatException异常

package com.hjb.common.pack;

public class Demo01 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转换成引用类型
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println(integer1);
        System.out.println(integer2);
        System.out.println("===========================================");
        //类型转换：拆箱，引用类型转换成基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println(num2);
        System.out.println("===========================================");
        //JDK1.5之后，提供自动装箱和拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println(integer4);
        System.out.println("===========================================");
        //自动拆箱
        int age2 = integer4;
        System.out.println(age2);

        System.out.println("===========================================");
        //基本类型和字符串之间转换
        //1.基本类型转换成字符串
        int n1 = 255;
        //1.1使用+号
        String s1 = n1+"";
        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(n1);
        String s3 = Integer.toString(n1,16);
        String s4 = Integer.toHexString(n1);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);

        System.out.println("===========================================");

        //2.字符串转换成基本类型
        String str = "150";
        //使用Integer.parseXXX();
        int n2 = Integer.parseInt(str);
        System.out.println(n2);

        //boolean字符串形式转成基本类型，"true"---->true   非"true"---->false
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);

    }
}

2.2 Integer缓冲区

Java预先创建了256个常用的整数包装类型对象。在实际应用当中，对已创建的对象进行复用。

package com.hjb.common.pack;

public class Demo02 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);


        Integer integer3 = 100;//自动装箱   用的Integer.valueOf(100)
        Integer integer4 = 100;
        System.out.println(integer3==integer4);


        Integer integer5 = 200;//自动装箱  因为200不在整数缓冲区，-128-127
        Integer integer6 = 200;
        System.out.println(integer5==integer6);
    }
}

3. String类

字符串是常量，创建之后不可改变。
字符串字面值存储在字符串池中，可以共享。
String s = “Hello”，产生一个对象，字符串池中存储。
String s = new String(“Hello”)，产生两个对象，堆、池各存储一个。

package com.hjb.common.pack;

public class Demo03 {
    public static void main(String[] args) {
        String name = "Hello"; // "Hello"常量存储在字符串池中
        name = "zhangsan";//"张三"赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间。
        String name2 = "zhangsan";


        //字符串的另一种创建方式   new String
        String str = new String("java是最好的语言");
        String str2 = new String("java是最好的语言");
        System.out.println(str==str2);//比较的是地址
        System.out.println(str.equals(str2));//比较的是数据

    }
}

3.1 String类常用方法

public int length():返回字符串的长度
public char charAt(int index):根据下标获取字符
public boolean contains(String str):判断当前字符串中是否包含str
public char[] toCharArrray():将字符串转换成数组
public int indexOf(String str):查找str首次出现的下标，存在则返回该下标；不存在则返回-1
public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引
public String trim():去掉字符串前后的空格
public String toUpperCase():将小写转换成大写
public boolean endWith(String str):判断字符串是否以str结尾
public String replace(char oldChar,char newChar):将旧字符串替换成新字符串
public String[] split(String str):根据str做拆分

package com.hjb.common.pack;

import javax.tools.JavaCompiler;
import java.util.Arrays;
import java.util.Locale;

public class Demo03 {
    public static void main(String[] args) {
        String name = "Hello"; // "Hello"常量存储在字符串池中
        name = "zhangsan";//"张三"赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间。
        String name2 = "zhangsan";


        //字符串的另一种创建方式   new String
        String str = new String("java是最好的语言");
        String str2 = new String("java是最好的语言");
        System.out.println(str==str2);//比较的是地址
        System.out.println(str.equals(str2));//比较的是数据

        System.out.println("========================================================");
        //字符串方法的使用
        //length();返回字符串的长度
        //charAt(int index);返回某个位置的字符
        //contains(String str):判断当前字符串中是否包含某个子字符串

        String content = "Java是世界上最好的编程语言";
        System.out.println(content.length());
        System.out.println(content.charAt(0));
        System.out.println(content.charAt(content.length()-1));
        System.out.println(content.contains("Java"));
        System.out.println(content.contains("php"));

        //toCharArray();返回字符串对应的数组
        //indexOf();返回字符串首次出现的位置
        //lastIndexOf();返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("Java"));
        System.out.println(content.lastIndexOf("Java"));

        //public String trim():去掉字符串前后的空格
        //public String toUpperCase():将小写转换成大写
        //public boolean endWith(String str):判断字符串是否以str结尾, startWith()
        String content2 = "    hello world   ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase());
        System.out.println(content2.toLowerCase());
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));

        //public String replace(char oldChar,char newChar):将旧字符串替换成新字符串
        //public String[] split(String str):根据str做拆分
        System.out.println(content.replace("Java","php"));

        String say = "java is the best programing language";
        String[] array = say.split(" ");
        System.out.println(array.length);
        for (String string : array){
            System.out.println(string);
        }

        //补充方法equals、compare();比较大小
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));
        System.out.println(s1.compareTo(s2));

        String s3 = "abc";
        String s4 = "abcxyz";
        System.out.println(s3.compareTo(s4));
        
    }
}

3.2 案例演示

package com.hjb.common.pack;

public class Demo04 {
    public static void main(String[] args) {
        String str = "this is a text";
        //1.单词单独获取出来
        String[] arr = str.split(" ");
        for (String string : arr){
            System.out.println(string);
        }
        //2.将text替换成practice
        String str2 = str.replace("text", "practice");
        System.out.println(str2);

        //3.将text前加easy
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);

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

3.3 可变字符串

StringBuffer:可变长字符串，JDK1.0提供，运行效率慢，线程安全
StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全

package com.hjb.common.pack;

public class Demo05 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //1.append追加
        sb.append("java世界第一");
        System.out.println(sb.toString());
        sb.append("java真香");
        System.out.println(sb.toString());

        //2.insert添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());

        //3.replace替换
        sb.replace(0,5,"hello");
        System.out.println(sb.toString());

        //4.delete删除
        sb.delete(0,5);
        System.out.println(sb.toString());
        sb.delete(0,sb.length());
        System.out.println(sb.toString());
    }
}

package com.hjb.common.pack;

public class Demo06 {
    public static void main(String[] args) {
        //1.验证StringBuilder效率高于String
        long start = System.currentTimeMillis();
//        String string = "";
//        for (int i = 0; i < 99999; i++) {
//            string+=i;
//        }
//        System.out.println(string);


        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
           sb.append(i);
        }
        System.out.println(sb.toString());
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));
    }
}

4. BigDecimal

很多实际应用需要精确的计算，而double是近似值存储，不符合要求，需要借助BigDecimal
位置：java.math包中。
作用：精确计算浮点数。
创建方式：BigDecimalbd=newBigDecimal(“1.0”)；
参数scal：指定精确到小数点后几位。
参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式，取值为BigDecimal.ROUNDHALF_UP。

package com.hjb.common.pack;

import java.math.BigDecimal;

public class Demo07 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);

        //BigDecimal,大的浮点数的精确计算
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");

        //减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);

        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);

        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);

        //除法
        BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);
        System.out.println(r5);
    }
}

5. Date

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
时间单位：1秒=1000毫秒，1毫秒=1000微秒，1微秒=1000纳秒

package com.hjb.common.pack;

import java.util.Date;

public class Demo08 {
    public static void main(String[] args) {
        //创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        //昨天
        Date date2 = new Date(date1.getTime()-60*60*24*1000);
        System.out.println(date2.toLocaleString());

        //方法after和before
        boolean b1 = date1.after(date2);
        System.out.println(b1);
        boolean b2 = date1.before(date2);
        System.out.println(b2);

        //比较compareTo()
        int d = date1.compareTo(date2);
        System.out.println(d);
        
        //比较是否相等equals
        boolean b3 = date1.equals(date2);
        System.out.println(b3);
    }
}

6. Calendar

Calendar提供了获取或设置各种日历字段的方法。
构造方法
protectedCalendar()：由于修饰符是protected，所以无法直接创建该对象。
其他方法
方法名和说明
static Calendar getlnstance() 使用默认时区和区域获取日历
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 getTimelnMillies() 毫秒为单位返回该日历的时间值

package com.hjb.common.pack;

import java.util.Calendar;

public class Demo09 {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());

        //获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //获取月
        int month = calendar.get(Calendar.MONTH);
        //获取日
        int day1 = calendar.get(Calendar.DATE);
        int day2 = calendar.get(Calendar.DAY_OF_MONTH);
        //获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR_OF_DAY是24小时，HOUR是12小时
        //获取分钟
        int minute = calendar.get(Calendar.MINUTE);
        //获取秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year + "年" + (month + 1) + "月" + day1 + "日" + hour + ":" + minute + ":" + second);
        //修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH, 22);
        System.out.println(calendar2.getTime().toLocaleString());
        //add修改时间
        calendar2.add(Calendar.HOUR, 1);
        System.out.println(calendar2.getTime().toLocaleString());
        //补充方法，获取当前时间的最大最小值
        int maximum = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int minimum = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(maximum);
        System.out.println(minimum);
    }
}

7. SampleDateFormat

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。

• 进行格式化（日期->文本）、解析（文本->日期）。
• 常用的时间模式字母：y,M,d,H,m,s,S

package com.hjb.common.pack;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo10 {
    public static void main(String[] args) throws Exception {
        //创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //创建Date
        Date date = new Date();
        //格式化date,日期转成字符串
        String string = sdf.format(date);
        System.out.println(string);

        //解析,字符串转成日期
        Date date2 = sdf.parse("1990/05/01");
        System.out.println(date2);
    }
}

8. System类

System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。
方法名和说明
static void arraycopy(…)复制数组
static long currentTimeMillis();获取当前系统时间，返回的是毫秒值
static void gc();建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status);退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm。

package com.hjb.common.pack;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.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;
    }

    public Student(){
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("回收了  " +name+ "  "+ age);
    }
}

package com.hjb.common.pack;

public class Demo11 {
    public static void main(String[] args) {
        //arraycopy数组复制
        //src：源数组
        //srcPos:从哪个位置开始复制
        //dest：目标数组
        //destPos：目标数组的位置
        //length:复制的长度
        int[] arr = {20,28,25,8,35,26,45,90};
        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]);

        }
        //Array.copyOf(Original,newLength)

        System.out.println(System.currentTimeMillis());
        
        long start = System.currentTimeMillis();
        for (int i = 0; i < 99999999; i++) {
            for (int j = 0; j < 9999999; j++) {
                int result = i+j;
            }
        }
        //获取时间
        long end = System.currentTimeMillis();
        System.out.println(end-start);


        //回收器回收垃圾
        new Student("aaa",19);
        new Student("bbb",19);
        new Student("ccc",19);
        System.gc();//告诉垃圾回收器回收垃圾


        //退出jvm
        System.exit(0);
        System.out.println("程序结束了");

    }
}