Java常用类

最新推荐文章于 2022-06-20 19:05:05 发布

0尼可乐0

最新推荐文章于 2022-06-20 19:05:05 发布

阅读量102

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/liu504903837/article/details/115358978

版权

Java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

常用类

1.Object类

概述：

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

Object类中常用的方法

getClass方法：方法返回值是一个Class类型。返回引用中存储的实际对象类型。

public final Class<?> getClass（）{}

应用：通常用于判断两个引用中实际存储对象类型是否一致。

public class Test{
    public static void main(String[] args) {
        //getClass方法使用
        //创建两个对象
        Student s1 = new Student("a",12);
        Student s2 = new Student("b",15);
        //调用Objct类中的getClass方法，返回两个对象的类型，并通过if语句判断两个对象是否是同一类型。
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if(class1 == class2){
            System.out.println("s1和s2为同一类型");
        }else{
            System.out.println("s1和s2不是同一类型");
        }
    }
}

（在执行之前请记的先创建一个Student类，然后再在主方法中创建对象。）

hashCode方法：返回对象为哈希码值。哈希值根据对象的地址和字符串或者数字使用hash算法计算出来的int类型的数值。一般情况下相同的对象返回相同的哈希码值。

          //输出s1和s2的哈希码值
          System.out.println(s1.hashCode());
          System.out.println(s2.hashCode());
          //创建一个对选哪个使其和s1相同
          Student s3 = s1;
          //输出s3的哈希码值
          System.out.println(s3.hashCode());//输出结果和s1的是一样的

toString方法：返回该对象的字符串表示（表现形式）。默认情况返回对象的类型和16进制的哈希值。一般情况下为了更好理解对象，会对toString方法进行重写。

System.out.println(s1.toString());
//如果不重写则输出结果类似于：com.nicholas.ChangYongClass.Demo01.Student@14ae5a5
//重写可以自己定义返回值格式，在此就不多演示了。

equals方法：可以用来比较两个对象是否相等，返回值为布尔值。默认实现（equals == obj），比较的是两个对象的地址是否相同。可进行重写，从而实现比较对象的内容是否相同。

System.out.println(s1.equals(s2));
//equals比较的是对象的地址，所以如果即使创建了两个对象值相同，判断的结果依旧是false
//重写方法可以更改判断条件实现判断内容相同则认为是同一对象。

fianlize方法：（程序猿通常不会自己调用）当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列

垃圾对象：没有被有效引用的指向此对象为垃圾对象。

垃圾回收：由GC销毁垃圾对象，释放数据存储空间。

自动回收机制：JVM内存耗尽，一次性回收所以垃圾对象。

手动回收机制：使用System.gc();通知JVM执行垃圾回收，但是依旧是JVM自行判断后才会选择执行与否。（由当前运行情况回收）

        Student s1 = new Student("a",12);
        Student s2 = new Student("b",15);
        Student s3 = new Student("a",12);
        new Student("b",15);
        new Student("b",15);
        new Student("b",15);
        System.gc();
        System.out.println("回收垃圾：");
        //后面三个没有有效的指向对象，因此被判定为垃圾对象，会被回收。

2.包装类

包装类是基本数据所对应的引用数据类型。为了能够让基本类型，提供更强大的功能，在设计jdk时对八个基本数据类型又设计了对应的引用类型。引用数据类型就可以称为是基本数据类型所对应的保护类。Object类可统一所有数据，任何对象都可以使用object类来接收，包装类属于引用类型所以包装类的默认值是null。

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

类型转换与装箱、拆箱：

基本类型转换为对象的过程被称为装箱。（基本类型转换为引用类型）
把堆中的对象拿到栈空间中被称为拆箱。（引用类型转化为基本类型为拆箱）

public class Test{
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转换成引用类型的过程。
        //定义一个基本类型
        int num1 = 10;
        //方式1:使用Integer类创建对象
        System.out.println("装箱：");
        Integer integer1 = new Integer(num1);
        System.out.println(integer1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println(integer2);

        //类型转换：拆箱，引用类型转成基本类型
        //使用Integer
        Integer integer3 = new Integer(10);
        //使用valueOf方法
        int num2 = integer3.intValue();
        System.out.println("拆箱：");
        System.out.println(integer3);
        System.out.println(num2);
        
    }
}

jdk1.5版本后提供了自动装箱与拆箱的功能：

        //自动装箱与自动拆箱
        //不需要再使用new了
        int age = 26;
        Integer integer4 = age;
        int age2 = integer4;
        System.out.println(integer4);
        System.out.println(age2);

八种包装类提供不同类型间的转换方式：

