java常用类

1. 内部类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

什么是内部类？
在一个类的内部再定义一个完整的类。
特点：
·编译之后可生成独立的字节码文件。
·内部类可直接访问外部类的私有成员，而不破坏封装。
·可为外部类提供必要的内部功能组件。

1.1 成员内部类

·在类的内部定义，与实例变量、实例方法同级别的类。
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

Outer out = new Outer();
Inner in = out.new Inner();

·当外部类、内部类存在重名属性时，会优先访问内部类属性。
访问重名的外部类属性

//打印外部类的属性
System.out.println(Outer.this.name);

成员内部类不能定义静态成员。但是可以包含静态常量

1.2 静态内部类

只有内部类才能用static修饰
成员内部类加static。
静态内部类的级别和外部类相同。
可以包含静态成员

1.3 局部内部类

定义在 方法里面的，前面不能加任何访问修饰符
定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。

·局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
·限制类的使用范围。

//访问外部类的属性
System.out.println(Outer.this.name)

1.4 匿名内部类

·没有类名的局部内部类（一切特征都与局部内部类相同）。
·必须继承一个父类或者实现一个接口。
·定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
·优点：减少代码量。
·缺点：可读性较差。

如果局部内部类只用一次的话，可以将局部内部类优化为匿名内部类

2. Object类

·超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
·任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
·Object类中所定义的方法，是所有对象都具备的方法。

·Object类型可以存储任何对象。

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

2.1 getClass方法

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

创建student类，添加构造方法，添加有参构造方法，添加get，set方法。

package commonClass.ObjectClass;

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

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

创建测试类，使用getclass方法判读是否为同一个类。

package commonClass.ObjectClass;

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbbb", 24);
        // 判断s1 s2，是不是同一个内型？
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 == class2){
            System.out.println("s1 s2属于同一个类型");
        }else{
            System.out.println("s1 s2不属于同一个类型");
        }
    }
}

2.2 hashCode方法

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

在栈里面不同位置的s1，s3 都指向了堆里面的相同位置

2.3 toString()方法

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


在student类下重写toString方法

2.4 equals()方法

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

equals()方法覆盖步骤

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

 //重写equals方法
    @Override
    public boolean equals(Object obj) {
        // 1. 判断两个对象是不是同一个引用
        if( this == obj){
            return true;
        }
        // 2. 判断obj是否为空？
        if(obj == null){
            return false;
        }
        // 3. 判断是否是同一个类型
//        if (this.getClass() == obj.getClass()){
//
//        }
        // instanceof 判断对象是否是某种类型
        // 因为instanceof比较的其实是其前面对象的实际类型是不是后面对象实际类型的子类或同类，是的话返回true，不是为false，所以true的情况下可能有子类的情况出现 就需要强制转换为同类
        if(obj instanceof Student){
            // 4. 强制类型转换
            Student s = (Student) obj;
            // 5. 比较
            if (this.name.equals(s.getName()) && this.age == s.getAge()){
                return true;
            }
        }
        return false;
    }

2.5 finalize()方法

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

3. 包装类

将基本类型的值包装在对象中。也就是将栈里面的数据放在了堆中
·基本数据类型所对应的引用数据类型。
·0bject可统一所有数据，包装类的默认值是nul1。
基本类型没有属性方法，可以通过包装类来实现。

3.1 类型转换，与装箱、拆箱

Java从JDK1.5开始，便引入了自动装箱和拆箱的机制。
装箱 ： 将栈里面的数据拿到堆里面
拆箱： 将引用类型转换为基本类型。

        System.out.println("==================装箱===========================");
        // 装箱操作： 基本类型 转换成引用类型
        int num1 = 1820;  // 基本类型
        //使用Interger类创建对象
        Integer integer1 = new Integer(num1);  // 'Integer(int)' 已被弃用
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("==================拆箱===========================");
        // 拆箱操作：引用类型转换为基本类型
        Integer integer4 = new Integer(1000);  // 'Integer(int)' 已被弃用
        Integer integer3 = Integer.valueOf(1000);
        int num2 = integer3.intValue();

        // JDK 1.5 之后 自动装箱拆箱机制
        int age = 30;
        // 自动装箱
        Integer integer5 = age;
        // 自动拆箱
        int age2 = integer5;

·8种包装类提供不同类型间的转换方式：
·Number父类中提供的6个共性方法。
・parseXXX()静态方法。
valueOff()静态方法。

        // 基本类型和字符串之间的转换
        // 基本类型 ----》 字符串
        int n1 = 255;
        // 1.1 使用+号
        String a1 = n1 + "";
        // 1.2 使用Integer中的toString方法
        String a2 = Integer.toString(n1);
        //    toString的重载方法    radix 几进制
        String a3 = Integer.toString(n1, 16);
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
            // 字符串----》 基本类型
        String str = "150";
        // 使用Integer.parseXXX（str)
        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);

