【JavaSE】之Java常用类

港控/mmm° 2024-04-03 10:01 72阅读 0赞

#### 【JavaSE】Java常用类 ####

*  前言
 *  一、内部类
 *   *  1.分类
     *  2.成员内部类
     *  3.静态内部类
     *  4.局部内部类
     *  5.匿名内部类
 *  二、Object类
 *  三、包装类
 *  四、字符串
 *  五、可变字符串
 *  六、BigDecimal
 *  七、Date
 *  八、日历类
 *  九、SimpleDateFormat
 *  十、System类的常见方法
 *  后记

--------------------

## 前言 ##

本文为Java常用类详细介绍，**Java全栈学习路线可参考：**[【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引][Java_Java_Java]，内含最全Java全栈学习技术清单~

## 一、内部类 ##

*  定义在类的内部的类叫做内部类。
 *  内部类的作用一般是用来封装在类的内部使用的类，不希望外部被其他类所使用。

### 1.分类 ###

*  成员内部类：直接在类的内部定义的类
 *  静态内部类：直接在类的内部定义的前面加上static关键字的类
 *  局部内部类：在方法中定义的类
 *  匿名内部类：没有类的名称，只使用一次的类

### 2.成员内部类 ###

*  使用方式等同于成员变量的使用方式

public class A {
        
        int i = 3;
        public class B{
        
            public String n;
        }
        public void m() {
        
            B b = new B();
        }
    }
    
    public class Test {
        
        public static void main(String[] args) {
        
            A a = new A();
            a.i = 3;
            A.B b = new A().new B();
            b.n = "Hello";
            System.out.println(b.n);
        }
    }

*  成员内部类与外部类的相互调用
 *  内部类不能定义静态属性，但是可以定义静态常量，需要直接赋值

public class A {
        
        int i = 3;
        // 在外部类可以创建对象调用内部类
        public void m() {
        
            B c = new B();
            System.out.println(i);
            System.out.println(c.n);
            c.b();
        }
        public class B{
        
            public String n;
            int i = 5;
            // 内部类可以直接调用外部类
            public void b() {
        
                System.out.println(n);
                System.out.println(i); // 调用当前类的i属性
                System.out.println(A.this.i);  // 如果属性名称相同，调用外部的i属性
    //            m();
            }
        }
    }

### 3.静态内部类 ###

*  在类的内部定义的使用static修饰的类
 *  注意：静态内部类中无法访问外部类的实例相关的内容

public class StaticA {
        
        public static String count;
        public String a;
        public static class StaticB{
        
            public String name;
            public static int i;
            public void m() {
        
    //            System.out.println(StaticA.this.a); // 无法访问外部类的成员
                System.out.println(count);
            }
            public static void sm() {
        
                System.out.println(count);
            }
        }
    }
    public static void main(String[] args) {
        
        StaticA.count = "5";
        StaticA.StaticB staticB =  new StaticA.StaticB(); // 使用外部类的类名来引用内部类的构造方法
    }

### 4.局部内部类 ###

*  在一个方法中定义的类，只能在该方法中创建对象并使用

public class C {
        
        public String name = "aaa";
        public void m1() {
        
            class D{
         // 局部内部类的使用
                int n = 5;
                public void d() {
        
                    System.out.println(n);
                    System.out.println(name);
                }
            }
            D d = new D(); // 创建对象
            d.n = 10;
            d.d();
        }
        public void m2() {
        
        }
    }

### 5.匿名内部类 ###

*  一般是将接口使用new关键字在创建对象时进行一个匿名实现
 *  作用：在项目中，有些类只需要创建一个对象，此时可以使用匿名内部类。（单例模式最好的解决方法就是使用此方案<内部类的方式>）

public interface MyInter {
        
        void method();
        void m1();
    }
    public static void main(String[] args) {
        
        MyInter m = new MyInter() {
        
            @Override
            public void method() {
        
                System.out.println("method");
            }
            @Override
            public void m1() {
        
                System.out.println("m1");
            }
        };
        m.method();
    }

## 二、Object类 ##

Class Object是类Object结构的根。 每个类都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法  
**Object中的方法：**

*  clone()：克隆
 *  equals(Object obj)：比较
 *  getClass()：获得对象类型
 *  hashCode()：返回对象的哈希码值
 *  finalize()：垃圾回收
 *  toString()：返回对象的字符串表示形式
 *  notify()：唤醒正在等待对象监视器的单个线程
 *  notifyAll()：唤醒正在等待对象监视器的所有线程
 *  wait()：导致当前线程等待，直到另一个线程调用该对象的notify()或notifuAll()方法
 *  注意：其中equals()方法是比较内存地址的，若想比较值需要重写equals()方法!!!

