关于java:1w-字总结-Java-常用类整理太全了建议收藏

起源：cnblogs.com/lwtyyds/p/15678152.html

罕用类概述

外部类
Object类
包装类
数学类
工夫类
字符串
String Builder和StringBuffer
DecimalFormat

外部类

「概念」 ：在一个类外部再定义一个残缺的类。

个别状况下类与类之间是互相独立的，外部类的意思就是突破这种独立思想，让一个类成为另一个类的外部信息，和成员变量、成员办法等同级别。

「外部类的益处：」

把一个类写在里面和写在外面最终达到的后果都一样，那咱们为什么还要应用外部类，岂不是多此一举吗？

「采纳外部类这种技术，能够暗藏细节和内部结构，封装性更好，让程序的构造更加正当！如果类很多且都裸露在里面，那么类与类之间的调用就会非常繁琐！」

外部类的分类：

1.成员外部类（非动态外部类）

参考代码如下：

package NeiBuLei;
public class OuterClass {
    //成员变量
    private String OuterName;
    //成员办法
    public void display(){
        System.out.println("这是外部类办法！");
        System.out.println(OuterName);
    }
    //外部类
    public class InnerClass{
        //成员变量
        private String InnerNme;
        //构造方法
        public InnerClass() {
            InnerNme = "Inner Class";
        }
        //成员办法
        public void display(){
            System.out.println("这是外部类办法！");
            System.out.println(InnerNme);
        }
    }
    // 主办法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();//这是外部类办法！null

        // 这个类是外部类，曾经不是独立的类了，因而不能像外部类一样间接创立！
        //InnerClass innerClass = new InnerClass(); 行不通
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();// 同成员办法/变量 只是加了个前缀
        innerClass.display();// 这是外部类办法！
    }
}

输入后果：

这是外部类办法！null 这是外部类办法！Inner Class

「总结：成员外部类（非动态外部类）的应用就是将外部类作为外部类的的一个成员变量/成员办法来应用，所以必须依赖于外部类的对象能力调用，用法和成员变量/成员办法统一！」

2.部分外部类

部分外部类：根本的外部类还能够在一个办法体中定义。

package NeiBuLei;
public class OuterClass {
    //成员变量
    private String OuterName;
    //成员办法
    public void display(){
        class InnerClass {
            public void print(){
                System.out.println("这是一个部分外部类办法！");
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.print();
    }

    // 主办法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
    }
}

动态外部类

动态外部类的结构不须要依赖于外部类对象，类中的动态组件都不须要依赖于任何对象，能够间接通过「类自身」 进行结构。

package NeiBuLei;
public class OuterClass {
    //成员变量
    private String OuterName;
    //成员办法
    public void display(){
        System.out.println("这是外部类办法！");
        System.out.println(OuterName);
    }
    //动态外部类
    public static class InnerClass{
        private String InnerName;
        public InnerClass() {
            InnerName = "Inner Class";
        }

        //成员办法
        public void display(){
            System.out.println("这是动态外部类办法！");
            System.out.println(InnerName);
        }
    }

    // 主办法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        // 动态外部类的结构不依赖与外部类，能够间接通过类自身进行结构！
        InnerClass innerClass = new InnerClass();
        innerClass.display();
    }
}

输入后果：

这是外部类办法！null 这是动态外部类办法！Inner Class

4.匿名外部类

匿名外部类：没有名字的外部类。

匿名外部类「次要利用与接口的实现！」

接口：

package NeiBuLei;
public interface MyInterface {
    public void test();
}

实现类：

package NeiBuLei;
public class MyImplement implements MyInterface{
    @Override
    public void test() {
        System.out.println("test");
    }
}

匿名外部类的应用：

package NeiBuLei;
public class MyImplement implements MyInterface{
    @Override
    public void test() {
        System.out.println("test");
    }
}

「匿名外部类的益处：」

咱们定义接口之后，「它的实现类不须要去独自创立一个文件去写它的实现」 ，咱们能够把这个实现类的操作写到咱们调用的中央就能够了！写起来更加简洁、不便。

