Java常用类

常用类

一.内部类

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

内部类的分类：

1. 成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类。
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
• 当外部类、内部类存在重名属性时，会优先访问内部类属性。
• 成员内部类里不能定义静态成员、可以包含静态常量(final)。

实例：

package com.wnaoii.chapter;

// 外部类
public class Outer {
    // 私有内部变量
    private String name = "张三";
    private int age = 13;

    // 内部类
    class Inner{

        // 内部类和外部类名字相同优先调用内部类
        private String name = "李四";

        private String address = "北京";
        private String phone = "110";

        public void show(){

            // 打印输出外部类属性
            System.out.println(Outer.this.name);    // 想要调外部重名属性需要像这个例子一样加上前缀
            System.out.println(Outer.this.age);     // 当然写全也会更加方便查看调用的是哪个类的属性

            // 打印输出内部类属性
            System.out.println(this.name);
            System.out.println(this.address);
            System.out.println(this.phone);
        }
    }
}

调用内部类方法测试：

package com.wnaoii.chapter;

public class TestOut {
    public static void main(String[] args) {
        // 实例化外部类
        // Outer outer = new Outer();
        // 创建内部类对象
        // Outer.Inner inner = outer.new Inner();
        
        // 缩写
        Outer.Inner inner = new Outer().new Inner();

        inner.show();
    }
}

输出结果：

张三
13
李四
北京
110

2. 静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
• 只有内部类才可以是静态（static）的。

实例：

package com.wnaoii.chapter02;

// 外部类
public class Outer {
    private String name = "张三";
    private int age = 13;

    // 内部类
    static class Inner {
        private String address = "上海";
        private String phone = "189 xxx xxxx";
        // 静态成员
        private static int count = 100;

        public void show() {
            // 静态内部类调用外部类属性需要先实例化外部类
            Outer outer = new Outer();
            System.out.println(outer.name);
            System.out.println(outer.age);

            // 静态内部类调用内部类的属性和方法可以直接调用
            System.out.println(this.address);
            System.out.println(this.phone);

            // 静态内部类调用静态内部类的静态属性
            System.out.println(Inner.count);

        }
    }
}

调内部方法测试：

package com.wnaoii.chapter02;

public class TestOuter {
    public static void main(String[] args) {
        // 静态内部类可以直接创建，不需要创建先外部类
        Outer.Inner inner = new Outer.Inner();

        inner.show();
    }
}

输出结果：

张三
13
上海
189 xxx xxxx
100

3. 局部内部类

• 定义在外部类的方法中，作用范围和创建对象范围仅局限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
• 限制类的使用范围。

实例：

package com.wnaoii.chapter03;

public class Outer {
    private String name = "张三";
    private int age = 15;

    // 外部类的方法
    public void show() {
        // 局部变量
        final String address = "深圳";

        // 局部内部类;局部内部类不能加任何访问修饰符
        class Inner {
            // 局部内部类的方法
            private String phone = "189 xxx xxxx";
            private String emali = "werttys@qq.com";

            // 局部内部类的方法
            public void show_2() {

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

                // 访问内部类的属性
                System.out.println(this.phone);
                System.out.println(this.emali);

                // 访问局部变量; 在JDK1.7时要求变量必须是常量(final)，JDk1.8之后自动添加final
                System.out.println(address);
            }
        }
        // 创建局部内部类对象
        Inner inner = new Inner();
        inner.show_2();
    }
}

调用测试：

package com.wnaoii.chapter03;

public class TestOut {
    public static void main(String[] args) {
        // 实例化外部类
        Outer outer = new Outer();
       
        outer.show();
    }
}

输出结果：

张三
15
189 xxx xxxx
werttys@qq.com
深圳

4. 匿名内部类

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

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

二.Object类

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层
• 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
• Object类中所定义的方法，是所有对象都具备的方法
• Object类型可以存储任何对象
  • 作为参数，可接受任何对象
  • 作为返回值，可返回任何对象

1. getClass( )方法

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

实例：

package com.wnaoii.chapter;