3.2 Integer缓冲区

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

        Integer integer6 = Integer.valueOf(100);
        Integer integer7 = Integer.valueOf(100);
        System.out.println(integer6 == integer7); // true

-128~127之间的数会自动装箱，（就是需要转换为引用类型的数会优先查找匹配堆中的-128到127的地址）
调用valueOf(int)静态方法会总会缓存-128到127之间的值

深入剖析Java中的装箱和拆箱

4. String概述

·字符串是常量，创建之后不可改变。
·字符串字面值存储在字符串池中，可以共享。

package commonClass.stringClass;

public class StringClass {
    public static void main(String[] args) {
        String name = "Hello."; //hello常量 存储在字符串池当中
        name = "zhangfen"; // 把zhangfen赋值给name，给字符串赋值时，并没有修改数据，而是重新开辟空间
        String name =  "zhangfen"
    }
}

Strings="Hello"；产生一个对象，字符串池中存储。
String s=new String(“Hello”）；产生两个对象，堆、池各存储一个。堆里并没有这个对象，实际指向的是池里的。

equals在Object类中比的是地址，但是SUN公司在String类中重写了equals，重写为比较值，基本Sun公司在每一个类里都重写了equals

4.1 String常用方法

public int length():返回字符串的长度。
public char charAt(int index)：根据下标获取字符。
public boolean contains(String str)：判断当前字符串中是否包含str。
public char[]toCharArray(）：将字符串转换成数组。
public int indexOf(String str)：查找str首次出现的下标,存在，则返回该下标；不存在，则返回-1。
public int 1astIndexOf(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做拆分。

String[] arr1 = content2.split("[, ]+"); // 中括号里面的字符都可以用于拆分，再加个+表示 可以多个字符拆分
        System.out.println(arr1.length);
        for (String s : arr1) {
            System.out.println(s);
        }

package commonClass.stringClass;

import java.util.Arrays;

public class StringMethoc {
    public static void main(String[] args) {
        //字符串方法的使用
        // 1. length（） 返回字符串长度
        // 2. charAt（int index）  返回某个位置的字符
        // 3. contains（String str） 判断是否包含了某个字符串

        String content = "java是世界上最好的java编程语言,java真香";
        System.out.println(content.length());
        System.out.println(content.charAt(4));
        System.out.println(content.contains("语言"));
        //toCharArray(）：将字符串转换成数组。
        //indexOf(String str)：查找str首次出现的下标,存在，则返回该下标；不存在，则返回-1。
        // lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引。
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.toCharArray());
        System.out.println(content.indexOf("java"));
        System.out.println(content.indexOf("java",4));
        System.out.println(content.lastIndexOf("java"));
//       trim()：去掉字符串前后的空格。
//       toUpperCase():将小写转成大写。
//       endWith(String str):判断字符串是否以str结尾。
        String content1 = "              java真香       ";
        System.out.println(content1);
        System.out.println(content1.trim());
        System.out.println(content1.toUpperCase());
        System.out.println(content1.toLowerCase());
        System.out.println(content.endsWith("香"));
        System.out.println(content.startsWith("香"));

        //replace(char oldChar,char newChar)；将旧字符串替换成新字符串
        //split(String str):根据str做拆分。
        String content2 = "1,2,,5,4,5,,7,9,8 9";
        System.out.println(content2.replace(",","  "));
        System.out.println(content2.split(","));
        String[] arr = content2.split(",");
        System.out.println(arr.length);
        for (String s : arr) {
            System.out.println(s);
        }
        String[] arr1 = content2.split("[, ]+"); // 中括号里面的字符都可以用于拆分，再加个+表示 可以多个字符拆分
        System.out.println(arr1.length);
        for (String s : arr1) {
            System.out.println(s);
        }
    }

}

4.2 String类案例演示

System.out.println("=============================================================");
        String arr2 = "this is a text";

        // 1. 单词获取出来
        String[] arr3 = arr2.split(" ");
        for (String s : arr3) {
            System.out.println(s);
        }
        // 2. text 替换位 practice
        String arr4 = arr2.replace("text","practice");
        System.out.println(arr4);
        // 3. text前插入easy
        String arr5 = arr2.replace("text","easy text");
        System.out.println(arr5);
        // 4. 将每个单词的首字母变为大写
        for (int i = 0; i < arr3.length; i++) {
            char first = arr3[i].charAt(0);
            // 把第一个字符转为大写
            char upperfirst = Character.toUpperCase(first);
            String news = upperfirst+arr3[i].substring(1);
            System.out.println(news);

4.3 可变字符串

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

package commonClass.stringClass;

/**
 * StringBuffer 和 StringBuilder的使用
 * 和String的区别
 * 1. 效率比String高
 * 3. 比String节省内存1
 */
public class StringBufferBuilder {
    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,"java我要学");
        System.out.println(sb.toString());
        // 3. replace(); 替换 ，可以指定位置替换
        sb.replace(0,4,"python");
        System.out.println(sb.toString());
        // 4. delite();  删除
        sb.delete(0,4);
        System.out.println(sb.toString());
        // 5. 清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
    }
}

验证

package commonClass.stringClass;

/**
 * 验证StringBulider效率高于String
 */
public class VerifyStringBulider {
    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);   11370
        StringBuilder string = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            string.append(i);
        }
        long end = System.currentTimeMillis();  // 14
        System.out.println("用时：" + (end - start));
    }
}