「匿名外部类的毛病：」

耦合度太高了！

Object类

匿名外部类的毛病

Object类罕用办法：

1.equals办法

「==与equals的比照【面试题】+ jdk查看原码」

==是一个比拟运算符

==：既能够判断根本类型，又能够判断援用类型
==：如果判断的是「根本类型」 ，「判断的是值是否相等」 。

//==： 如果判断的是根本类型，判断的是 值 是否相等
int x1 = 10;
int x2 = 10;
double x3 = 10.0;
System.out.println(x1 == x2);//true
System.out.println(x1 == x3);//true

==：如果判断的是「援用类型」 ，「判断的是地址是否相等，即判断是不是同一个对象」

package Equals;
public class Test01 {
    public static void main(String[] args) {
        //==： 如果判断的是援用类型，判断的是地址是否相等，即判断是不是同一个对象
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a==c);// ? true
        System.out.println(b==c);// true
        B obj = a;
        System.out.println(obj==c);// true
    }
}

class B{}
class A extends B{}

equals办法是Object类中的办法，「只能判断援用类型」 。

❝

idea查看Jdk原码：鼠标光标放在要查看的办法上，间接输出ctrl + b

查看某个类所有办法：ctrl + F12

❞

默认判断的是地址是否相等，「子类(Object类是所有类的父类)往往重写该办法，用于判断内容是否相等」 。

/*
Object类 equals()办法原码

//默认判断地址是否一样
    public boolean equals(Object obj) {
        return (this == obj);
    }

子类往往重写该办法，用于判断内容是否相等  String类中的equals()办法原码（重写了父类equals()办法）

    public boolean equals(Object anObject) {
        if (this == anObject) { // 如果是同一个对象(地址雷同)
            return true; // 返回true
        }
        if (anObject instanceof String) { // 判断类型
            String anotherString = (String)anObject; // 向下转型
            int n = value.length;
            if (n == anotherString.value.length) { // 如果长度雷同
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) { // 比拟每一个字符
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true; // 如果两个字符串每一个字符都雷同，则返回true
            }
        }
        return false;
    }
 */

在看个例子

【小练习】

写出输入后果：

package Equals;
public class EqualsTest01 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "tom";
        Person p2 = new Person();
        p2.name = "tom";
        System.out.println(p1 == p2);// 援用类型——判断是否为同一个对象（地址）
        System.out.println(p1.name.equals(p2.name));// p.name是String类型，重写了equals()办法——判断内容是否一样
        System.out.println(p1.equals(p2));//p1,p2属于Person类，该类并没有重写equals()办法（继承父类equals()办法，即判断地址）

        String s1 = new String("abc");
        String s2 = new String("abc");

        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2);
    }
}

class Person{
    public String name;
}

输入后果：

false true false true false

2.hashCode办法

小结：（能够当作地址来看但它实质上不是地址）

进步具备哈希构造的容器的效率
两个援用，如果指向的是同一个对象，则哈希值必定一样
两个援用，如果指向的是不同对象，则哈希值是不一样的
哈希值次要依据地址号来！不能将哈希值齐全等价于地址
在前面的汇合中hashCode如果需要的话，也会重写

package hashCode;
public class HashCode {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;
        System.out.println("aa.hashCode()="+ aa.hashCode());
        System.out.println("aa2.hashCode()="+ aa2.hashCode());
        System.out.println("aa3.hashCode()="+ aa3.hashCode());
    }
}

class AA{}

输入后果：

❝

aa.hashCode()=460141958 aa2.hashCode()=1163157884 aa3.hashCode()=460141958

❞

3.toString办法

toString办法

根本介绍：

默认返回：全类名 + @ + 哈希值的十六进制

/*
    Object toString()原码
    //(1)getClass().getName() 类的全类名（包名+类名）
    //(2)Integer.toHexString(hashCode()) 将hashCode的值转成16进制字符串
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
 */