public class TestStudent {
    public static void main(String[] args) {
        // 实例化两个类
        Student s1 = new Student();
        Student s2 = new Student();
        // 判断s1和s2是不是同一个类型
        Class Class1 = s1.getClass();
        Class Class2 = s2.getClass();

        if (Class1 == Class2){
            System.out.println("属于同一个类型");
        }else {
            System.out.println("不是同一个类型");
        }
    }
}

2. hashCode( )方法

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

package com.wnaoii.chapter;

public class TestStudent {
    public static void main(String[] args) {
        // 实例化两个类
        Student s1 = new Student();
        Student s2 = new Student();
        
        Student s3 = s1;

        // hashCode方法,输出hash值
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println(s3.hashCode());
    }
}

3. toString( )方法

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

@Override
 // toString方法不重写默认显示：包名+类名+哈希值
public String toString() {
    return name + age;
}

4. equals( )方法

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

// 源码可以看出返回值是布尔值，判断this值与输入的Object对象是否相等
public boolean equals(Object obj) {
        return (this == obj);
    }

实例：

package com.wnaoii.chapter;

public class TestStudent {
    public static void main(String[] args) {
        // 实例化两个类
        Student s1 = new Student("张三",14);
        Student s2 = new Student("张三", 14);
        // 使用quals()方法比较
        System.out.println(s1.equals(s2));
    }
}

输出：false

虽然值相同但地址不同所以返回 false

5. finalize( )方法 （过时了）

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

三.包装类

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

基本数据类型	包装类型（首字母大写）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

1. 类型转换与装箱、拆箱

• 8种包装类提供不用类型间的转换方式
  1. Number父类中提供的6个共性方法
  2. parseXXX( )静态方法
  3. valueOf( )静态方法
• 注意：需保证类型兼容，否则抛出NumberFormatException异常

package com.wnaoii.chapter05;

public class Demo01 {
    public static void main(String[] args) {
        // JDK1.5之前的装箱、拆箱
        // 基本类型
        int num1 = 18;

        // 类型转换：装箱， 基本类型-->引用类型
        // 使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);

        // 类型转换：拆箱， 引用类型 → 基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();

        // 在JDK1.5之后提供了自动装箱、拆箱
        // 基本类型
        int age = 20;

        // 自动装箱
        Integer integer4 = age;
        // 自动拆箱
        int age2 = integer4;

        // 基本类型和字符串之间转换
        // 基本类型 + 字符串
        int in1 = 5;
        String str = 5 + "";
        // 使用Integer中的toString()方法
        String str2 = Integer.toString(in1);

        // 字符串转成基本类型
        String str3 = "16";
        // 使用Integer中的parseXXX()方法
        int in2 = Integer.parseInt(str3);

        // boolean 字符串形式转成基本类型，"true" --> true 非"true" --> false
        String str4 = "true";
        Boolean BL = Boolean.parseBoolean(str4);    // Boolean是布尔型的包装类
    }
}

2. 整数缓冲区

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

package com.wnaoii.chapter05;

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.valueOf(100);
        Integer integer3 = 100;// 自动装箱
        // Integer integer3 = Integer.valueOf(100);
        Integer integer4 = 100;
        System.out.println(integer3 == integer4); // true

        Integer integer5 = 200;// 自动装箱
        Integer integer6 = 200;
        System.out.println(integer5 == integer6); // false    
    }
}

查看valueOf( )方法源码：

public static Integer valueOf(int i) {
    // 缓存区数组 [-128, 127] 在这范围之内地址都一样，方便对已创建的对象进行复用
    if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
        return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
    // 超出范围才new一个
    return new Integer(i);
}

四.String类

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

声明一个字符串：

String str = "张三";

使用new关键字创建字符串：

String str = new String("HelloWorld");
String str2 = new String("HelloWorld");

虽然两个字符串对象的值指向的是同一个，但new对象的时候会开辟一块新的空间，导致它们内存地址不同

• 比较两个字符串时用equals来比较，而不是用==来比较

String str = new String("HelloWorld");
String str2 = new String("HelloWorld");
System.out.println(str == str2);	// false
System.out.println(str.equals(str2) );	//ture

String中重写了equals()方法，比较的不是地址，而是比较值。

String类常用方法

1. public int length();返回字符串的长度。