5. BigDecmal的使用

package commonClass.stringClass;

public class TestBigDecimal {
    public static void main(String[] args) {
        double a = 1.0;
        double b = 0.9;
        System.out.println(a-b);
        // 面试题
        double c = (1.4-0.5)/0.9;
        System.out.println(c);
        // double float 存的是近似值
        
    }
}
"D:\Program Files\Java\jdk-11.0.11\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2021.1.2\lib\idea_rt.jar=55332:D:\Program Files\JetBrains\IntelliJ IDEA 2021.1.2\bin" -Dfile.encoding=UTF-8 -classpath E:\JAVA\javaSE\out\production\基础语法 commonClass.stringClass.TestBigDecimal
0.09999999999999998
0.9999999999999999

进程已结束，退出代码为 0

位置：java.math包中。
作用：精确计算浮点数。
创建方式：BigDecimal bd=new BigDecimal(“1.0”);

package commonClass.stringClass;

import java.math.BigDecimal;

public class TestBigDecimal {
    public static void main(String[] args) {
        // BigDecimal 大的浮点数的精确计算
        BigDecimal bd1 = new BigDecimal("1.0");   // 以字符串的形式输入
        BigDecimal bd2 = new BigDecimal("0.9");// 以字符串的形式输入
        // 类的减法不能使用运算符, 减法
        BigDecimal bd3 = bd1.subtract(bd2);
        // 加法
        BigDecimal bd4 = bd1.add(bd2);
        System.out.println(bd4);
        // 乘法
        BigDecimal bd5 = bd1.multiply(bd2);
        System.out.println(bd5);
        // 除法
        BigDecimal b1 =  new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(b1);
        // 保留小数还未实现
        BigDecimal b2 =  new BigDecimal("10").divide(new BigDecimal("3"));
        System.out.println(b2);



    }
}

6. Date类

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

package commonClass.stringClass;

import java.util.Date;

public class TestDate {
    public static void main(String[] args) {
        // 创建Date对象
        // 今天
        Date date1 = new Date();
        System.out.println(date1.toString());
        // 昨天
        Date date2 = new Date(date1.getTime()-60*60*24*1000);
        System.out.println(date2.toString());
        // 方法 after before
        boolean bi = date1.after(date2);
        System.out.println(bi);
        // 比较  compareTO()
        int d =date1.compareTo(date2);
        System.out.println(d);
        //
        System.out.println(date1.equals(date2));
    }
}

7. Calendar类

package commonClass.stringClass;

import java.util.Calendar;

public class TestCalendar {
    public static void main(String[] args) {
        // 创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        // 2. 获取时间信息
        // 获取年
        int year = calendar.get(Calendar.YEAR);
        System.out.println(year);
        // 获取月
        int month = calendar.get(Calendar.MONTH);
        System.out.println(month);
        // 日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        // 小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY); // hour 12小时  hourofday 24小时
        //分钟
        int minute = calendar.get((Calendar.MINUTE));
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);

        // 修改时间
        
    }
}

8. SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的
具体类。
进行格式化（日期-〉文本）、解析（文本-〉日期）。
常用的时间模式字母

9. System类

System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。

package commonClass.stringClass;

public class TestSystem {
    public static void main(String[] args) {
        //arraycopy: 实现数组的复制
        // src:复制源数组， srcPos: 从那个位置开始复制
        // dest： 目标数组   destPos：目标数组的位置
        // length： 需要复制的长度
        //System.arraycopy();
        int[] arr = {20,18,15,8,35,26,45,90};
        int[] dest = new int[8];
        System.arraycopy(arr, 4, dest, 4, 3);
        for (int i : dest) {
            System.out.println(i);
        }
        //可以实现计时操作
        long start =  System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            int j = i;
        }
        long end =  System.currentTimeMillis();
        System.out.println("用时：" + (end - start));

        // System.gc(); 告诉垃圾回收器，回收
        // 退出jvm
        System.exit(0);
        System.out.println("程序结束了");
    }
}