「子类往往重写toString办法，用于返回对象的属性信息（快捷键：alt + insert），当然咱们也能够本人定制。」

当咱们输入一个对象时，toString()办法会被默认调用

4.finzlize办法

finzlize办法：当垃圾收集确定不再有对该对象的援用时，垃圾收集器在对象上调用该对象。

当对象被回收时，零碎主动调用该对象的finzlize办法。子类能够重写该办法，做一些开释资源的操作
什么时候被回收：当某个对象没有任何援用时，则jvm就认为这个对象是一个垃圾对象，就会时候垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finzlize办法。

垃圾回收机制的调用，是由零碎来决定（即有本人的GC算法），也能够通过System.gc()被动触发垃圾回收机制。

❝

注：在理论开发中，简直不会用finzlize办法，更多的是为了应酬面试

❞

包装类

「1.根本数据类型以及对应的包装类：」

byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean

这些类都在java.lang包

「2.包装类的意义：」

让根本数据类型有面向对象的特色
「封装了字符串转化成根本数据类型的办法（重点）」

3.包装类罕用办法：

Integer.parseInt()
Long.paseLong()
Double.parseDouble()

【参考代码】

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

//        Integer i = new Integer(10);// 创立包装类对象
//        Integer ii = 10; // 主动打包
//        System.out.println(i+10); // 在应用上，int 和Integer 其实没有区别，能够相互应用
//        System.out.println(ii+10);
//        int j = ii;// 主动解包
//        System.out.println(j+100);

        String a = "12";
        String b = "34";
        System.out.println(a+b); // 1234
    // 转型:
        // 字符串转成int的惟一计划
        int c = Integer.parseInt(a);
        int d = Integer.parseInt(b);
        System.out.println(c+d); // 46

        // 字符串转成double类型
        String e = "1.25";
        double f = Double.parseDouble(e);
        System.out.println(f*6); // 7.5

        // 转成long类型
        long l = Long.parseLong("1234567");
        System.out.println(l);
    }
}

数学类

❝

数学类的办法都是静态方法，能够间接援用——Math.办法();

❞

「罕用数学类办法：」

abs()：获取绝对值
max()：求最大值
min()：求最小值
pow()：求次幂
round()：四舍五入
sqrt()：求平方根

工夫类

Java罕用工夫类：

Date 日期类
Calendar 日历类
SimpleDateFormat 格式化工夫类

❝

Date和Calendar类在java.util包中， SimpleDateFormat类在java.text包

❞

1.Date 日期

【1】new Date() 能够获取到零碎工夫

【2】getTime() 能获取到工夫的long模式，能够用来计算时间差

❝

getTime()——获取计算机底层存储的数字，返回一个数字用来示意工夫，这个数字的类型long，单位为毫秒。

❞

【参考代码】

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d); // 零碎工夫
        //get...()——获取年月日.....
        System.out.println(d.getYear()+1900); // 从1900年开始算的
        System.out.println(d.getMonth()+1); // 月份从0开始计算
        System.out.println(d.getDate()); // 天数
        System.out.println(d.getHours());// 小时

        //getTime()——获取到工夫的毫秒模式 返回的是long
        System.out.println(d.getTime());
    }
}

2.Calendar 日历

【1】get() 获取到工夫的某一部分

【2】set() 设置工夫 – -> 计算工夫：零碎曾经帮咱们设置好了，不必放心二月有多少天等问题，计算工夫非常不便

❝

注：Calendar 日历类是抽象类，因而不能够去new对象。尽管抽象类不能创建对象，然而jdk官网提供了一个实例对象的操作：

Calendar rightNow = Calendar.getInstance();

咱们通过这条代码就是间接造了一个Calender的对象

❞

【参考代码】：get() 获取到工夫的某一部分：

package date;
import java.util.Calendar;
public class TestCalendar {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
//        System.out.println(cal);

        /*
 假如当天：
        2021
        8
        10
         */
  cal.set(Calendar.DATE,cal.get(Calendar.DATE)+31); // 计算工夫(这里用天数计算的)

