Java常用类（Object、包装类、String、BigDecimal、Date，Calendar、System）

最新推荐文章于 2024-08-09 09:30:00 发布

xbd_zc

最新推荐文章于 2024-08-09 09:30:00 发布

阅读量181

点赞数

分类专栏： java基础文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/xbd_zc/article/details/121481827

版权

java基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Java常用类（Object、包装类、String、BigDecimal、Date，Calendar、System）

文章目录

Java常用类（Object、包装类、String、BigDecimal、Date，Calendar、System）

Object类
包装类

1、Object类

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

1.1、getClass()方法

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

		Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",22);
        //判断s1和s2是不是同一个类型
        Class c1 = s1.getClass();
        Class c2 = s2.getClass();
        if (c1==c2){
            System.out.println("同一类型");
        }else{
            System.out.println("不同类型");
        }

1.2、hashCode()方法

返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型数值

一般情况下相同对象返回相同哈希值

        System.out.println(s1.hashCode());//460141958
        System.out.println(s2.hashCode());//1163157884
        Student s3 = s2;
        System.out.println(s3.hashCode());//1163157884

1.3、toString()方法

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

//重写toString方法，Alt+insert----toString
	@Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
		//toString
        System.out.println(s1.toString());//Student{name='aaa', age=20}
        System.out.println(s2.toString());//Student{name='bbb', age=22}

1.4、equals()方法

可以用来比较两个对象是否相等，相等-true

        //equals方法，判断两个对象是否相等
        System.out.println(s1.equals(s2));//false
        Student s4 = new Student("ccc",11);
        Student s5 = new Student("ccc",11);
        System.out.println(s4.equals(s5));//false

这里比较的是对象的地址值，如果想要比较值，可以重写equals方法

