Java常用类

最新推荐文章于 2024-05-07 10:08:01 发布

漫鲸

最新推荐文章于 2024-05-07 10:08:01 发布

阅读量51

点赞数

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

本文链接：https://blog.csdn.net/m0_50851235/article/details/119969891

版权

JavaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Object类

简介

类层次结构最顶层的基类，所有类都直接或者间接继承该类。

构造方法

Object()

常用成员方法

int hashCode() 一般情况下，相同对象返回相同的哈希码
Class<?>getClass() 返回引用存储的实际对象类型，通常用于判断两个引用中实际存储对象类型是否一致
String toString() 返回该对象的字符串表示，可以根据程序的需求重写该方法
boolean equals() 比较两个对象的地址是否相同，可进行覆盖，比较两个对象内容是否相同
finalize() 当对象被判定为垃圾对象时，由JVM自动调用此方法

注意:Object属于java.lang包下的类，可以直接使用，不用导包

子类重写方法

有时候我们定义类之后，可以在类中重写Object类中的成员方法，常用的有toString()方法、equals()方法

//举例：重写equals()方法
public boolean equals(Object obj){
    //1.判断是否是同一个对象的引用
    if(this==obj) {
        return true;
    }
    //2.判断是否为空
    if(obj==null) {
        return false;
    }
    
    if(obj instanceof Student) {
        Student s = (Student) obj;
        return this.id==s.id;
    }
    return false;
}
//equals()方法通常是比较两个对象是否相等，
//重写之前可以认为比较的是地址值，
//重写之后是比较对象属性的内容是否一致

String类

简介

字符类，每一个字符串对象都是常量。（此处的“常量”并不是说不能改变所指值，字符串字面值存储在字符串池（在方法区）中，可以共享，修改并没有修改数据，而是重新开辟了空间）

构造方法（不止下面两种）

String(byte[]) 将指定的字节数组–>字符串
String(char[]) 将指定的字符数组–>字符串

常用成员方法

判断功能

equals(String) 比较两个字符串是否相等，区分大小写
equalsIgnoreCase(String) 比较两个字符串是否相等，不区分大小写
startsWith(String str)判断是否以str开头
endsWith(String str)判断是否以str结尾
isEmpty() 是否为空
compareTo(String) 比较两个字符串的大小/长度
boolean contains(String str)判断是否包含某个字符串

获取功能

int length() 返回字符串的长度
char charAt(int index) 返回某个位置的字符
int indexOf(String str) 查找str首次出现的下标，不出现返回-1
int lastIndexOf(String str) 查找str最后一次出现的下标
String substring(int,int) 返回两个索引之间的子串，含头不含尾
String substring(int) 返回从该索引到最后一个索引的子串

转换功能

byte[] getBytes() 获取该字符串的字节数组
char[] toCharArray() 将字符串–>字符数组
static String valueof(…)
String replace(old,new) 用新字符（串）替换老字符（串）
String[] split(String str) 根据str做拆分
String trim() 去掉字符串前后的空格
String toUpperCase() 将小写转换成大写
String toLowerCase() 将大写转换成小写

实例

字符串相等的比较和拆分

package com.opp.demo02;

public class StringTest {
    public static void main(String[] args) {
        String s1 = "java";
        String s2 = "java";
        System.out.println(s1==s2);//true
        System.out.println(s1.equals(s2));//true

        System.out.println("********************");
        String s3 = new String("java");
        String s4 = new String("java");
        System.out.println(s3==s4);//false
        System.out.println(s3.equals(s4));//true

        System.out.println("********************");
        String s = "java is the best programing language,   yes,,oh";
        String[] arr = s.split("[ ,]+");//表示按空格和逗号拆分，+表示连续的空格和逗号也算
        for (String s5 : arr) {
            System.out.println(s5);
        }

        /*
        java
		is
		the
		best
		programing
		language
		yes
		oh
		*/
    }
}

注意点

String s = "hello";

String s1 = new String("hello");

//上面两个都是创建字符串的方法，但二者有区别。
//第一个是产生一个对象，在字符串池中存储（地址存在栈中）；
//第二个是产生一个对象，堆和栈中都有存储，栈中存放的是堆里的地址。

字符串的compareTo方法

String s1 = "abc";
String s2 = "ayza";
System.out.println(s1.compareTo(s2));//-23 该次比较的是两个字符串的大小,字符串中的字符依次比较

String s3 = "abcxyz";
System.out.println(s1.compareTo(s3));//-3 该次比较的是长度

StringBuilder和StringBuffer类

简介

可变字符序列，用于构造字符串对象，前者效率高，在java.lang包下；
与String的区别：效率比String高，比String节省内存；
StringBuilder：运行效率快，线程不安全；StringBuffer：运行效率慢，线程安全

常用构造方法

StringBuilder()
StringBuilder(String)

常用成员方法

StringBuilder append(…) 追加，返回自身
StringBuilder insert() 可以在任何索引处增加
StringBuilder replace( , , ) 可以指定索引间替换（含头不含尾）
StringBuilder delete() 删除指定索引间字符串

Date类

Date类中很多方法已经被Calendar所取代