        // 获取Calendar创立的对象里的所有内容
        System.out.println(cal.get(Calendar.YEAR)); // 2021 年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份：从0开始的  后果：为10月
        System.out.println(cal.get(Calendar.DATE)); // 日
        System.out.println(cal.get(Calendar.HOUR_OF_DAY));// 小时
        System.out.println(cal.get(Calendar.MINUTE));
        System.out.println(cal.get(Calendar.SECOND));
    }
}

【参考代码】：set() 设置工夫 – -> 计算工夫：

❝

注：cal.setTime(d); 把Date转化成Calendar

❞

package date;
import java.util.Calendar;
import java.util.Date;
public class TestCalendar {
    public static void main(String[] args) {
        Date d = new Date();
        Calendar cal = Calendar.getInstance();
        cal.setTime(d);// 把Date转化成Calendar
        System.out.println(cal);
        System.out.println(cal.get(Calendar.YEAR)); //  年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份：从0开始的
        System.out.println(cal.get(Calendar.DATE)); // 日
    }
}

3.SimpleDateFormat格式化工夫

Date，Calendar通过援用也能够进行工夫的格式化，但比拟繁琐，而SimpleDateFormat类是专门帮咱们格式化工夫的工具类，它在java.text包中。

【工夫格局】：yyyy-MM-dd HH:mm:ss

SimpleDateFormat类有两大罕用办法：

【1】format(Date)：

❝

format(Date) 帮咱们把工夫转成字符串，字符串的格局为SimpleDateFormat类定义对象时设置的工夫格局

❞

【参考代码】

package Simple;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d); //Thu Aug 12 08:40:08 CST 2021  不美观

  //                  设置格式化工夫的模式，咱们罕用yyyy-MM-dd HH:mm:ss这个模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 工夫格局
        String s = sdf.format(d); // 格式化工夫
        System.out.println(s); // 2021-08-12 08:45:09
    }
}

【2】parse(String)：

❝

parse(String) 帮咱们把字符串转化成工夫

❞

【参考代码】

package Simple;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出一个工夫(yyyy-MM-dd HH:mm:ss)：");
        String s = sc.nextLine();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       Date d =  sdf.parse(s); // 把字符串转成工夫
        System.out.println(d);
        /*
        请输出一个工夫(yyyy-MM-dd HH:mm:ss)：
        2021-08-12 12:25:21
        Thu Aug 12 12:25:21 CST 2021
         */
    }
}

❝

注：因为用户输出的字符串不肯定是咱们要求的格局，可能是任何货色，想把它们转成工夫是不可能的，你不可能把一个人转成工夫对吧，因而存在着很大的危险未解决(异样: java.text.ParseException)，为此咱们须要解决异样。

❞

4.计算时间差

计算思路：

格式化工夫
先将字符串转化成long类型工夫
计算毫秒级别时间差，取绝对值
毫秒级别时间差转成秒级别
秒级别时间差转成分钟级别
分钟级别时间差转化显示成xx小时xx分钟

【参考代码】

package Simple;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDiff {
    public static void main(String[] args) throws ParseException {
        String s1 = "2021-08-12 12:00:00"; // 开始工夫
        String s2 = "2021-08-12 14:35:00"; // 完结工夫
        //格式化工夫
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        //将字符串转成工夫模式
        Date d1 = sdf.parse(s1);
        Date d2 = sdf.parse(s2);

        //计算时间差:先要获取工夫毫秒模式（long类型） 再做差
        long long1 = d1.getTime();
        long long2 = d2.getTime();
        long diffTime = Math.abs(long1 - long2);

        // 秒级别时间差
        long diffSec = diffTime / 1000;

        // 分级别时间差
        long diffMin = diffSec / 60;

        //显示 xx小时xx分钟
        long displayHours = diffMin / 60; // 小时
        long displayMin = diffMin % 60; //分钟
        System.out.println("您学习的时长为："+displayHours+"小时"+displayMin+"分钟");
    }
}