重写步骤

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

	@Override
    public boolean equals(Object o) {
        //1比较两个引用是否指向同一个对象
        if (this == o) return true;
        //2判断obj是否为null
        if (o == null ) return false;
        //3判断两个引用指向的实际对象类型是否一致
//        if(this.getClass()==o.getClass()){}
        //instanceof 判断对象是否是某种类型
        if (o instanceof Student) {
            //4强制类型转换
            Student s = (Student) o;
            //5比较属性
            if (this.name.equals(s.getName()) && this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }

2、包装类

基本数据类型所对应的引用类型
- 基本数据类型都是存在栈中
- 引用类型存在堆中
Object可同一所有数据，包装类的默认值是null

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

2.1、类型转换与装箱、拆箱

装箱基本类型转换为引用类型
拆箱引用类型转换为基本类型

2.2、8种包装类提供不同类型间的转换方式

2.2.1、Nmber父类中提供6个共性方法：抽象类`Number`是表示数字值可转换为基本数据类型平台类的超类`byte` ， `double` ， `float` ， `int` ， `long`和`short` 。

装箱拆箱Integer类

	public static void main(String[] args) {
        //类型转换：装箱-基本类型转成引用类型的过程
        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 = 30;
        //自动装箱
        Integer integer4 = age;
        //自动拆箱
         int age2 = integer4;
    }
-------------------------------------------源码
public class Demo1 {
    public Demo1() {
    }

    public static void main(String[] args) {
        int num1 = 18;
        new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        Integer integer3 = new Integer(100);
        int num2 = integer3;
        int age = 30;
        Integer integer4 = Integer.valueOf(age);
        int age2 = integer4;
    }
}

2.2.2、基本类型和字符串之间转换

	public static void main(String[] args) {
        //基本类型和字符串之间转换
        //1、基本类型转成字符串
        int n1 = 100;
        //1.1使用+“”
        String s1 = n1+"";
        //1.2使用Integer中的toString方法
        String s2 = Integer.toString(n1);
        System.out.println(s1);//100
        System.out.println(s2);//100
        //2、字符串转成基本类型
        String str = "110";
        //使用Integer.parseXXX();
        int n2 = Integer.parseInt(str);//字符串中只能有数字
        System.out.println(n2);//110
        //3、字符砖形式转成boolean。“true”可以转true，不是true都转成false
        String str2 = "true";
        String str3 = "tru";
        boolean b1 = Boolean.parseBoolean(str2);
        boolean b2 = Boolean.parseBoolean(str3);
        System.out.println(b1+"---"+b2);//true---false
    }

2.3Integer缓冲区

Java预先创建了256个常用的整数包装类型对象（-128 ~ 127）
在实际应用中，对已创建的对象进行复用

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
    }

100在已创建好的对象中进行赋值
200不在范围内，重写new了一个

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

3、String类

String

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

    public static void main(String[] args) {
        String name = "hello";//存储在字符串池中
        //创建之后不可以改变
        name = "张三"; //给字符串重新赋值,是在字符串池中重新建了一个“张三”,再把name指向“张三”
        //常量共享
        String name2 = "张三";//检测到字符串池中有“张三”,把name2也指向“张三”
    }

String s = “hello”;产生一个对象，字符串池中存储
String s = new String(“hello”); 产生了两个对象，堆、池个存储一个

    public static void main(String[] args) {
        String name = "hello";//存储在字符串池中
        //创建之后不可以改变
        name = "张三"; //给字符串重新赋值,是在字符串池中重新建了一个“张三”,再把name指向“张三”
        //常量共享
        String name2 = "张三";//检测到字符串池中有“张三”,把name2也指向“张三”

        //字符串的另一种创建方式 new String
        String str = new String("java");
        String str2 = new String("java");
        System.out.println(str==str2);//false ,new 创建了两个对象，地址不一样
        System.out.println(str.equals(str2));//true
    }

3.1常用方法

1 public int length():返回字符串的长度
2 public char charAt(int index) 获取下标字符
3 public boolean contains(String str) 判断字符串中是否包含str
4 public char[] toCharArray() 将字符串转换成数组
5 public int indexOf(String str) 查找str首次出现的下标,存在,则返回该下标;不存在,则返回-1。
6 public int lastIndexOf(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做拆分
12 equals：比较字符串是否相等, compareTo：比较大小

    public static void main(String[] args) {
        //1  length();返回字符串的长度
        String str = "aabbcc啊啊啊";
        System.out.println(str.length());//9 ,字母算一个
        //2  charAt();返回某个位置的字符
        System.out.println(str.charAt(1));//a
        System.out.println(str.charAt(str.length()-1));//啊  取最后一个字符
        //3  contains(String str);判断是否包含某个子字符
        System.out.println(str.contains("啊"));//true
        System.out.println(str.contains("俺"));//false
        //4  toCharArray();返回字符串对应的数组
        System.out.println(str.toCharArray());//aabbcc啊啊啊
        System.out.println(Arrays.toString(str.toCharArray()));//[a, a, b, b, c, c, 啊, 啊, 啊]
        //5  indexOf();返回字符串首次出现的位置
        System.out.println(str.indexOf("b"));//2
        System.out.println(str.indexOf("b",3));//3 ,从第几个下标开始找
        //6  lastIndexOf(); 返回字符串最后一次出现的位置
        System.out.println(str.lastIndexOf("c"));//5
        //7  trim() 去字符串前后的空格
        String str2 = "   hello  worldD  ";
        System.out.println(str2.trim());//hello  worldD
        //8  toUpperCase() 把小写转成大写,toLowerCase();大转小
        System.out.println(str2.toUpperCase());//   HELLO  WORLDD
        System.out.println(str2.toLowerCase());//   hello  worldd
        //9  endWith(str) 判断是否以str结尾，startWith(str)以str开头
        String str3 = "hello.java";
        System.out.println(str3.endsWith(".java"));//true
        System.out.println(str3.startsWith("hello"));//true
        //10  replace(char oldChar,char newChar) newChar替换oldChar
        String str4 = "你 真 帅";
        System.out.println(str4.replace("你","我"));//我 真 帅
        //11  split(str);根据str拆分字符串
        String[] arr =str4.split(" ");
        for (String string: arr) {
            System.out.print(string+"@");//你@真@帅@
        }
        //12  equals：比较字符串是否相等, compareTo：比较大小
        String s1 = "hello";
        String s2 = "Hello";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true 忽略大小写比较
        String s3 = "abc";//字典表 a:97
        String s4 = "xyz";//字典表 x:120
        //第一个字符相等就比第二个
        System.out.println(s3.compareTo(s4));//-23   a-x : 97-120=-23
        String s5 = "abcxyz";//如果前面一样就比长度，6-3
        System.out.println(s5.compareTo(s3));//3
    }

3.2 案例

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

    public static void main(String[] args) {
        String str = "this is a text";
        //1. 将str中的单词单独提取出来
        String[] arr =   str.split(" ");
        for (String s : arr) {
            System.out.println(s);
        }
        //2. 将str中的text替换为practice
        System.out.println(str.replace("text","practice"));//this is a practice
        //3. 在test前面插入一个easy
        System.out.println(str.replace("text","easy text"));//this is a easy text
        //4. 将每个单词的首字母改为大写
        for (int i = 0; i < arr.length; i++) {
            //获取首字母
            char first = arr[i].charAt(0);
            //把首字母转成大写，char对应Character
            char upper = Character.toUpperCase(first);
            //subString :截取
            String news =upper+arr[i].substring(1);//首字母+第二位以后的字符
            System.out.print(news+" ");//This Is A Text
        }
    }

3.3 StringBuffer和StringBuilder

StringBuffer:可变长字符串，JDK1.0提供，运行效率慢、线程安全
- 开辟一个缓冲区，直接在上面操作
StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全
单线程情况下可以使用StringBuilder

3.3.1常用方法

public static void main(String[] args) {
        /*
        和String比较 ，比String效率高，更节省内存
         */
        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真香
        //2 insert();添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());//我在最前面java天下第一java真香
        //3 replace(); 替换
        sb.replace(0,5,"hello");//替换第0位到第五位直接的值
        System.out.println(sb.toString());//hellojava天下第一java真香
        //4 delete();删除
        sb.delete(0,5);//删除第0位到第五位直接的值
        System.out.println(sb.toString());//java天下第一java真香
        //5 清空
        sb.delete(0, sb.length());
        System.out.println(sb.length());//0
    }

3.3.2对比String，StringBuffer，StringBuilder效率

        /*
        对比String，StringBuffer，StringBuilder效率
         */
        long start = System.currentTimeMillis();
//        String str = "";
        StringBuffer sb = new StringBuffer();
//        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 999999; i++) {
//            str+=i;
            sb.append(i);
        }
        long end = System.currentTimeMillis();
        //String 17914    		i=99999
        //StringBuffer  40		i=999999
        //StringBuilder 35		i=999999
        System.out.println(end-start);
    }

