Java常用类

Java常用类

1内部类

概念：在一个类的内部再定义一个完整的类。

class Outer{
	class Inner{
	
	}
}

• 特点：
  • 编译之后可生成独立的字节码文件。
  • 内部类可直接访问外部类的私有成员，而不破坏封装。
  • 可为外部类提供必要的内部功能组件。

1）成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类。

• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

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

• 成员内部类不能定义静态成员static，但可以包含静态常量 final

//外部类
public class Outer {
    //实例变量
    private String name = "张三";
    private int age = 18;

    //内部类
    class Inner{
        private String address = "南京";
        private  String phone = "120";
        //属性和外部类的属性名字相同
        private  String name = "李四";

        //方法
        public void show(){
            //打印外部类的属性，属性和外部类的属性名字相同,Outer.this
            System.out.println(name);
            System.out.println(Outer.this.name);
            System.out.println(Outer.this.age);

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

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

//        //1 创建外部类对象
//        Outer outer = new Outer();
//        //2 创建内部类对象
//        Outer.Inner inner = outer.new Inner();

        //一步的写法
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

2） 静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。

• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）
  Outer.Inner inner = new Outer.Inner();

  Outer.Inner.show();

public class Outer {

    private String name = "***";
    //静态内部类：和外部类相同
    static class Inner{
        private String address = "南京";

        //静态成员
        private static  int count = 100;

        public void show(){
            //调用外部类的属性时
            //1 先创建外部类对象
            Outer outer = new Outer();
            //2 调用外部类对象属性
            System.out.println(outer.name);

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

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

        Outer.Inner inner = new Outer.Inner();
        //调用方法
        inner.show();
    }
}

3）局部内部类

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

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

    public void show(){
        //定义局部变量
        String address = "南京";

        //局部内部类:注意不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "123456";
            private String email = "zhangsan@123.com";

            public void show2(){
                //访问外部类属性
                System.out.println(Outer.this.name);
                System.out.println(age);
                //访问内部类属性
                System.out.println(this.phone);
                System.out.println(this.email);

                //访问局部变量,jdk1.7要求，局部变量必须时常量，
                // jdk1.8及以后自动添加final
                System.out.println(address);
            }

        }
        //创建局部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}
class Test{
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();

    }
}

4）匿名内部类

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

package com.huang.innerclass.Demo04;
//接口
public interface Usb {
    //服务方法
    void service();
}

package com.huang.innerclass.Demo04;
public class Mouse implements Usb{
    @Override
    public void service() {
        System.out.println("连接电脑成功，鼠标开始共工作！");
    }
}

package com.huang.innerclass.Demo04;

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 usb = new Fan();
//        usb.service();

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

2 Object类

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

3 Object类常用方法

1）getClass方法

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

Class class1 = s1.getClass();
Class class2 = s2.getClass();
if(class1==class2){
    
}

2）hashCode方法

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

int hashValue = s1.hashCode();

3）toString方法

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

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

//输出为
//    Outer{name='张三', age=18}

4）equals方法

• public boolean equals(Object obj){}
• 默认实现为（this == obj），比较两个对象地址是否相同。
• 可进行覆盖(重写)，比较两个对象的内容是否相同。
  • 比较两个引用是否指向同一个对象。
  • 判断obj是否为null
  • 判断两个引用指向的实际对象类型是否一致。
  • 强制类型转换
  • 依次比较各个属性值是否相同。

public boolean equals(Object obj){
    return(this == obj);
}

boolean value = s1.equals(s2);

//重写equals()方法
public boolean equals(Object obj){
    //1 判断两个对象是否时同一个引用
    if(this == obj){
        return true;
    }
    //2 判断obj受否为null
    if(obj == null){
        return false;
    }
    //3 判断是否时同一个类型
    
//    if(this.getClass() == obj.getClass()){
//        
//    }
    //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;
}

5）finalize方法

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

4 包装类

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

8种包装类对应，继承于Number类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

基本类型存储在栈中，引用类型存储在堆中

装箱：把基本类型转换为引用类型（数据：栈–>堆）

拆箱：把引用类型转换为基本类型（数据：堆–>栈）

• 8种包装类提供不同类型间的转换方式：
  • Number父类中提供的6个共性方法。
  • parseXXX() 静态方法。（字符串–>基本类型）
  • valueOf() 静态方法。（装箱，基本类型–>引用类型）

Number类

变量和类型	方法	描述
byte	byteValue()	返回指定数字的值 byte 。
abstract double	doubleValue()	返回指定数字的值 double 。
abstract float	floatValue()	返回指定数字的值 float 。
abstract int	intValue()	以 int返回指定数字的 int 。
abstract long	longValue()	以 long返回指定数字的值。
short	shortValue()	返回指定数字的值 short 。

public class Demo01 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型-->引用类型
        int num1 = 15;
        //使用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 ;

    }
}