**判断一个对象是否某个类型的两种方式：**

if(obj3 instanceof Cat) {
        
        System.out.println("obj3是cat类的对象");
    }
    if(obj2.getClass() == Dog.class) {
        
        System.out.println("obj2是dog类的对象");
    }

hashCode():通过对象的地址或者其他信息根据hash算法计算出来的一个数字，有利于对象在内存中的查找、排序、比较等。相同的对象应该保证其hashCode相同，不同的对象尽可能保证hashCode不同。  
toString()：默认显示当前对象类型和其hashCode，意义不大。一般情况下，在自定义的类中，需要对toString方法进行重写，以便在输出时能够输出更多的信息。

public class Animal {
        
        private String name;
        public String getName() {
        
            return name;
        }
        public void setName(String name) {
        
            this.name = name;
        }
        @Override
        public String toString() {
        
            return "Animal [name=" + name + "]";
        }
    }

equals方法用来比较对象是否相同的对象。不应该使用，因为比较是地址。由于在Object中equals方法是默认为用==比较，所以在实际项目中，应该重写equals方法，然而相同的对象应该有相同的hashCode，所以重写equals方法的同时也应该重写hashCode方法。

public class Animal {
        
        private String id;
        private String name;
        public String getId() {
        
            return id;
        }
        public void setId(String id) {
        
            this.id = id;
        }
        public String getName() {
        
            return name;
        }
        public void setName(String name) {
        
            this.name = name;
        }
        @Override
        public String toString() {
        
            return "Animal [name=" + name + "]";
        }
        @Override
        public boolean equals(Object obj) {
        
            if(obj == null) {
         // 对象是否为空
                return false;
            }
            if(this == obj) {
         // 是否同一个地址
                return true;
            }
            if(obj instanceof Animal) {
         // 是否同一个类型
                Animal a = (Animal)obj;
                if(a.id == null) {
        
                    return false;
                }
                if(this.id .equals(a.id) ) {
        
                    return true;
                }else {
        
                    return false;
                }
            }else {
        
                return false;
            }
        }
        @Override
        public int hashCode() {
        
            return id.hashCode();
        }
    }

## 三、包装类 ##

*  Java中基本数据类型对应的引用数据类型，叫包装类

public static void main(String[] args) {
        
        // JDK1.5之前的写法
        int i = 3;
        Integer in = new Integer(i); // 装箱
        Object obj = in;
        int i2 = in.intValue(); // 拆箱
        // JDK1.5之后，自动装箱拆箱
        Integer in1 = i; // 自动装箱
        int i3 = in1; // 自动拆箱
        Double d = 0.3;
        double db = d;
        // 将字符串转换成基本数据类型
        String s = "3";
        // 如果该字符串里面不是数字，将会出现NumberFormatException
        int n = Integer.valueOf(s); // parseInt()也行
        System.out.println(n);
        String s1 = "2.04";
        double db1 =  Double.parseDouble(s1);
        System.out.println(db1);
        // 如果该字符串中不是true(不区分大小写)，则返回false，不论如何不会报错
        String s2 = "TRue";
        boolean b = Boolean.parseBoolean(s2);
        System.out.println(b);
        // 对于char类型，直接使用charAt(index)
        String s3 = "ABCD";
        char c = s3.charAt(2);
        System.out.println(c);
        int m = 50;
        int m1 = 50;
        System.out.println(m == m1);
        // Integer常量池（缓冲区）
        // 在Integer中，最多会设置-128到127，一共256个常量
        // 在使用valueOf或者直接以数字的形式赋值时，会去常量池中查找，如果能找到，则返回该常量，否则或创建一个对象
        // 如果是常量池中的常量，使用再多次，也是用的同一个地址
        Integer in2 = 100;
        Integer in3 = 100;
        System.out.println(in2 == in3); // true
        Integer in4 = 200;
        Integer in5 = 200;
        System.out.println(in4 == in5); // false
        Integer in6 = new Integer(100);
        Integer in7 = new Integer(100);
        System.out.println(in6 == in7); // false
        Integer in8 = Integer.valueOf(100);
        Integer in9 = Integer.valueOf(100);
        System.out.println(in8 == in9); // true
        Integer in10 = Integer.valueOf(200);
        Integer in11 = Integer.valueOf(200);
        System.out.println(in10 == in11); // false
    }

## 四、字符串 ##