4、BigDecimal

浮点数计算时需要借助BigDecimal工具
double是近似值存储，精度不够

    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
    }

方法

    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
        //double是近似值存储，精度不够
        //BigDecimal，大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");//使用字符串
        BigDecimal bd2 = new BigDecimal("0.9");//使用字符串
        //加法
        BigDecimal r1 = bd1.add(bd2);//bd1+bd2
        System.out.println(r1);//1.9
        //减法
        BigDecimal r2 = bd1.subtract(bd2);//bd1-bd2
        System.out.println(r2);//0.1
        // 乘法
        BigDecimal r3 = bd1.multiply(bd2);//bd1*bd2
        System.out.println(r3);//0.90
        // 除法
//        BigDecimal r4 = bd1.divide(bd2);//bd1/bd2，
        //.ArithmeticException 出现异常，无法除尽
        BigDecimal r4 = bd1.divide(bd2,2,BigDecimal.ROUND_HALF_UP);
        //2:保留两位小数，BigDecimal.ROUND_HALF_UP：四舍五入
        System.out.println(r4);//1.11
        //计算 (1.4-0.5)/0.9
        BigDecimal r5 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r5);//1
    }

加：add
减：subtract
乘：multiply
除：divide
- 除不尽的会报异常：ArithmeticException，可以加参数：divide(num,N,BigDecimal.ROUND_HALF_UP)
- N:保留几位小数，BigDecimal.ROUND_HALF_UP：四舍五入

5、Date

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