	//基本类型和字符串之间的转换
        //1 基本类型-->字符串
        int n1 = 10;
        //1.1使用 “+”
        String s1 = n1 + "";
        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(n1);
        String s3 = Integer.toString(n1,16);//重载方法，16表示16进制
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

        //1 字符串-->基本类型
        String str = "100";
        //使用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);

Integer缓冲区： -128 ~ 127

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

5 String类

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

1）length()方法

public int length()：返回字符串长度

2）charAt(int index)方法

public char charAt(int index)：根据下标获取字符

3）contains(String str)方法

public boolean contains(String str)：判断当前字符串中是否包含str

4）toCharArray()方法

public char[] toCharArray()：将字符串转换成数组

5）indexOf(String str)方法

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

6）lastIndexOf(String str)方法

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

7）trim()方法

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

8）toUpperCase()方法

public String toUpperCase()：将小写转成大写。

public String toLowerCase()：将大写转成小写。

9）endWith(String str)方法

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

10）replace(char oldChar,char newChar)方法

public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串

11）split(String str)方法

public String split(String str)：根据str做拆分.

String[] arr = say.split("[ ,]+");

equals() 和compare()的比较

String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1。equalsIgnoreCase(s2));//忽略大小写 true

String s3 = "abc";//97
String s4 = "xyz";//120
System.out.println(s3.compareTo(s4));//-23

String s3 = "abc";//3
String s4 = "abcxyz";//6
System.out.println(s5.compareTo(s6));//-3

案例演示

需求：已知String str = “this is a text”;

1. 将str中的单词单独获取出来
2. 将str中的text替换为practice
3. 在text前面插入easy
4. 将每个单词的首字母改为大写

/**
 * 需求：已知String str = "this is a text";
 *
 * 1. 将str中的单词单独获取出来
 * 2. 将str中的text替换为practice
 * 3. 在text前面插入easy
 * 4. 将每个单词的首字母改为大写
 */


public class Case {
    public static void main(String[] args) {
        String str = "this is a text";

        //1. 将str中的单词单独获取出来
        System.out.println("---------1. 将str中的单词单独获取出来-------");
        String[] arr = str.split(" ");
        for(String s:arr){
            System.out.println(s);
        }

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

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

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

/* ****输出结果******
---------1. 将str中的单词单独获取出来-------
this
is
a
text
---------2. 将str中的text替换为practice-------
this is a practice
---------3. 在text前面插入easy-------
this is a easy text
---------4. 将每个单词的首字母改为大写------
This Is A Text 

*/

5.1 可变字符串

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

public class StrBuf {
    /*
    * - StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。
      - StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。
    * */
    public static void main(String[] args) {
//        StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();
        //1 append();追加
        sb.append("java is best");
        System.out.println(sb.toString());
        sb.append(" Yes");
        System.out.println(sb.toString());

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

        //3 replace();替换
        sb.replace(0,4,"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.length());
    }
}

6 BigDecimal类

//思考题
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);//输出0.09999999999999998

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

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

• 位置：java.math包中。
• 作用：精确计算浮点数。
• 创建方式：BigDecimal bd=new BigDecimal("1.0");
• 除法：divide(BigDecimal bd,int scal,RoundingMode mode)
  • 参数scal：指定精确到小数点后几位。
  • 参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式，取值为BigDecimal.ROUND_HALF_UP。

//思考题
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);//输出0.09999999999999998

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

        //BigDecimal，大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);  //输出 0.1

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

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

        //除法
        BigDecimal r4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r4);// 1

        //除不尽的情况，保留小数位
        BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),3, RoundingMode.HALF_UP);
        //RoundingMode.HALF_UP：4舍5入法
        System.out.println(r5);// 6.667

7 Date类

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

//1 创建Date对象
//今天
Date date1 = new Date();
System.out.println(date1.toString()); //Sat Feb 26 11:02:54 CST 2022
System.out.println(date1.toLocaleString());//2022年2月26日 上午11:02:54
//昨天
Date date2 = new Date(date1.getTime()-(60*60*24*1000));//一天的毫秒数：60*60*24*1000
System.out.println(date2.toLocaleString());//2022年2月25日 上午11:10:40

//2 方法 after before
System.out.println(date1.after(date2));//true
System.out.println(date1.before(date2));//false

