Java常用类

内部类

一、内部类的分类

二、什么是内部类

三、成员内部类

成员内部类不能定义静态成员，但是可以定义静态常量：

public static final String country = "中国"

四、静态内部类

静态内部类：

public class Outer {
	private String name = "xxx";
	private int age = 18;
	
	//静态内部类：和外部类相同
	static calss Inner{
		private String address ="上海";
		private String phone = "111";
			
		//静态成员
		private static int count = 1000;
		public void show() {
			//调用外部类的属性
			//1、先创建外部类的对象
			Outer outer = new Outer();
			//2、调用外部类对象的属性
			System.out.println(outer.name);
        	System.out.println(outer.age);
        	//调用静态内部类的属性和方法
        	System.out.println(address);
        	System.out.println(phone);
        	//调用静态内部类的静态属性
        	System.out.println(Inner.count);
		}
	}
}

测试类

public class TestOuter{
	public static void main(String[] args){
		//直接创建静态内部类对象
		Outer.Inner inner = new Outer.Inner();
		//调用方法
		inner.show();
	}
}

四、局部内部类

局部内部类

public class Outer {
    private String name = "李欢";
    private int age = 12;

    public void show(){
        //定义局部变量
        String address = "深圳";
        //局部内部类：不能加任何访问修饰符
        class Inner {
            private String phone="123123123";
            private String email="123@.asd.com";

            public void show2(){
                //访问外部类的属性
                //不能写静态资源，但可以写静态常量 public static final String country = "中国"
                System.out.println(Outer.this.name);
                System.out.println(age);
                //访问内部类的属性
                System.out.println(phone);
                System.out.println(email);
				//访问局部变量,jdk1.7要求：变量必须是常量final,jdk1.8自动添加final
				System.out.println(address);
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

测试类

public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

五、匿名内部类

匿名内部类其实是有类名的，可以在生成的class文件中查看到

接口

public interface Usb {
    //服务方法
    void service();
}

使用接口的类

public class Mouse implements Usb{
    @Override
    public void service() {
        System.out.println("鼠标链接成功，可以使用...");
    }
}

测试类

public class TestUsb {
    public static void main(String[] args) {
        //Usb usb = new Mouse();
        //usb.service();


        局部内部类
        //class Fan implements Usb{
        //    @Override
        //    public void service() {
        //        System.out.println("链接风扇成功，风扇开始工作...");
        //    }
        //}
        使用局部内部类创建对象
        //Usb usb1 = new Fan();
        //usb1.service();


        //使用匿名内部类优化（相当于创建了一个局部内部类）
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("链接风扇成功，风扇开始工作...");
            }
        };
        usb.service();

    }
}

Object类

Java1.8API中文文档

- 公共Student类

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

一、getClass()方法

返回此 Object的运行时类。

- 实例：

测试类

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 12);
        Student s2 = new Student("bbb", 11);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2是同一种类型");
        } else {
            System.out.println("s1和s2不是同一种类型");
        }
    }
}

二、hashCode()方法

返回对象的哈希码值。

- 实例：

测试类

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 12);
        Student s2 = new Student("bbb", 11);

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

三、toString()方法

返回对象的字符串表示形式。

- 实例：

测试类

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 12);
        Student s2 = new Student("bbb", 11);

        System.out.println("--------------toString方法-------------");
        System.out.println(s1.toString());//qf.demo03.Student@4554617c
        System.out.println(s2.toString());//qf.demo03.Student@74a14482
    }
}

四、equals()方法

指示一些其他对象是否等于此。

- 实例：

测试类

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 12);
        Student s2 = new Student("bbb", 11);

        //4.equals方法
        System.out.println("--------------equals方法-------------");
        System.out.println(s1.equals(s2));//false
        Student s4 = new Student("小明",17);
        Student s5 = new Student("小明",17);
        System.out.println(s4.equals(s5));//false
    }
}

- equals()方法覆盖步骤

Student类