Number父类中提供的六个共性方法。可以实现引用类型转换为基本类型。jdk1.5版本后可以实现自动装箱与拆箱了。（通过编译器自动帮你转化为方法的调用）
parsexxx（）:基本类型和字符串之间的转换。

（注意：保证类型兼容，否则抛出NumberFormException异常）

基本类型准换为字符串：

        //基本类型与字符串之间的转换
        //基本类型转换为字符串
        int n1 = 100;
        //方法1：使用基本类型＋“”（空字符串）实现自动转换。
        String s1 = n1 + "";
        System.out.println(s1);
        
        //方法2：使用Integer的toString方法
        String s2 = Integer.toString(n1);
        System.out.println(s2);
        
	    //toString还有一些重载的方法可以实现将定义的变量转换为其他进制的数字
        int n2 = 15;
        String s3 = Integer.toString(n2, 16);//将n2变成16进制
        System.out.println(s3);//输出结果为f
        //toBinaryString是转化为二进制，toHe小String是转化为16进制（此方法和示例效果是一样的）

字符串类型转化为基本类型：

        //注：字符串类型转换为基本类型时，字符串中不可以出现非数字的字符
        String str = "178";
        //使用Integer中的parse方法。
        int n = Integer.parseInt(str);
        System.out.println(n);
        
        //boolean类型字符串形式转换为基本类型时，只有true能够转为true，任何非true字符串都会转化为false。
        String str2 = "true";
        boolean b = Boolean.parseBoolean(str2);
        System.out.println(b);

补充：java预先建立了256个常用的整数包装类型对象。在实际应用中，对已创建的对象进行复用。堆空间中实际上有一个-128到127的数组，即整数缓区。

public class Test{
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);
        //结果是false，因为比较的是两个对象的地址，即使属性相同，其地址也不相同。
        
        Integer integer3 = 100;
        Integer integer4 = 100;
        System.out.println(integer3 == integer4);
        //结果为true
         Integer integer5 = 200;
         Integer integer6 = 200;
        System.out.println(integer5 == integer6);
        //结果为false
        //上述原因呢，是因为自动装箱使用的方法是valueOf，而valueOf方法是有缓冲区的，范围是-128到127。
        //200不在范围内，因此得到了false的结果。
    }
}

3.String类

字符串是常量，创建之后是不可改变的。字符串的字面值存储在字符串池（在方法区），可以共享。

字符串的创建有两种方式：

String s = “Hello”;产生一个对象，字符串池中储存。
String s = new String（“Hello”）;产生两个对象，堆和字符串池中各储存一个。

1.字符串第一种创建方式：

public class Test{
    public static void main(String[] args) {
        //定义一个字符串
        String say = "Hello!";
        //将这个字符串重新进行赋值;
        say = "Hi!";
        //再定义一个字符串，其值同say的值
        String str = "Hi！";
    }
}

过程：每次定义一个新的字符串，就会将值加到字符串池中，然后字符串名字存储在栈中，字符串名指向了在字符串池内的字符串，当字符串被重新赋值时，字符串名则会指向新的字符串，但是旧的字符串并没有消失，如果后续不再有有效的指向才会被判定为垃圾，当不同的字符串名有同样的值时，则两个栈中的字符串名会指向字符串池中同一个字符串。

2.字符串的第二种创建方式：

public class Test{
    public static void main(String[] args) {
        String str1 = new String("Java");
        String str2 = new String("Java");
        System.out.println(str1 == str2);//false 因为str1和str2为两个栈中的对象，地址是不同的所以判断结果为false
        System.out.println(str1.equals(str2));//true 因为字符串之间使用equals比较的是数据而不是地址。
    }
}

3.String类型常用的方法：

public class Test{
    public static void main(String[] args) {
        //定义一个字符串
        String content = " Java 是世界 上最好 的 语言。 ";
        //字符串的长度
        System.out.println(content.length());//注意，空格也算在内的。
        //根据下标获取字符串中的字符
        System.out.println(content.charAt(content.length()-1));//输出此字符串中最后一个字符,注意下标不要越界
        //判断字符串中是否包含某字符串
        System.out.println(content.contains("Java"));
        //将字符串转换为数组
        System.out.println(Arrays.toString(content.toCharArray()));
        //查找字符串首次出现的位置下标
        System.out.println(content.indexOf("Java"));
        //也可以选择从第几个字符开始查找
        System.out.println(content.indexOf("上",3));
        //查找字符串最后一次出现的位置下标
        System.out.println(content.lastIndexOf("a"));
        //去掉字符串前后的空格
        System.out.println(content.trim());
        //将小写转换为大写
        System.out.println(content.toUpperCase());
        //将大写转化为小写
        System.out.println(content.toLowerCase());
        //判断字符串是否以某个字符结尾.(开始使用startWith方法)
        System.out.println(content.endsWith("a"));
        //将就字符替换为新字符
        System.out.println(content.replace("Java","Python"));
        //根据某个字符做拆分
        String str = "Java is the best programing language.";
        String[] arr = str.split("[ ,]");//表示遇到空格和逗号都会做拆分。
        for (String s : arr) {
            System.out.println(s);
        }
    }
}

