java常用类

鱼尾巴选手

已于 2022-04-03 15:13:58 修改

阅读量714

点赞数 1

文章标签： java 开发语言

于 2022-04-03 14:57:01 首次发布

本文链接：https://blog.csdn.net/weixin_62918925/article/details/123937763

版权

Java常用类

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层。

任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
Object类中所定义的方法，是所有对象都具备的方法。
Object类型可以存储任何对象：
- 作为参数，可接受任何对象。
- 作为返回值，可返回任何对象。

getClass()方法

public final Class<?> getClass(){}

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

hashCode()方法

public int hashCode(){}

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

toString()方法

public String toString(){}

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

equals()方法

public boolean equals(Object obj){}

默认实现为（this == obj），比较两个对象地址是否相同。
可进行覆盖，比较两个对象的内容是否相同。

equals()方法覆盖步骤：

比较两个引用是否指向同一个对象；
判断obj是否为null;
判断两个引用指向的实际对象类型是否一致；
强制类型转换；
依次比较各个属性值是否相同；

finalize()方法

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

Demo

Student类：

public class Student {

    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override   //重写toString方法
    public String toString() {
        return name + ":" + age;
    }

    @Override   //重写equals方法
    public boolean equals(Object obj) {
        if (this == obj) {//判断是否为同一个引用
            return true;
        }
        if (obj == null) {//判断obj是否为null
            return false;
        }
        if (obj instanceof Student) {//判断实际类型是否一致
            Student s = (Student) obj;//强制类型转换
            if (this.name.equals(s.name) && this.age == s.age) {
                return true;
            }
        }
        return false;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name + "对象被回收了");
    }
}

Student测试：

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

        //1.getClass()方法
        Student s1 = new Student("A", 20);
        Student s2 = new Student("B", 22);

        //判断s1、s2是不是同一种类型
        Class Class1 = s1.getClass();
        Class Class2 = s2.getClass();
        if (Class1 == Class2) {
            System.out.println("s1和s2属于同一种类型");//   √
        } else {
            System.out.println("s1和s2不属于同一种类型");
        }

        //2.hashCode()方法
        System.out.println("=======================");
        Student s3 = s1;
        System.out.println(s1.hashCode());//1163157884
        System.out.println(s2.hashCode());//1956725890
        System.out.println(s3.hashCode());//1163157884

        //3.toString()方法
        System.out.println("=======================");
        System.out.println(s1.toString());//A:20
        System.out.println(s2.toString());//B:22

        //4.equals()方法：判断两个对象是否相等
        System.out.println("=======================");
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equals(s3));//true
        //equals()方法覆盖后：
        Student s4 = new Student("小明", 3);
        Student s5 = new Student("小明", 3);
        System.out.println(s4.equals(s5));//true，未重写前为false

        //finalize()方法
        System.out.println("=======================");
        new Student("abc", 20);
        new Student("def", 20);
        System.gc();
        /*
            def对象被回收了
            abc对象被回收了
         */
    }
}

包装类

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

包装类对应

类型转换和装箱、拆箱

装箱：基本类型数据转成引用类型（栈—>堆）

拆箱：与上述装箱相反。

demo1：

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

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

        //拆箱：引用类型--->基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();

        //JDK1.5后，提供自动装箱和拆箱
        int age = 22;
        Integer integer4 = age;//自动装箱
        int age2 = integer4;//自动拆箱

    }
}

自动装箱使用的是valueOf()方法，自动拆箱使用的是intValue()方法。

8种包装类提供不同类型间的转换方式：
- Number父类中提供的6个共性方法；
- parseXXX()静态方法。
- valueOf()静态方法：基本类型转引用类型。

demo2：

public class Demo02 {
    public static void main(String[] args) {
        //基本类型和字符串之间转换
        //1. 基本类型转换成字符串
        int n1 = 100;
        //使用+号：
        String s1 = 100 + "";

        //使用Integer中的toString()方法：
        String s2 = Integer.toString(n1);


        //2. 字符串转换成基本类型
        String str = "150";
        //使用Integer.parseXXX()：
        int n2 = Integer.parseInt(str);

        //boolean字符串形式转成基本类型
        String str2 = "true";
        String str3 = "trueo";
        boolean b1 = Boolean.parseBoolean(str2);
        boolean b2 = Boolean.parseBoolean(str3);
        System.out.println(b1);//true
        System.out.println(b2);//false
    }
}

其中，注意：

使用parseXXX()方法，类型需要兼容。如str=“150y”，则parseInt(str)会报错；
boolean字符串转换时，若为"true"则是true，其它全为false。

Integer缓冲区

demo：

public class Demo03 {
    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
        Integer.valueOf(100);
    }
}

出现上面这个是因为，当我们使用自动装箱的时候，其实是使用Integer.valueOf()方法，当我们去查看valueOf方法的源码时会发现：

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

这个缓冲区为[-128,127]，那么integer3和integer4其实都是指向存着100的那个地址，所以输出结果才会为true。

String类

字符串是常量，创建之后不可改变。
字符串字面值存储在字符串池中，可以共享。