在JDK 1.1之前， Date有两个附加功能。它允许将日期解释为年，月，日，小时，分钟和第二个值。它还允许格式化和解析日期字符串。不幸的是，这些功能的API不适合国际化。从JDK 1.1开始， Calendar类应该用于在日期和时间字段之间进行转换，并且DateFormat类应用于格式化和解析日期字符串。在相应的方法Date被弃用。

构造方法 
            
          Constructor and Description 
Date() 
分配一个 Date对象，并初始化它，以便它代表它被分配的时间，测量到最近的毫秒。  

boolean after(Date when) 
测试此日期是否在指定日期之后。  
boolean before(Date when) 
测试此日期是否在指定日期之前。  
Object clone() 
返回此对象的副本。  
int compareTo(Date anotherDate) 
比较两个日期进行订购。  
boolean equals(Object obj) 
比较两个日期来平等。  
static Date from(Instant instant) 
从 Instant对象获取一个 Date的实例。

6、Calendar

提供获取或设置各种日历字段的方法
构造方法

Modifier	Constructor and Description
`protected`	`Calendar()` 构建具有默认时区和默认的 `FORMAT`语言环境的日历。
`protected`	`Calendar(TimeZone zone, Locale aLocale)` 构造具有指定时区和区域设置的日历。

常用方法

演示

    public static void main(String[] args) {
        //1,创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());//2021-11-22 21:03:26
        System.out.println(calendar.getTimeInMillis());//1637586206381 1970年到现在的时间
        //2,获取时间信息
        int year = calendar.get(Calendar.YEAR);//年，也可以，calendar.get(1)
        int month = calendar.get(Calendar.MONTH);//月0-11
        int day = calendar.get(Calendar.DAY_OF_MONTH);//日
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR 12小时，HOUR_OF_DAY 24小时
        int second = calendar.get(Calendar.SECOND);//秒
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"时"+second+"秒");
        //3，修改时间
        Calendar c1 = Calendar.getInstance();
        c1.set(Calendar.DAY_OF_MONTH,5);//修改为5号
        //4 add方法修改时间
        c1.add(Calendar.HOUR,-1);//减1小时
        //5获取最大/小值
        int max = c1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = c1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println("max："+max+" min : "+min);//max：30 min : 1
    }

7、SimpleDateFormat

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

请添加图片描述

    public static void main(String[] args) throws Exception {
        //1、创建对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        //2 创建Date
        Date date = new Date();
        //格式化date 把日期转成字符串
        System.out.println(sdf.format(date));
        //解析，把字符串转成日期
        Date date2 = sdf.parse("1990/09/09 11:11:11");//要跟实例化的参数格式一致
        System.out.println(date2);//Sun Sep 09 11:11:11 CDT 1990
    }

8、System类

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

    public static void main(String[] args) {
        //1 arraycopy数组复制
        //1 scr:源数组，2 srcPos:从哪个位置开始复制 0 ，3 dest:目标数组，4 destPos:目标数组位置
        int[] arr = {11,22,3,45,31,5,113,5};
        int[] dest = new int[8];
        System.arraycopy(arr,0,dest,0,arr.length);
        for (int i : dest) {
            System.out.print(i+" ");//11 22 3 45 31 5 113 5
        }
        //2 currentTimeMillis);返回系统时间，毫秒
        System.out.println(System.currentTimeMillis());//可以用来做计时
        //3 System.gc() ,垃圾回收，由系统决定
        //4 退出jvm
        System.exit(0);
        System.out.println("1111111111111111111111");
    }

xbd_zc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java常用类（Object、包装类、String、BigDecimal、Date，Calendar、System）

Java常用类（Object、包装类、String、BigDecimal、Date，Calendar、System）Object类包装类1、Object类超类、基类，所有类的直接或间接父类，位于继承树的最顶部任何类、如没有写extends显示继承某个类，都默认直接继承Object类、否则为间接Object类中所定义的方法，是所有对象都具备的方法Object类型可以存储任何对象作为参数，可以接收任何对象作为返回值，可以返回任何对象1.1、getClass()方法返回引用中
复制链接

扫一扫