String str = "fc world";
System.out.println(str.length());

2. public char charAt(int index);根据下标获取字符。

String str = "fc world";
System.out.println(str.charAt(4));

3. public boolean contains(String str);判断当前字符串中是否包含某个字符串。

String str = "fc world";
System.out.println(str.contains("world"));

4. public char[] toCharArray();将字符串转换成数组。

String str = "fc world";
System.out.println(Arrays.toString(str.toCharArray()));	// import java.util.Arrays;

5. public int indexOf(String str);查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。

String str = "fc world hl code";
System.out.println(str.indexOf("d"));

6. public int lastIndexOf(String str);查找字符串在当前字符串中最后一次出现的下标索引。

String str = "fc world hl code";
System.out.println(str.lastIndexOf("d"));

7. public String trim();去掉字符串前后的空格。

String str = " hello code ";
System.out.println(str.trim());

8. public String toUpperCase();将小写转成大写。(toLowerCase()大转小类似不细锁)

String str = "hello code";
System.out.println(str.toUpperCase());

9. public boolean endWith(String str);判断字符串是否以字符串结尾。

String str = "hello code";
System.out.println(str.endsWith("e"));

10. public String replace(char oldChar, char newChar);将旧字符串替换成新字符串。

String str = "hello code";
System.out.println(str.replace("code","world"));

11. public String[] split(String str);根据字符串做拆分。

• 拆分的条件可以用正则。

String str = "Java is best programing language";
// 根据单个空格拆分字符串
String[] arr = str.split(" ");
// 遍历数组
for (String strs:arr) {
    System.out.println(strs);
}

12. 补充两个方法equals()、compareTo();比较大小。

• equals():

String str1 = "code";
String str2 = "CODE";
System.out.println(str1.equals(str2));
System.out.println(str1.equalsIgnoreCase(str2));    // 忽略大小写比较

• compareTo():

String str1 = "abc";
String str2 = "adc";
System.out.println(str1.compareTo(str2));   // str1的位置减str2的位置

可变字符串

• StringBuffer : 可变长字符串，运行效率慢、线程安全
• StringBuilder : 可边长字符串、运行快、线程不安全
• StringBuffer 和 Stringbuilder用法一样。

public class StringDemo03 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();
        // append();追加
        stringBuffer.append("Code");
        // insert();添加、插入
        stringBuffer.insert(4,"牛蛙");
        // replace();替换字符串,从第几个到第几个替换
        stringBuffer.replace(4,6,"牛哇");
        // delete();删除某一块的字符串
        stringBuffer.delete(4,6);
        // 清空
        stringBuffer.delete(0,stringBuffer.length());
        System.out.println(stringBuffer);
    }
}

Tip

• 验证String和StringBuilder运行速度

public class StringBuilder__String {
    public static void main(String[] args) {
        // 获取开始时间
        Long starTime = System.currentTimeMillis();
        String str = "";
        for (int i = 0;i <= 99999;i++) {
            str += i;
        }
        // 结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("用时:" + (endTime - starTime));
    }
}

输出：

用时:16294

StringBuilder运行速度：

public class StringBuilder__StringBuffer {
    public static void main(String[] args) {
        Long starTime = System.currentTimeMillis();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0;i <= 99999;i++) {
            stringBuilder.append(i);
        }
        Long endTime = System.currentTimeMillis();
        System.out.println("用时：" + (endTime - starTime));
        System.out.println(System.currentTimeMillis());
    }
}

输出：

用时：9

五.BigDecimal类

• BigDecimal类位于 java.math 包中
• 作用：精确计算浮点数
• 创建方式 BigDecimal bd = new BigDecimal("1.0");
• BigDecimal对象传值的时候得传字符串，传其他的值有可能还是近似值。

import java.math.BigDecimal;

public class BigDecimal_02 {
    public static void main(String[] args) {
        // 传字符串
        BigDecimal b1 = new BigDecimal("1.0");
        BigDecimal b2 = new BigDecimal("0.9");
        // 不能直接"-"，得调BigDecimal的内置subtract()方法
        BigDecimal b3 = b1.subtract(b2);
        System.out.println(b3);
    }
}

方法：