构造方法

Date() 精确到毫秒
Date(long)

成员方法

long getTime()
int get(int field)
void set(int field,int value)

实例

package com.opp.demo02;

import java.util.Date;

public class DateTest {
    public static void main(String[] args) {
        //今天
        Date date1 = new Date();
        System.out.println(date1.toLocaleString());//2021-8-27 15:58:26  该方法已经过时，但还能用

        //昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());//2021-8-26 15:58:26

        //after() before()
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true

        boolean b2 = date1.before(date2);
        System.out.println(b2);//false

        //compareTo()
        int d = date2.compareTo(date1);
        System.out.println(d);//-1

        //equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3);//false
    }
}

Calendar类

构造方法

protected calendar() 由于修饰符是protected，因此无法直接创建该对象

常用成员方法

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

实例

package com.opp.demo02;

import java.util.Calendar;

public class CalendarTest {
    public static void main(String[] args) {
        //1.创建一个Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());//2021-8-28 10:01:36
        System.out.println(calendar.getTimeInMillis());//1630116096450

        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);//Calendar.YEAR=1
        //获取月 0-11
        int month = calendar.get(Calendar.MONTH);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);//也可以是Calendar.DATE
        //获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR_OF_DAY是24小时制，HOUR是12小时制
        //获取分钟
        int minute = calendar.get(Calendar.MINUTE);
        //获取秒
        int second = calendar.get(Calendar.SECOND);
        //输出
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+" "+hour+":"+minute+":"+second);//2021年8月28日 10:1:36

        //3.修改时间
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH, 5);//设置“日”为5
        System.out.println(calendar1.getTime().toLocaleString());//2021-8-5 10:01:36

        //4.add方法
        calendar1.add(Calendar.DAY_OF_MONTH,-1);
        System.out.println(calendar1.getTime().toLocaleString());//2021-8-4 10:01:36

        //5.补充方法
        int max = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);//31
        System.out.println(min);//1
    }

}

SimpleDateFormat类

简介

SimpleDateFormat类是一个以语言环境有关的方式来格式化和解析日期的具体类；进行格式化（日期—>文本）；进行解析（文本—>日期）

常用的时间模式字母

字母	日期/时间	示例
y	年	2019
M	年中的月份	08
d	月中的天份	10
H/h	天中的小时数（0-23/0-11）;H:24小时制；h:12小时制	22
m	分钟	16
s	秒	59
S	毫秒	367

实例

package com.opp.demo02;

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

public class SdfTest {
    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();
        //格式化
        String str = sdf.format(date);
        System.out.println(str);//2021/08/28 14:59:17

        //解析
        String str1 = "2021/07/30 17:10:00";
        Date date1 = sdf.parse(str1);//要抛出异常
        System.out.println(date1);//Fri Jul 30 17:10:00 CST 2021
    }
}

基本类型的包装类

简介

基本数据类型所对应的引用数据类型，包装类的默认值是null

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

装箱

基本类型—>包装类型

int num = 18;
Integer integer = new Integer(num);
Integer integer2 = Integer.valueOf(num);

拆箱

包装类型—>基本类型

Integer integer3 = new Integer(100);
int num2 = integer3.intValue();

JDK1.5之后，可以自动装箱和拆箱

int age = 30;
Integer integer4 = age;//自动装箱

int age2 = integer4;//自动拆箱

常用方法

static 基本类型 parseXXX(String) 将字符串—>对应的基本类型，Character中没有parseXXX方法，因为如果将字符串转换成字符类型，可以使用String类中的toCharArray(),charAt()方法

实例

package com.opp.demo02;

public class ChangeTest {
    public static void main(String[] args) {
        //基本类型--->字符串
        int n1 = 255;
        //1.1使用+号
        String s1 = n1 + "";

        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(n1, 16);//16进制
        System.out.println(s1);//255
        System.out.println(s2);//ff

        //字符串--->基本类型
        String s = "150";
        int n2 = Integer.parseInt(s);
        System.out.println(n2);//150

        //布尔字符串形式--->布尔基本类型
        //“true"--->true,非"true"--->false
    }
}

补充

Integer缓冲区（整数缓冲区）

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

package com.opp.demo02;

public class IntegerTest {
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);//false

        //相当于Integer integer3 = Integer.valueOf(100);
        Integer integer3 = 100;
        //相当于Integer integer4 = Integer.valueOf(100);
        Integer integer4 = 100;
        System.out.println(integer3==integer4);//true

        //相当于Integer integer5 = Integer.valueOf(200);
        Integer integer5 = 200;
        //相当于Integer integer6 = Integer.valueOf(200);
        Integer integer6 = 200;
        System.out.println(integer5==integer6);//false
    }
}

BigDecimal类

简介

在java.math包下，用于精确计算浮点数。

常用方法

BigDecimal add() 加法
BigDecimal multiply() 乘法
BigDecimal divide() 除法 divide(除数,2,BigDecimal.ROUND_HALF_UP)第二个参数为“保留位数”，第三个参数为保留法则，例子中为四舍五入

实例

package com.opp.demo02;