*  String对象创建后不可变，是指String内部使用一个final char\[\]来存放数据。所以值不能改变。
 *  String每次重新赋值相当于重新的创建了字符串。

String s = "hello";
    s = "world678";
    System.out.println(s);

*  字符串的两种赋值方式： String s = “hello”; String s1 = new String(“world”);
 *  字符串常量池，在内存中，会分配一块空间，里面存放字符串常量，当使用""来给字符串赋值时，会在常量创建该字符串，如果变量直接用等于接收，即变量中存储的是该常量的地址，而该常量可以复用，所以下面第一个表达式的值为true，即都指向常量池中的同一个区域。
 *  而如果通过new String来创建对象，会分配一个块新的空间，所以下面的第二个表达式值为false。

String s1 = "hello";
    String s2 = "hello";
    System.out.println(s1 == s2); // true
    String s3 = new String("hello");
    String s4 = new String("hello");
    System.out.println(s3 == s4); // false

*  字符串的常量优化：(编译期优化)
 *  如果字符串在编译时，能确定值，并且不会变化，则会进行优化，直接在编译时直接得到结果，而不会在运行时再计算。

String s5 = "ab";
    String s6 = "a" + "b";
    System.out.println(s5 == s6); // true
    String s7 = "a";
    String s8 = s7 + "b";
    System.out.println(s5 == s8); // false
    final String s9 = "a";
    String s10 = s9 + "b";
    System.out.println(s5 == s10); // true

*  字符串常用方法如下代码
 *  **注意：** 如果该方法是用来改变字符串，一定会返回一个新的字符串，因为字符串不能直接改变 。

public static void main(String[] args) {
        
        // 得到字符某个位置的字符
        String s = "hello";
        char ch = s.charAt(1); // 结果为e
        String s1 = "oh, hello, hello";
        boolean b = s1.contains(s); // 结果是true，s1字符串中包含s
        System.out.println(b);
        char [] arr = s1.toCharArray(); // 将字符串转换成char数组
        System.out.println(Arrays.toString(arr));
        int index = s1.indexOf(s); // 判断s1中是否包含s，如果包含则返回s第一次出现的下标，如果不包含，则返回-1
        System.out.println(index);
        // 注意：数组的长度为length属性，字符串是length方法
        System.out.println(s1.length()); // length方法返回字符串的长度
        String s2 = "       hello       ";
        System.out.println(s2);
        System.out.println(s2.length());
        String newS2 = s2.trim(); // 去掉字符串两边的空格
        System.out.println(newS2);
        System.out.println(newS2.length());
        String newS1 = s1.toUpperCase(); // 将字符串全部大写
        System.out.println(newS1);
        newS1 = newS1.toLowerCase(); // 将字符串全部小写
        System.out.println(newS1);
        boolean b1 = s1.startsWith("oh,"); // 判断字符串是否以xx开始
        System.out.println(b1);
        b1 = s1.endsWith("oh,"); // 判断字符串是否以xx结尾
        System.out.println(b1);
        String newS3 = s1.replace("h", "ooo"); // 将字符串中出现h全部替换成ooo
        System.out.println(newS3);
        String [] strArr = s1.split(","); // 将字符串根据,切割成一个字符串数组
        System.out.println(strArr.length);
        System.out.println(Arrays.toString(strArr));
        String s4 = "abcdefghijkllmn";
        String newS4 = s4.substring(3); // 从第三号位置开始截取，截取后面所有的字符串
        System.out.println(newS4);
        newS4 = s4.substring(3, 6); // 从第三号位置开始截取，截取到6号位置（不包含6号位置）
        System.out.println(newS4);
        byte [] bytes = s5.getBytes(); // 得到所有的字节形成的字节数组
        System.out.println(Arrays.toString(bytes));
    }

## 五、可变字符串 ##

*  可变字符串可以对字符串进行增删改操作，主要作用是当要大量的操作字符串的时候，应该使用可变字符串，以提升性能，节约空间。
 *  StringBuffer：JDK1.0提供，线程安全，效率低
 *  StringBuilder：JDK5.0提供，线程不安全，效率高

// 创建StringBuilder或StringBuffer
    StringBuilder sb = new StringBuilder("hello");
    // 拼接字符串
    sb.append("world");
    sb.append("world");
    sb.insert(2, "aaa"); // 向第二号位插入内容
    sb.delete(3, 6); // 从第3号位删除到第6号位（不包含6号位）
    System.out.println(sb.toString());

## 六、BigDecimal ##