补充：equals()、compareTo（）

public class Test{
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "hello";
        System.out.println(s1.equals(s2));//普通判断值是否相等
        System.out.println(s1.equalsIgnoreCase(s2));//忽略大写小判断是否相等

        //compareTo是比较大小用的，比较的是字典表的顺序。A比B则会计算A在字典表的位置减去B在字典表的位置
        String s3 = "abc";
        String s4 = "xyz";
        System.out.println(s3.compareTo(s4));//只比第一位，如果第一位相同则比第二位
        
        //特殊的
        String s5 = "abc";
        String s6 = "abcxyz";
        //这种情况下则会比较字符串长度。
    }
}

4.StringBuffer与StringBuilder

StringBuffer：可变长字符串，jdk1.0提供，运行效率慢，线程安全。 String 的增强类，会提前开辟一些缓冲区，操作时在缓冲区进行操作，可以提高效率并节省内存。

常用的方法：

append（）：在最后添加
insert（）：在任意位置添加
replace（）：替换
delete（）：删除，可以用于清空（x.delete(0,x.length())）

不常用的方法：

reverse（）：翻转

StringBuilder：同StringBuffer，由jdk1.5提供，区别只有此类运行效率快，线程不安全。单线程建议使用StringBuilder。

66public class Test{
    public static void main(String[] args) {
        //创建一个新对象
        StringBuffer strB = new StringBuffer();
        //追加
        strB.append("java世界第一");
        System.out.println(strB.toString());
        strB.append("java真香");
        System.out.println(strB.toString());
        //添加
        strB.insert(0,"我在最前面");//填写添加位置以及添加内容
        System.out.println(strB.toString());
        //替换
        strB.replace(0,5,"Hello");//填写起始坐标
        System.out.println(strB.toString());
        //删除
        strB.delete(0,5);//填写起始坐标
        System.out.println(strB.toString());

    }
}

验证StringBuilder运行速度高于String：

public class Test{
    public static void main(String[] args) {
       long start1 = System.currentTimeMillis();
       String str1 = "";
        for (int i = 0; i < 999; i++) {
            str1 += 1;
        }
        System.out.println(str1);
        long end1 = System.currentTimeMillis();
        System.out.println("用时："+ (end1 - start1));//用时：6

        long start2 = System.currentTimeMillis();
        StringBuilder str2 = new StringBuilder();
        for (int i = 0; i < 999; i++) {
            str2.append(i);
        }
        System.out.println(str2.toString());
        long end2 = System.currentTimeMillis();
        System.out.println("用时："+ (end2 - start2));//用时：0
    }
}

这次把数字设置成999了，设置成更大，效果会更明显。

5.BigDecimal（高精度运算）

思考：当使用double定义两个变量比如1.0和0.9，做减法运算，我们会发现结果并不是0.1，这是因为double类型和float类型的数字只是近似值。而很多实际应用中，我们需要用到高精度运算或储存，则double和float就无法满足了，于是就需要用到BIgDecimal类。

位置：java.math

创建方式：BIgDecimal x = new BigDecimal(“1.0”);

常用的运算方法：

add(); 加法
substract(); 减法
multiply(); 乘法
divide()；除法

除法由于其位数的不确定性，会使用有一些参数：如参数mode可以制动小数部分的取舍模式，例如常用的四舍五入：BIgDecimal.ROUND_HALF_UP。

//BigDecemal的使用
public class Test{
    public static void main(String[] args) {
        //创建两个BigDecimal对象
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        BigDecimal bd3 = new BigDecimal("0.5");
        //字符串运算不能直接用运算符，而要通过方法实现运算
        BigDecimal r1 = bd1.add(bd2);//实现加法
        System.out.println(r1);
        BigDecimal r2 = bd1.subtract(bd2);//实现减法
        System.out.println(r2);
        BigDecimal r3 = bd1.multiply(bd2);//实现乘法
        System.out.println(r3);
        BigDecimal r4 = bd1.divide(bd3);//实现除法
        System.out.println(r4);

        //但是由于除法经常会遇到无法除尽的问题，这时候直接使用divide方法就会抛出异常，需要使用divide的重载方法，使用参数
        //下面直接使用链式编程实现
        //保留两位小数，并进行四舍五入
        BigDecimal r5 = new BigDecimal(10).divide(new BigDecimal(0.3),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(r5);
    }
}

6.Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calender类中的方法所取代。jdk1.0出现，1.1之后被取代，由于考虑不全面。1.8后出现了新的API。

public class Test{
    public static void main(String[] args) {
        //输出当期那日期时间
        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);
        //after和before判断两个时间的先后
        boolean b1 = date1.after(date2);
        System.out.println(b1);
        boolean b2 = date2.after(date1);
        System.out.println(b2);