//比较compareTo()
System.out.println(date1.compareTo(date2));//1

//equals()
System.out.println(date1.equals(date2));//false

8 Calendar类

• Calendar提供了获取或设置各种日历字段的方法。

• 构造方法

  • protected Calendar()：由于修饰符是protected，所以无法直接创建该对象。

• 其他方法

变量和类型	方法	描述
abstract void	add(int field, int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段
int	get(int field)	返回给定日历字段的值。
static Calendar	getInstance()	使用默认时区和区域设置获取日历。
Date	getTime()	返回一个 Date对象，表示此 Calendar的时间值
long	getTimeInMillis()	以毫秒为单位返回此Calendar的时间值。
void	set(int year, int month, int date, int hourOfDay, int minute, int second)	设置字段中的值 YEAR ， MONTH ， DAY_OF_MONTH ， HOUR_OF_DAY ， MINUTE和 `SECOND
void	setTime(Date date)	使用给定的 Date设置此日历的时间。

//1 创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());//2022年2月26日 上午11:29:50
System.out.println(calendar.getTimeInMillis());//毫秒值1645846256953
//2 获取时间信息
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH);
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hour = calendar.get(Calendar.HOUR_OF_DAY);//12小时制 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);//2022年2月26日11:39:13

//3 修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,24);
System.out.println(calendar2.getTime().toLocaleString());//2022年2月24日 上午11:41:56

9 SimpleDATeFormat类

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

字母	Date or Time Component	Presentation	Examples
G	Era designator	Text	AD
y	Year	Year	1996; 96
Y	Week year	Year	2009; 09
M	Month in year (context sensitive)	Month	July; Jul; 07
L	Month in year (standalone form)	Month	July; Jul; 07
w	Week in year	Number	27
W	Week in month	Number	2
D	Day in year	Number	189
d	Day in month	Number	10
F	Day of week in month	Number	2
E	Day name in week	Text	Tuesday; Tue
u	Day number of week (1 = Monday, …, 7 = Sunday)	Number	1
a	Am/pm marker	Text	PM
H	Hour in day (0-23)	Number	0
k	Hour in day (1-24)	Number	24
K	Hour in am/pm (0-11)	Number	0
h	Hour in am/pm (1-12)	Number	12
m	Minute in hour	Number	30
s	Second in minute	Number	55
S	Millisecond	Number	978
z	Time zone	General time zone	Pacific Standard Time; PST; GMT-08:00
Z	Time zone	RFC 822 time zone	-0800
X	Time zone	ISO 8601 time zone	-08; -0800; -08:00

/**
 * SimpleDATeFormat类
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1 创建SimpleDATeFormat对象 y年 M月
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        //2 创建Date
        Date date = new Date();
        //格式化date（把日期转成字符串）
        String str = sdf.format(date);
        System.out.println(str);

        //解析（字符-->日期）
        Date date2 = sdf.parse("2022/02/26 11:55:04");//需抛出异常
        System.out.println(date2.toLocaleString());

    }
}

10 System类

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

---

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

 //1 arraycopy(),数据复制
        //System.arraycopy(src,srcPos,dest,destPos,length);
        //src:源数组
        //srcPos：从哪个位置开始复制
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int[] arr = {1,2,3,4,8,7,6,5};
        int[] dest = new int[8];
        System.arraycopy(arr,4,dest,4,4);
        for(int i=0; i<dest.length;i++){
            System.out.println(dest[i]);
        }
//        Arrays.copyOf(original,newLength);

        //2 currentTimeMillis(),获取时间
        System.out.println(System.currentTimeMillis());

        //计时
        long start = System.currentTimeMillis();
        for(int i = -99999;i<999999;i++){
            for(int j = -99999;j<999999;j++){
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));

        //3 gc(),垃圾回收
        //匿名使用后，会自动回收
        System.gc();

        //4 exit(0),退出
        System.exit(0);//退出JVM
        System.out.println("程序退出了！");//不会被执行

总结

• 内部类：
  • 在一个类的内部再定义一个完整的类。
  • 成员内部类、静态内部类，局部内部类、匿名内部类。
• Object类：
  • 所有类的直接或间接父类，可存储任何对象。
• 包装类：
  • 基本数据类型所对应的引用数据类型，可以使Object统一所有数据。
• String类：
  • 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
• BigDecimal：
  • 可精确计算浮点数。
• Date
  • 特定时间
• Calendar
  • 日历
• SimpleDateFormat
  • 格式化时间
• System
  • 系统类

资料整理来源：千峰教育

视频链接：点击此处