*  通常用来进行小数精确运算和大数字的计算。
 *  注意：构造方法一定要使用字符串的方式。

public static void main(String[] args) {
        
        //        System.out.println(1.0-0.9); // 不精确
        //        System.out.println(2100000000 * 2100000000 * 2100000000); // 超出范围
        BigDecimal b = new BigDecimal("1.0");
        BigDecimal b1 = new BigDecimal("0.9");
        System.out.println(b.subtract(b1)); // 减法
        BigDecimal b2 = new BigDecimal("1.0234279243253");
        BigDecimal b3 = new BigDecimal("0.91231231234");
        System.out.println(b2.multiply(b3)); // 乘法
        BigDecimal b4 = new BigDecimal("1.0234279243253");
        BigDecimal b5 = new BigDecimal("0.91231231234");
        // 参数1，数
        // 参数2，保留小数位
        // 参数3，此处选择的四舍五入
        System.out.println(b4.divide(b5, 2000, BigDecimal.ROUND_HALF_UP));// 除法
        // 大数字的运算
        BigDecimal b6 = new BigDecimal("428374892734927347892749827498273947298374927344");
        BigDecimal b7 = new BigDecimal("548347593754892874823472938748237875984359374859");
        System.out.println(b6.multiply(b7));
    }

## 七、Date ##

*  常用的一个日期时间类，可以得到当前时间，与其他的时间比较早晚。

public static void main(String[] args) {
        
        Date d = new Date(); // 得到当前时间对象，有时区
        // 得到距离1970-1-1 GMT 0:0:0 所经过的毫秒数
        System.out.println(d.getTime()); 
        d.setTime(1597046465956L); // 设置时间为2020-8-10 16:01:05 CST
        System.out.println(d);
        Date d1 = new Date();
        System.out.println(d.before(d1)); // 判断d是否在d1之前
        System.out.println(d.after(d1)); // 判断d是否在d1之后
        int n = d.compareTo(d1); // d如果早于d1，返回-1，等于返回0，晚于返回1
        System.out.println(n);
    }

## 八、日历类 ##

*  日历类主要作用是对日期进行获取和设置，并进行加减。

public static void main(String[] args) {
        
        // 得到对象，不能使用new创建对象
        Calendar c = Calendar.getInstance();
        // 获取日期
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int date = c.get(Calendar.DATE);
        int hour = c.get(Calendar.HOUR_OF_DAY);// 24小时制
        int minute = c.get(Calendar.MINUTE);
        int second = c.get(Calendar.SECOND);
        int weekday = c.get(Calendar.DAY_OF_WEEK); // 日一二三
        System.out.println(year + "年" + (month+1) + "月" + date + "日 " +
                           hour + ":" + minute + ":" + second + " 星期" + weekday);
        // 日期计算
        // 参数1：日期计算的标准（日，月，年，星期，小时等）
        // 参数2：时长（可以使用负数）
        c.add(Calendar.WEEK_OF_YEAR, -60);
        System.out.println(c);
    }

## 九、SimpleDateFormat ##

*  主要作用是将日期格式化成字符串，或将字符串转换成日期格式。

public static void main(String[] args) {
        
        String s = "1999年10月10日 14:25:36.175";
        // yyyy 年
        // MM 月
        // dd 日
        // HH 24制小时 
        // hh 12小时制
        // mm 分钟
        // ss 秒
        // SSS 毫秒
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss.SSS");
        try {
        
            Date date = sdf.parse(s); // 将字符串转换成日期类型
            System.out.println(date);
        } catch (ParseException e) {
        
            // 如果出错会执行输出异常原因
            e.printStackTrace();
        } 
        Date d = new Date();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = sdf1.format(d); // 按照提供的格式将日期转换成字符串显示
        System.out.println(str);
    } = 'bar';

## 十、System类的常见方法 ##

*  arrayCopy() ：数组复制
 *  currentTimeMillis()：得到当前时间的毫秒数
 *  gc()：建议JVM启动垃圾回收
 *  exit(0)：退出系统

public static void main(String[] args) {
        
        // 得到当前时间距离1970-1-1 0:0:0 GMT的毫秒数
        System.out.println(System.currentTimeMillis());
        for (int i = 0; i < 100; i++) {
        
            if(i == 20) {
        
                System.exit(0); // 退出系统
            }
            System.out.println(i);
        }
    }

## 后记 ##

**Java全栈学习路线可参考：**[【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引][Java_Java_Java]，内含最全Java全栈学习技术清单~

[Java_Java_Java]: https://blog.csdn.net/qq_42146402/article/details/127133435