public class Demo01 {
    public static void main(String[] args) {
        String name="hello";//hello常量存在字符串池中
        name="zhangsan";//这没有修改hello的值，而是重新开辟空间
        String name2="zhangsan";//与name指向同一个“zhangsan”
    }
}

分析：

分析图

产生一个对象，字符串中存储：
```
String s = "Hello";
```

产生两个“对象”，堆和池各存储一个：

String s = new String("Hello");
String s1 = new String("Hello");
System.out.println(s==s1);//比较地址，所以为：false

常用方法

序号	内容	功能
1	public int length()	返回字符串的长度
2	public char charAt(int index)	根据下标获取字符
3	public boolean contains(String str)	判断当前字符串中是否包含str
4	public char[] toCharArray()	将字符串转换成数组
5	public int index0f(String str)	查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
6	public int lastIndex0f (String str)	查找字符串在当前字符串中最后一次出现的下标索引
7	public String trim()	去掉字符串前后的空格
8	public String toUpperCase()	将小写转成大写
9	public boolean endWith (String str)	判断字符串是否以str结尾
10	public String replace (char oldChar, char newChar)	将旧字符串替换成新字符串
11	public String[] split (String str)	根据str做拆分

包含以上方法的demo：

import java.util.Arrays;
public class Demo02 {
    public static void main(String[] args) {

        String content = "Java是一门编程语言，Java真棒Java";
        // 1. length(),返回字符串长度
        System.out.println(content.length());//22
        //2. charAt()，返回某个位置的字符
        System.out.println(content.charAt(0));//J
        //3. contains()，判断是否包含某个子字符串
        System.out.println(content.contains("Java"));//true
        System.out.println(content.contains("Python"));//false
        //4. toCharArray()，返回字符串对应的数组
        System.out.println(Arrays.toString(content.toCharArray()));
        //5. indexOf()，返回字符串首次出现的位置
        System.out.println(content.indexOf("Java"));//0
        System.out.println(content.indexOf("Java", 4));//从第4位置开始往后找：12
        //6. 返回字符串最后一次出现的位置
        System.out.println(content.lastIndexOf("Java"));//18


        String s = "   hello WORLD   ";
        String filename = "hello.java";
        //7. trim()，去掉字符串前后的空格
        System.out.println(s.trim());//中间空格还有
        //8. topUpperCase()，小写字母转大写；toLowerCase()，大写字母转小写。
        System.out.println(s.toUpperCase());//HELLO WORLD
        System.out.println(s.toLowerCase());//hello world
        //9. endsWith(str)，判断是否str结尾；endsWith(str)，判断是否str开头。
        System.out.println(filename.endsWith(".java"));//true
        System.out.println(filename.startsWith("hello"));//true

        //10. replace(oldchar,newchar)，用新的字符（串）替换久的字符（串）
        System.out.println(content.replace("Java", "Python"));//Python是一门编程语言，Python真棒Python
        //11. split()，对字符串进行拆分
        String say = "java is the best programing language";
        String[] arr = say.split(" ");//[java,is,the,best,programing,language]
        System.out.println(arr.length);//6
        for (String s1 : arr) {
            System.out.println(s1);
        }
    }
}

补充：

equals()方法和compareTo()方法：

demo：

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

        String s1="hello";
        String s2="HELLO";
        System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写的比较值：true

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

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

    }
}

我们可以知道compareTo的方法体如下：

int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;

int k = 0;
while (k < lim) {
	char c1 = v1[k];
	char c2 = v2[k];
	if (c1 != c2) {
		return c1 - c2;
	}
	k++;
}
return len1 - len2;

所以例子中的两个compareTo()方法分别是比较字典中的位置、字符串的长度。

String案例

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

public class Demo04 {
    /*
    已知String str = "this is a text" ;
    1.将str中的单词单独获取出来
    2.将str中的text替换为practice
    3.在text前面插入一个easy
    4.将每个单词的首字母改为大写
    */
    public static void main(String[] args) {
        String str = "this is a text";
        //1. ---------------------
        String[] arr = str.split(" ");
        for (String s : arr) {
            System.out.println(s);
        }

        //2. ---------------------
        System.out.println(str.replace("text", "practice"));

        //3. ---------------------
        System.out.println(str.replace("text", "easy text"));

        //4. ---------------------
        for (int i = 0; i < arr.length; i++) {
            char first = arr[i].charAt(0);
            char newfirst = Character.toUpperCase(first);
            String news = newfirst + arr[i].substring(1);
            System.out.println(news);
        }
    }
}

可变字符串

StringBuffer：可变长字符串，JDK1. 0提供，运行效率慢、线程安全。
StringBuilder：可变长字符串，JDK5. 0提供，运行效率快、线程不安全（不能同步访问，单线程使用）。
常用方法：

序号方法作用
1 append（）追加
2 insert（）插入
3 replace（）替换
4 delete（）删除

序号	方法	作用
1	append（）	追加
2	insert（）	插入
3	replace（）	替换
4	delete（）	删除

demo：