String类

字符串类罕用办法

「办法汇总：」

❝

「注：字符串是一个不可变的类型（final类），简直所有的字符串操作都会返回一个新字符串而不是在原有根底上进行批改。」

❞

【示例代码】

public class Test {
    public static void main(String[] args) {
        String s = "我的名字叫李华";
        s.concat("hhh"); // 在字符串s上拼接，拼接hhh
        System.out.println(s);// 我的名字叫李华
        //字符串是不可变的数据类型
        //简直所有的字符串操作都会返回一个新字符串
        String s1 = s.concat("hhh"); // 在字符串s上拼接，拼接hhh
        System.out.println(s1);//我的名字叫李华hhh

        String str1 = "李华喜爱看罗老师的视频";
        str1.replace("李华","张三");
        System.out.println(str3); //李华喜爱看罗老师的视频  并没有替换 字符串是不变的str1还是str1

        String str2 = str1.replace("李华","张三");//简直所有的字符串操作都会返回一个新字符串 新串要用新变量接
        System.out.println(str2);//张三喜爱看罗老师的视频
   }
}
package String;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        String s = "我的名字叫李华";
        System.out.println(s.charAt(0)); // 获取第0个地位的字符
        s.concat("hhh");
        System.out.println(s);// 我的名字叫李华
        //字符串是不可变的数据类型
        //简直所有的字符串操作都会返回一个新字符串
        String s1 = s.concat("hhh"); // 在字符串s上拼接，拼接hhh
        System.out.println(s1);//我的名字叫李华hhh
        System.out.println(s.contains("李华")); //true
        System.out.println(s.contains("牛津")); //false
        System.out.println("邀请李华来加入英语沙龙流动".endsWith("流动"));//true 判断是否以xxx为结尾
        System.out.println("邀请李华来加入英语沙龙流动".startsWith("李华"));//false 判断是否以xxx结尾

        // equals字符串内容是否雷同

        // 承受邀请加入流动的李华到现场后要输出验证码
//        String yanZhengMa = "AAkm";
//
//        Scanner sc = new Scanner(System.in);
//
//        System.out.println("请输出验证码("+yanZhengMa+")");
//
//        String userInput = sc.nextLine();
//
//        if(yanZhengMa.equalsIgnoreCase("aakm")){  // 疏忽大小写判断两边的内容是否一样
//            System.out.println("欢送加入英语沙龙流动！");
//        }else{
//            System.out.println("您未受到邀请，请现场报名！");
//        }

//        String str = "李华玩得很开心！";
//        System.out.println(str.indexOf("开心"));// 5 计算给出字符串第一个呈现的地位

        String str2 = "李华问题很好";
        System.out.println(str2.length()); // 6 计算字符串的长度

        String str3 = "李华喜爱看罗老师的视频";
        str3.replace("李华","张三");
        System.out.println(str3); //李华喜爱看罗老师的视频  并没有替换 字符串是不变的str3还是str3

        String str4 = str3.replace("李华","张三");//简直所有的字符串操作都会返回一个新字符串 新串要用新变量接
        System.out.println(str4);//张三喜爱看罗老师的视频
        String str5 = "哈哈_呵呵_嘻嘻_噢no";
        String[] ss = str5.split("_");//切割
        System.out.println(ss[0]);//哈哈
        System.out.println(ss[1]);//哈哈
        System.out.println(ss[2]);//嘻嘻
        System.out.println(ss[3]);//噢no

        String str6 = "今天天气不错";
        System.out.println(str6.substring(2,4));//天气 字符串截取 [ ) 左闭右开，左边取不到

        String str7 ="     哈    哈      ";
        System.out.println(str7.trim());// 去掉左右两边的空格
        int i = 10;
        System.out.println(String.valueOf(i)); // 根本数据类型转为字符串
        System.out.println(i+""); // 野路子
    }
}

String Builder和StringBuffer

「String类的毛病：」

String 是一个不可变的数据类型，每每拼接都会产生一个新的字符串，那么内存迟早会被这些拼接的字符串塞满。