public class Student {
    private String name;
    private int age;
   	...
   	代码省略
   	...
    @Override
    public boolean equals(Object obj) {
        //判断两个对象是否是同一个引用
        if(this == obj) {
            return true;
        }
        //判断obj是否为空
        if(obj == null){
            return false;
        }
        //判断是否是同一类型
        //instanceof可以判断对象是否是某种类型
        if(obj instanceof Student){
            //强制类型转换
            Student s =(Student)obj;
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }

        return false;
    }
}

测试类

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 12);
        Student s2 = new Student("bbb", 11);

        //4.equals方法
        System.out.println("--------------equals方法-------------");
        System.out.println(s1.equals(s2));//false
        Student s4 = new Student("小明",17);
        Student s5 = new Student("小明",17);
        System.out.println(s4.equals(s5));//true
    }
}

五、finalize()方法

当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。

- 重写finalize()方法

Student类

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

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

测试类

public class TeatStudent01 {
    public static void main(String[] args) {
        //Student aaa = new Student("aaa", 12);
        //Student bbb = new Student("bbb", 12);
        //Student ccc = new Student("ccc", 12);
        //Student ddd = new Student("ddd", 12);
        new Student("aaa", 12);
        new Student("bbb", 12);
        new Student("ccc", 12);
        new Student("ddd", 12);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}

回收垃圾
ddd对象被回收了
ccc对象被回收了
bbb对象被回收了
aaa对象被回收了

包装类

一、什么是包装类

二、包装类对应

三、类型转换与装箱、拆箱

1. 装箱、拆箱

- 引用类型转基本类型（拆箱）

- 装箱和拆箱

public class Demo01 {
    public static void main(String[] args) {
        //int num = 10;

        /*jdk1.5之前*/
        //类型转换：装箱。基本类型转换成引用类型的过程
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);

        //类型转换：拆箱。引用类型转换为基本累心
        Integer integer3 = new Integer(100);
        int num3 = integer3.intValue();

        /*jdk1.5之后，提供了自动装箱和拆箱*/
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        //自动拆箱
        int age2 = integer4;

    }
}

2. 基本类型和字符串之间转换

public class Demo01 {
    public static void main(String[] args) {

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

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

boolean字符串形式转成基本类型，“true”–>true，非“true”–>false

	String str2="ture";
    boolean b1=Boolean.parseBoolean(str2);
    System.out.println(b1);

四、整数缓冲区

public class Demo02 {
    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);//自动装箱Integer.valueOf
        System.out.println(integer3==integer4);//true
		
		/*-128到127*/
        Integer integer5=Integer.valueOf(200);//自动装箱Integer.valueOf
        Integer integer6=Integer.valueOf(200);//自动装箱Integer.valueOf
        System.out.println(integer5==integer6);//false
    }
}

String类

一、字符串存储

1、创建后不可改变

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

2、字符串共享

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

2、创建方法

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

        //另一种创建字符串的方法new String
        String str=new String("Java");
        String str1=new String("Java");
        System.out.println(str = str1);//false;比的是地址
        System.out.println(str.equals(str1));//true;比的是字符串
    }
}

二、常用方法

补充方法：
equals();比较是否相等
equalsIgnoreCase();比较是否相等并忽略大小写
compareTo();比较大小或位数
substring();字符串截取

常用方法：

// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串

String content = "java是最好的语言, java no1";
sout(content.length()); // 10
sout(content.charAt(content.length() - 1)); // 言
sout(content.contains("java")); // true

// 4. toCharArray(); 返回字符串对应数组 
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置

sout(content.toCharArray());
sout(content.indexOf"java")); // 0
sout(content.indexOf("java", 4)); // 从索引4开始找 返回12
sout(content.lastIndexOf("java")); // 12

// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str);  判断是否以str 结尾、开头

String ct = " hello world ";
sout(ct.trim()); // "hello world"
sout(ct.toUpperCase()); // HELLO WORLD
sout(ct.toLowerCase()); // hello world
sout(ct.endWith("world")); // true
sout(ct.startWith("hello")) // true
  
// 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分

sout(content.replace("java", "php")); // php是最好的语言, php no1