import java.math.BigDecimal;

public class BigDecimalTest {
    public static void main(String[] args) {
        /*
        很多实际应用中要求精确运算，而double是近似值存储。
        不再符合要求，需借助BigDecimal类
         */
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);//0.09999999999999998

        BigDecimal bd = new BigDecimal("1.0");
        BigDecimal bd1 = new BigDecimal("0.9");

        BigDecimal result = bd.subtract(bd1);
        System.out.println(result);//0.1
    }
}

System类

简介

系统类，主要用于获取系统的属性数据和其他操作。

常见方法

static void arraycopy(…) 复制数组
static long currentTimeMillis() 获取当前系统时间，返回毫秒值
static void gc() 建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status) 退出JVM，参数为0正常退出；非0异常退出

实例

package com.opp.demo02;

public class SystemTest {
    public static void main(String[] args) {
        //1.arraycopy()复制数组
        int [] src = {10,20,30,40,50,60,70,80};
        int [] dest = new int[8];
        System.arraycopy(src,0,dest,0,src.length);
        for (int i : dest) {
            System.out.print(i + " ");
        }//10 20 30 40 50 60 70 80
        System.out.println();

        //2.currentTimeMillis()获取当前系统时间，返回时间的毫秒值
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            for (int j = 0; j < 100; j++) {
                int sum = i + j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时："+(end-start));//耗时：5

        //3.gc()建议jvm赶快启动垃圾回收器回收垃圾
        //System.gc()

        //4.exit()退出jvm
        //System.exit()
    }
}

四种内部类

什么是内部类

在一个类的内部再定义一个完整的类，也会生成class文件，可以为外部类提供必要的内部组件

成员内部类

不能定义静态成员，可以有静态常量

实例

package com.opp.inner;

public class Outer {
    private int id = 10;
    private String name = "alice";

    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class Inner{
        //static int a; 不能定义静态成员
        static final int a = 10;//可以定义静态常量
        private String name = "jack";

        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }

        //内部类和外部类有同名变量
        public void show(){
            System.out.println(name);
            System.out.println(Outer.this.name);
        }
    }
}


//主函数类
package com.opp.inner;

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out();//这是外部类的方法

        Outer.Inner inner = outer.new Inner();//创建内部类对象
        inner.in();//这是内部类的方法
        inner.getID();//10
        inner.show();//jack   alice
    }
}

静态内部类

在成员内部类前面加上static修饰符就是静态内部类

静态内部类

不依赖外部类对象，可以直接创建或通过类名访问，可以声明静态成员；
访问外部类属性：先创建外部类对象，再调用；
可以直接创建静态内部类对象；
只有内部类才能用static修饰

实例

package com.opp.inner;

public class Outer2 {
    private int id = 10;
    private String name = "alice";

    public void out(){
        System.out.println(name+"="+id);
    }

    public static class Inner2{
        private static int a;//可以定义静态成员

        Outer2 outer2 = new Outer2();//先创建外部类对象
        int b = outer2.id;//再访问其属性

        private String name = "jack";

        public void in(){
            //System.out.println(id);不能直接访问外部类属性
            System.out.println(name+"="+b);
        }
    }
}


//主函数类
package com.opp.inner;

public class Test {
    public static void main(String[] args) {
        Outer2 outer2 = new Outer2();
        outer2.out();//alice=10

        Outer2.Inner2 inner2 = new Outer2.Inner2();//不用通过外部类对象outer2来创建对象
        inner2.in();//jack=10
    }
}

局部内部类

不能加任何修饰符

public class Outer{
    public void method(){
        class Inner{//不能加任何修饰符
            //作用范围和创建对象仅限于当前方法
            //可以直接访问外部类的属性Outer.this.···
            //局部内部类访问外部类当前方法（method）时，因无法保障变量的生命周期与自身相同，因此变量必须用final修饰
        }
    }
}

匿名内部类

匿名内部类是没有名字的内部类。因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。使用匿名内部类有个前提条件：必须继承一个父类或实现一个接口。

实例

package com.opp.inner;
//接口
public interface Usb {
    void service();
}

//匿名内部类的使用
package com.opp.inner;

public class Outer3 {
    Usb usb = new Usb() {
        @Override
        public void service() {
            System.out.println("连接成功，开始工作！");
        }
    };
}

//测试类
package com.opp.inner;

public class UsbTest {
    public static void main(String[] args) {
        Outer3 outer3 = new Outer3();

        outer3.usb.service();//连接成功，开始工作！
    }
}

漫鲸

关注

0
点赞
踩
0

收藏

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

文章目录Object类简介构造方法常用成员方法子类重写方法String类简介构造方法（不止下面两种）常用成员方法判断功能获取功能转换功能实例字符串相等的比较和拆分注意点字符串的compareTo方法StringBuilder和StringBuffer类简介常用构造方法常用成员方法Date类构造方法成员方法实例Calendar类构造方法常用成员方法实例SimpleDateFormat类简介实例基本类型的包装类简介装箱拆箱常用方法实例补充BigDecimal类简介常用方法实例System类简介常见方法实例四种内
复制链接

扫一扫