「String类和StringBuilder和StringBuffer类的区别：」

StringBuilder和StringBuffer：「可变的字符串，不产生新对象，比拟省内存」 ，当进行大量的字符串拼接时倡议应用StringBuffer和StringBuilder，但它们两个一些办法的实现简直跟String一样。

「StringBuffer和StringBuilder类：」

【类似点】

两者用法截然不同，能够认为是一个类

【区别】

StringBuffer线程平安，StringBuilder非线程平安。
StringBuilder相比于StringBuffer有速度劣势，「少数状况下倡议应用StringBuilder类，但当被要求线程平安时必须应用StringBuilder类」

❝

字符串拼接办法：append()办法

StringBuffer和StringBuilder 转成String类：

StringBuilder sb = new StringBuilder(“猫喜爱吃鱼”); String s = sb.toString();

❞

【参考代码】

package String;
public class TestStringBuilder {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();// 一个空的字符串""
        StringBuilder sb2 = new StringBuilder("猫喜爱吃鱼");
        System.out.println(sb2);// 猫喜爱吃鱼

        sb2.append("，狗也喜爱吃鱼");
        System.out.println(sb2);// 追加  猫喜爱吃鱼，狗也喜爱吃鱼

        sb2.insert(1,"哈哈哈");
        System.out.println(sb2); //猫哈哈哈喜爱吃鱼，狗也喜爱吃鱼

        // 上述的操作huan'c
        // 把StringBuilder转化成String
        String s = sb2.toString();
        System.out.println(s); //猫哈哈哈喜爱吃鱼，狗也喜爱吃鱼
        // 上述操作都能够将StringBuilder换成StringBuffer，后果一样
    }
}

DecimalFormat

DecimalFormat：对小数进行格式化，保留几位小数。与格式化工夫联想记。

❝

. 示意小数点

0和# 示意数位，保留几位就几个0或者#

❞

【参考代码】

import java.text.DecimalFormat;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        double d= 10/3.0;
        System.out.println(d);//3.3333333333333335

        // . 示意小数点
        // 0和#示意数字

        // 保留两位小数                        格局
        DecimalFormat df = new DecimalFormat(".00"); // 或者.##
        String s = df.format(d); // 把 d 转成下面设置的格局
        System.out.println(s);//3.33
   }
}

总结

万变不离其宗，Java 的其余类和性能，都离不开这些根底。牢记根底，成长的更稳！

近期热文举荐：

1.1,000+ 道 Java面试题及答案整顿(2022最新版)

2.劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4.别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞+转发哦！

关于java:1w-字总结-Java-常用类整理太全了建议收藏

罕用类概述

外部类

外部类的分类：

1.成员外部类（非动态外部类）

2.部分外部类

4.匿名外部类

Object类

Object类罕用办法：

1.equals办法

2.hashCode办法

3.toString办法

4.finzlize办法

包装类

「1.根本数据类型以及对应的包装类：」

「2.包装类的意义：」

3.包装类罕用办法：

数学类

工夫类

Java罕用工夫类：

1.Date 日期

2.Calendar 日历

3.SimpleDateFormat格式化工夫

4.计算时间差

String类

字符串类罕用办法

String Builder和StringBuffer

DecimalFormat

总结

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于java:1w-字总结-Java-常用类整理太全了建议收藏

罕用类概述

外部类

外部类的分类：

1.成员外部类（非动态外部类）

2.部分外部类

4.匿名外部类

Object类

Object类罕用办法：

1.equals办法

2.hashCode办法

3.toString办法

4.finzlize办法

包装类

「1.根本数据类型以及对应的包装类：」

「2.包装类的意义：」

3.包装类罕用办法：

数学类

工夫类

Java罕用工夫类：

1.Date 日期

2.Calendar 日历

3.SimpleDateFormat格式化工夫

4.计算时间差

String类

字符串类罕用办法

String Builder和StringBuffer

DecimalFormat

总结

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复