public class Demo05 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //1. append():追加
        sb.append("java编程语言");
        System.out.println(sb.toString());//java编程语言
        sb.append("java不错");
        System.out.println(sb.toString());//java编程语言java不错
        sb.append("java真香");
        System.out.println(sb.toString());//java编程语言java不错java真香

        //2. insert():添加
        sb.insert(0,"在最前面");
        System.out.println(sb.toString());//在最前面java编程语言java不错java真香

        //3. replace():替换
        sb.replace(0,4,"被替换");
        System.out.println(sb.toString());//被替换java编程语言java不错java真香

        //4. delete():删除
        sb.delete(0,3);
        System.out.println(sb.toString());//java编程语言java不错java真香
        
    }
}

BigDecimal类

位置：java.math包中。

作用：精确计算浮点数。

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

方法	说明
subtract()	减法
add()	加法
multiply()	乘法
divide()	除法

例：

public class Demo01 {
    public static void main(String[] args) {
        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,大的浮点数精确计算
        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 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r2);//1

特别：

以下语句会报错：

 BigDecimal r3=new BigDecimal("10").divide(new BigDecimal("3"));
        System.out.println(r3);

除法：divide（BigDecimal bd，int scale，RoundingMode mode）
其中参数scale：指定精确到小数点后几位；

参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式；取值为BigDecimal.ROUND_HALF_UP。

日期时间

Date

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

demo：

import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        //1. 创建Date对象
        Date date1 = new Date();
        System.out.println(date1.toString());//Sat Apr 02 11:17:26 CST 2022
        //昨天
        Date date2 = new Date(date1.getTime() - 24 * 60 * 60 * 1000);//单位是毫秒
        System.out.println(date2.toString());//Fri Apr 01 11:17:26 CST 2022

        //2. after()、before()方法
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true
        boolean b2 = date1.before(date2);
        System.out.println(b2);//false

        //3. compareTo()比较：小于-1，等于0，大于1
        int d = date2.compareTo(date1);
        System.out.println(d);//-1
    }
}

Calendar

Calendar提供了获取或设置各种日历字段的方法。其构造方法：protected Calendar() ：由于修饰符是protected，所以无法直接创建该对象。（要使用getInstance()方法）

常用方法：

方法	说明
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-Calendar
Date getTime()	返回一个Date表示此日历的时间。Calendar-Date
void add(int field,int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMillies()	毫秒为单位返回该日历的时间值

demo：

import java.util.Calendar;

public class Demo02 {
    public static void main(String[] args) {
        //1. 创建Calendar对象
        Calendar calendar=Calendar.getInstance();
        System.out.println(calendar.getTime().toString());//Sat Apr 02 13:49:48 CST 2022

        //2. 获取时间信息
        int year=calendar.get(Calendar.YEAR);//年份
        int month=calendar.get(Calendar.MONTH);//月份--->区间为：0-11
        int day=calendar.get(Calendar.DAY_OF_MONTH);//日
        int hour=calendar.get(Calendar.HOUR_OF_DAY);//24小时制
        int minute=calendar.get(Calendar.MINUTE);
        int second=calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month=1)+"月"+day+"日"+hour+":"+minute+":"+second);//2022年4月2日13:49:48

        //3. 修改时间到昨天
        Calendar calendar2=Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,1);
        System.out.println(calendar2.getTime().toString());//Fri Apr 01 13:49:48 CST 2022

        //4. add方法修改时间
        calendar2.add(Calendar.HOUR_OF_DAY,1);//加一小时
        System.out.println(calendar2.getTime().toString());//Fri Apr 01 14:49:48 CST 2022
    }
}

SimpleDateFormat

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。作用：进行格式化(日期–>文本)、解析(文本–>日期)。

常用的时间模式字母：

字母	含义	示例
y	年	2022
M	年中月份	04
d	月中天数	02
H	1天中小时数（0-23）	14
m	分钟	30
s	秒	45
S	毫秒	567

demo：

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

public class Demo03 {
    public static void main(String[] args)throws Exception{
        //1. 创建SimpleDateFormat对象
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //2. 创建Date
        Date date=new Date();
        //3. 格式化date
        String str=sdf.format(date);
        System.out.println(str);//2022-04-02 14:19:54

        //把字符串转成时间（格式要一致）
        Date date2=sdf.parse("2020-01-01 12:03:44");
        System.out.println(date2);//Wed Jan 01 12:03:44 CST 2020
    }
}

System类

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

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

数组复制demo：

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

        int[] a={1,2,3,4,5,6,7};
        int[] b=new int[7];

        //arraycopy数组的复制
        System.arraycopy(a,3,b,2,4);
        for (int i : b) {
            System.out.print(i+"\t");//0 0 4 5 6 7 0
        } 
    }

鱼尾巴选手

关注

1
点赞
踩
7

收藏

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

文章目录Java常用类Object类getClass()方法hashCode()方法toString()方法equals()方法finalize()方法Demo包装类包装类对应类型转换和装箱、拆箱Integer缓冲区String类常用方法String案例可变字符串BigDecimal类日期时间DateCalendarSimpleDateFormatSystem类Java常用类Object类超类、基类，所有类的直接或间接父类，位于继承树的最顶层。任何类，如没有书写extends显示继承某个类，都默认
复制链接

扫一扫