String say = "java is the best language";
String[] arr = arr.say.split(" "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
sout(arr.length); // 5
for(String string : arr){
  sout(string);
}
// 打印出 
//java
//is
//the 
//best
//language

// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
sout(s1.equalsIgnoreCase(s2));// 忽略大小写比较true

// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值

案例：

public class Demo04 {
    public static void main(String[] args) {
        String str = "this is a text";
        //1.将str中的单词单独获取出来
        String[] arr = str.split(" ");
        System.out.println("========将str中的单词单独获取出来========");
        for (String s : arr) {
            System.out.println(s);
        }

        //2.将str中的text替换成practice
        String s = str.replace("text","practice");
        System.out.println("========将str中的text替换成practice========");
        System.out.println(s);

        //3.在text前面插入一个easy
        String s1 = str.replace("text", "easy text");
        System.out.println("========在text前面插入一个easy========");
        System.out.println(s1);

        //4.将每个单的首字母改为大写
        System.out.println("========将每个单的首字母改为大写========");
        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);
        }

    }
}

可变字符串

一、StringBuffer类

- 实例：

public class Demo05 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //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珍惜
        //2. insert();添加
        sb.insert(0, "前面");
        System.out.println(sb.toString());//前面java第一java珍惜
        //3. replace();替换
        sb.replace(0,2,"hello");
        System.out.println(sb.toString());//hellojava第一java珍惜
        //4. delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());//java第一java珍惜
    }
}

二、StringBuilder类

- 实例：

用法和StringBuffer相同

BigDecimal类

一、问题

很多实际应用中需要精确运算，而double是近似值存储，不再符合要求，需要借助BigDecimal。

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

二、使用

- 实例：

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

        //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 r4 = bd1.divide(bd2,2,BigDecimal.ROUND_HALF_UP);//除不尽四舍五入
        System.out.println(r4);

    }
}

注意：除法

Date类

public class Demo07 {
    public static void main(String[] args) {
        //1.创建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());//昨天的时间
        //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=date1.compareTo(date2);
        System.out.println(d);//1

    }
}

Calendar类

public class Demo08 {
    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);
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"/"+(month+1)+"/"+day+"  "+hour+":"+minute+":"+second);//2021/7/21  17:18:31

        //3.修改时间
        Calendar calendar1=Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(calendar1.getTime().toLocaleString());//2021-7-5 17:18:31

        //4.add方法修改时间
        calendar1.add(Calendar.HOUR,-1);
        System.out.println(calendar1.getTime().toLocaleString());//2021-7-5 16:18:31

        //5.补充方法
        int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);//31
        System.out.println(min);//1
    }
}

SimpleDateFormat类

public class Demo09 {
    public static void main(String[] args) throws Exception {
        //1.创建SimpleDateFormat对象
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2.创建Date
        Date date=new Date();
        //格式化date
        String str = sdf.format(date);
        System.out.println(str);//2021年07月22日 08:39:56

        //解析（把字符串转成日期）
        Date date1 = sdf.parse("1990/05/01");
        System.out.println(date1);// Tue May 01 00:00:00 CDT 1990
    }
}

System类

public class Demo10 {
    public static void main(String[] args) {
        //1.System.arraycopy()复制数组
        //arraycopy;数组的复制
        //src:原数组
        //srcPos:从哪个位置开始复制0
        //dest:目标数组
        //destPos:目标数组的位置
        //length:复制长度
        int[] arr={1,2,3,4,5,6,6,2};
        int[] dest=new int[8];
        System.arraycopy(arr,4,dest,0,4);
        for (int i = 0; i <dest.length ; i++) {
            System.out.println(dest[i]);
        }

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

        //3. System.gc();垃圾回收
        new Student("aaa",1);
        new Student("bbb",1);
        new Student("ccc",1);
        System.gc();

        //4. System.exit(0);退出jvm
        System.exit(0);
        System.out.println("程序结束了");//不会执行
    }
}

重写垃圾回收

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    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
    protected void finalize() throws Throwable {
        System.out.println("回收了"+name+"   "+age);
    }
}

总结：