        //compareTo（）方法：比较毫秒值
        int d = date1.compareTo(date2);
        System.out.println(d);//结果为1
        int f = date2.compareTo(date1);
        System.out.println(f);//结果为-1

        //equals方法,判断两个时间是否相等
        boolean b3 = date1.equals(date2);
        System.out.println(b3);
    }
}

7.Calender

获取或设置各种日历字段的方法

构造方法：由protected修饰符修饰，所以无法直接通过构造方法创建该对象。需要使用提供的方法getInstance（）来创建对象。

public class Test{
    public static void main(String[] args) {
        //创建实例对象并输出结果
        Calendar calendar = Calendar.getInstance();
        //将结果转成date输出
        System.out.println(calendar.getTime().toLocaleString());
        //输出1970年到现在的毫秒值
        System.out.println(calendar.getTimeInMillis());

        //获取时间信息
        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);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+month+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");

        //修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,5);//将修改内容写在后面
        System.out.println(calendar2.getTime().toLocaleString());

        //补充确定每个时间段最大值和最小值
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);//本月最多有多少天
        System.out.println(min);//本月最小的那天号数
    }
}

8.SimpleDateFormat:

以语言环境有关的方式来格式化和解析日期的具体类；格式化：日期—>文本。解析：文本—>日期

常用的时间模式字母

字母	日期或时间	示例
y	日期或时间	2019
M	年中的月份	08
d	月中的天数	10
H	一天中小时数	22
m	分钟	16
s	秒	59
S	毫秒	367

//SimpleDateFormat使用
public class Test{
    public static void main(String[] args) throws ParseException {
        //创建一个SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH：mm：ss");
        //创建Date
        Date date = new Date();
        //格式化date（把日期转化为字符串）
        String str = sdf.format(date);
        System.out.println(str);
        //解析：把时间字符串转化为日期
        Date date1 = sdf.parse("1995年12月21日15：12：10");
        System.out.println(date1);
    }
}

9.System类

系统类：主要用于获取系统的属性数据和其他操作，构造方法是私有的。使用不需要创建对象，方法都是静态的，直接用“.”调用即可。

System类常用的方法：

arraycopy（）；复制数组。
currentTimeMillies（）；获取当前系统时间，返回值是毫秒。
void gc（）；建议jvm启动垃圾回收器回收垃圾。
exit（）；退出jvm，如果参数是0表示正常退出jvm，非零表示异常退出jvm。

/SimpleDateFormat使用
public class Test{
    public static void main(String[] args) throws ParseException {
        //数组复制
        //src：源数组
        //srcPos:复制的起始位置
        //dest:目标数组
        //destPos：目标数组的位置
        //length:复制的长度
        int [] arr = {12,34,56,78,25,47,59,87};
        //定义一个与源数组相同容量的数组
        int [] dest = new int[8];
        //从源数组的第四个数开始复制，然后从目标函数的第六个数开始粘贴，复制的长度为3（即复制3个数）
        System.arraycopy(arr,3,dest,5,3);
        //遍历输出数组，未复制的部分都默认是0
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
        //Arayys.copyOf()的源码就是使用的System.arrytcopy

        //输出1970年到现在的毫秒值，可以利用前后的差值计算代码执行的时间
        System.out.println(System.currentTimeMillis());

        //gc():垃圾回收,取决于当前内存使用情况，不需要回收可能会再等一段时间才会执行。
        System.gc();

        //退出jvm
        System.exit(0);//0是正常输出。1是非正常输出
        System.out.println("程序结束了！");//这句话不会执行，因为在执行前就已经退出程序了。

    }
}

10.结语

常用类总算总结完了，其实这一部分不是很难，但是小的点又蛮多，真令人头秃。加油加油！！

0尼可乐0

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java常用类

常用类1.Object类概述：Object类为所有类的直接或间接父类，位于继承树的顶层，被称为超类（基类）。任何类如果没有写extends显示继承某个类，都默认直接继承Object类。否则为间接继承，也因此Object类中所定义的方法，是所有对象都具备的方法。Object类型可以存储任何对象，作为参数，可以接受任何对象，作为返回值，可以返回任何对象。Object类中常用的方法getClass方法：方法返回值是一个Class类型。返回引用中存储的实际对象类型。public final Clas
复制链接

扫一扫