• 加：public BigDecimal add(BigDecimal augend)
• 减：public BigDecimal subtract(BigDecimal subtrahend)
• 乘：public BigDecimal multiply(BigDecimal multiplicand)
• 除：public BigDecimal divide(BigDecimal divisor)
  • 注意这个除法方法重载public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
  • 参数scal :指定精确到小数点后几位。
  • 参数mode:
    • 指定小数部分的取舍模式,通常采用四舍五入的模式。
    • 四舍五入的取值为BigDecimal.ROUND_HALF_UP。

double类型存储是近似存储

实例：

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

        // 面试题
        double result = (1.4 - 0.5) / 0.9;
        System.out.println(result);
    }
}

输出结果：

0.09999999999999998
0.9999999999999999

Date类

• 过时了不再细琐（被Calendar类替代）

• Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代

• 时间单位：

  • 1秒 = 1000毫秒
  • 1毫秒 = 1000微秒
  • 1微妙 = 1000纳秒

Calendar类

• Calendar提供了获取或设置各种日历字段的方法
• 构造方法 protected Calendar(); 由于是protected 所以无法直接创建
• 其他方法

方法名	说明
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year, int month, int date, int hourofday, int minute, int second)	设置日历的年、月、日、时、分、秒
int get(int field)	返回给定日历字段的值。字段比如年、月、日
void setTime(Date date)	用给定的date设置此日历时间
Date getTime()	返回一个date表示此日历的时间
void add(int field, int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMilles()	毫秒为单位返回该日历的时间值

1. 获取当前年、月、日

import java.util.Calendar;

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

2. 年

int year = calendar.get(Calendar.YEAR);

3. 月

• 月默认：0—11月，输出记得加1。

int year = calendar.get(Calendar.YEAR);

4. 日

int day = calendar.get(Calendar.DAY_OF_MONTH);

5. 小时

int hour = calendar.get(Calendar.HOUR_OF_DAY);	// HOUR->12小时 HOUR_OF_DAY->24小时

6. 分钟

int minute = calendar.get(Calendar.MINUTE);

7. 秒

int second = calendar.get(Calendar.SECOND);

SimpleDateFormat类

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

字母	日期或时间	示例
y	年	2019
08	年中月份	08
d	月中天数	10
H	一天中小时（0-23）	22
m	分钟	16
s	秒	59
S	毫秒	356

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

public class SimpleDateFormat_01 {
    public static void main(String[] args) throws Exception{
        // 创建SimpleDateFormat对象
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        // 创建Date
        Date date = new Date();
        // 按照之前定义的格式格式化date （把日期转换为字符串）
        String format = simpleDateFormat.format(date);
        System.out.println(format);

        // 解析（把字符串转成日期需要按照上面定义的格式）
        Date parse = simpleDateFormat.parse("2020年08月16日 15:34:56");
        System.out.println(parse);
    }
}

六.System类

• 主要用于获取系统的属性数据和其他操作，构造方法私有的。
• 因为构造方法是私有的可以直接调用，不用new，许多方法也是静态的。

方法名	说明
static void arraycopy(...)	复制数组
static long currentTimeMillis();	获取当前系统时间，返回毫秒值
static void gc();	建议JVM赶快启动垃圾回收期器回收垃圾
static void exit(int status);	退出JVM 如果参数是0表示正常退出JVM 非0表示异常退出

1. static void arraycopy(...)方法

public static native void arraycopy(Object src,int  srcPos,Object dest,int destPos,int length);

• src：被复制的数组
• srcPos：从哪个位置开始复制
• dest：复制到的数组
• destPos：目标数组的哪个位置
• length：复制的长度

//arraycopy:数组复制
int[] arr = {43,54,23,47,86,34,84,12};
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. static long currentTimeMillis();方法

• 获取的时间为毫秒级。

• 一般用于计算程序运行所需的时间。

public class System_02 {
    public static void main(String[] args) {
        // 开始时的时间
        long star = System.currentTimeMillis();
        for (int i = 0;i < 99999;i++) {
            for (int j = 0;j <99999;j++) {
                int result = i + j;
            }
        }
        // 程序运行结束的时间
        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - star));
    }
}