学习笔记06--Java常用类

最新推荐文章于 2024-07-22 16:32:08 发布

WH3H3H3

最新推荐文章于 2024-07-22 16:32:08 发布

阅读量88

点赞数 1

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/Yikeman/article/details/123231904

版权

Java常用类

Math

Math包含执行基本数字运算的方法
没有构造方法，通过类名直接调用
该类为工具类，工具类构造方法用private 修饰，成员用public static 修饰
Math 类的常用方法

public static void main(String[] args) {
    //public static int abs(int a); 返回参数的绝对值
    System.out.println(Math.abs(10));
    System.out.println(Math.abs(-10));
    System.out.println("===============");
    //public static double ceil(double a);返回大于或等于参数的最小double值，等于一个整数
    System.out.println(Math.ceil(12.34));
    System.out.println(Math.ceil(12.54));
    System.out.println("===============");
    //public static double floor(double a);返回小于或等于参数的最小double值，等于一个整数
    System.out.println(Math.floor(12.34));
    System.out.println(Math.floor(12.54));
    System.out.println("===============");
    //public static double round(float a);按照四舍五入返回最近的int值
    System.out.println(Math.round(12.34F));
    System.out.println(Math.round(12.54F));
    System.out.println("===============");
    //public static double max(int a,int b);返回两个int值中较大的值
    System.out.println(Math.max(18,9));
    System.out.println("===============");
    //public static double min(int a,int b);返回两个int值中较大的值
    System.out.println(Math.min(18,9));
    System.out.println("===============");
    //public static double pow(double a,double b);返回a的b次幂
    System.out.println(Math.pow(2.0,3.0));
    System.out.println("===============");
    //public static double random();返回值为double的随机数 范围：[0.0-1.0)
    System.out.println(Math.random());
}

System

System包含几个有用的类字段和方法，它不能被实例化
System 类的常用方法

   public static void main(String[] args) {
        //public static void exit(int status);终止当前运行的 Java 虚拟机，非0表示异常终止
/*      System.out.println("开始");
        System.exit(0);
        System.out.println("结束");
*/
        //public static long currentTimeMillis();返回当前时间（以毫秒为单位）
        System.out.println(System.currentTimeMillis());
        //System.currentTimeMillis() / 1000 转化为秒
        //System.currentTimeMillis() / 1000 / 60 转化为分钟
        //System.currentTimeMillis() / 1000 / 60 / 60 转化为小时
        //System.currentTimeMillis() / 1000 / 60 / 60 / 24 转化为天数
        //System.currentTimeMillis() / 1000 / 60 / 60 / 24 /365 转化为年数
        System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365);

        //可以用来记录程序运行时间
        long start = System.currentTimeMillis();
        for(int i = 0;i < 10000;i++){
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("运行耗时为：" + (end - start) + "毫秒");
    }

Object

Object类是类层次结构的根。每个类都直接或间接继承Object类。所有对象（包括数组）都实现了这个类的方法
为什么子类的构造方法默认访问的是父类的无参构造方法，因为它们的顶级父类只有无参构造方法

常用方法

toString()：返回对象的字符串表示形式。一般来说，toString方法返回一个“toString代表”这个对象的字符串。结果应该是一个简明扼要的表达，容易让人阅读，建议所有子类重写此方法，可自动生成
方法名：public String toString()

public class Student {
    private String name;
    private int age;

    public Student(){
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

equals()：比较对象是否相等。默认比较地址，重写后可以比较内容，可自动生成
方法名：public boolean equals(Object obj)

@Override
public boolean equals(Object o) {
    /*
        this --- s1
        o    --- s2
     */
    //比较地址是否相同
    if (this == o) return true;
    //判断参数是否为null
    //判断两个对象是否来自同一个类，如果不是同一个类，二者不相同
    if (o == null || getClass() != o.getClass()) return false;
    //向下转型
    Student student = (Student) o;      //student = s2
    //比较年龄是否相同
    if (age != student.age) return false;
    //比较名字是否相同
    return name.equals(student.name);
}

Arrays

该类包含用于操作数组的各种方法（如排序和搜索）
该类为工具类

常用方法

toString()：返回指定的数组内容的字符串表示形式
方法名：public static String toString(int[] a)

public static void main(String[] args) {
    //定义一个数组
    int[] a = {18,84,63,91,22,40,8};
    System.out.println("排序前的数组为：" + Arrays.toString(a));
    Arrays.sort(a);
    System.out.println("排序后的数组为：" + Arrays.toString(a));
}

sort()：按照数字顺序排列成指定的数组
方法名：public static void sort(int[] a)

Date

Date代表了一个特定的时间，精确到毫秒
常用方法
- public Date()：分配一个 Date 对象，并初始化，以便它代表它被分配的时间，精确到毫秒
- public Date(long date)：分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
- public long getTime()：获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值
- public void setTime(long time)：设置时间，给的是毫秒值

public static void main(String[] args) {
    //public Date()：分配一个 Date 对象，并初始化，以便它代表它被分配的时间，精确到毫秒
    Date d1 = new Date();
    System.out.println(d1);

    //public Date(long date)：分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
    long date = 1000 * 60 * 60;   //1小时
    Date d2 = new Date(date);
    System.out.println(d2);     //输出结果为：Thu Jan 01 09:00:00 CST 1970，因为是东八区，所以是09:00:00

    //public long getTime()：获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值
    System.out.println((int)(d1.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365) + "年"); //换算为年

    //public void setTime(long time)：设置时间，给的是毫秒值
    Date d3 = new Date();
    long time = System.currentTimeMillis();
    d3.setTime(time);
    System.out.println(d3);
}

SimpleDateFormat

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从‘A’到Z’以及从‘a‘到’z’引号的字母被解释为表示日期或时间字符串的组件的模式字母
常用的模式字母以及对应关系
- y -------- 年
- M ------- 月
- d -------- 日
- H ------- 时
- m ------- 分
- s -------- 秒
构造方法
- public SimpleDateFormat()：构造一个SimpleDateFormat，使用默认模式和日期格式
- public SimpleDateFormat(String pattern)：构造一个 SimpleDateFormat使用给定的模式和默认的日期格式
格式化和解析日期
- 格式化（从Date到String）public final String format(Date date)：将日期格式化成日期/时间字符串
- 解析（从String到Date）：从给定的字符串的开始解析文本以生成日期

public static void main(String[] args) throws ParseException {
    //格式化（从Date到String）
    Date d =new Date();
    SimpleDateFormat sdf = new SimpleDateFormat();//使用默认模式和日期格式
    String s = sdf.format(d);
    System.out.println(s);

    SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    String s1 = sdf2.format(d);
    System.out.println(s1);

    //解析（从String到Date）
    String s2 = "2022-03-02 13:58:12";
    SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date d2 = sdf3.parse(s2);
    System.out.println(d2);
}

Calendar

Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance();
常用方法
- public int get(int field)：返回给定日历字段的值
- public abstract void add(int field,int amount)：根据日历的规则，将指定的时间量添加或减去给定的日历字段
- public final void set(int year,int month,int date)：设置当前日历的年月日

public static void main(String[] args) {
    //获取日历类对象
    Calendar c = Calendar.getInstance();

    //public int get(int field)：返回给定日历字段的值
    int year = c.get(Calendar.YEAR);
    int month = c.get(Calendar.MONTH) + 1;//月份是从0开始的，所以要加一
    int date = c.get(Calendar.DATE);
    System.out.println(year + "年" + month + "月" + date + "日");

    //public abstract void add(int field,int amount)：根据日历的规则，将指定的时间量添加或减去给定的日历字段
    c.add(Calendar.YEAR,-3);//三年前
    c.add(Calendar.DATE,5);//五天后
    int year1 = c.get(Calendar.YEAR);
    int month1 = c.get(Calendar.MONTH) + 1;
    int date1 = c.get(Calendar.DATE);
    System.out.println(year1 + "年" + month1 + "月" + date1 + "日");

    //public final void set(int year,int month,int date)：设置当前日历的年月日
    c.set(1991,10,24);
    int year2 = c.get(Calendar.YEAR);
    int month2 = c.get(Calendar.MONTH);
    int date2 = c.get(Calendar.DATE);
    System.out.println(year2 + "年" + month2 + "月" + date2 + "日");
}

基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换

Interger

包装一个对象中原始类型 int 的值
常用方法名
- public Integer(int value)：根据int值创建Integer对象
- public Integer(String s)：根据String值创建Integer对象
- public static Integer valueOf(int i)：返回表示指定的int值的Integer 实例
- public static Integer valueOf(String s)：返回一个保存指定值的Integer对象String
int 和 String 的相互转换
1. int 转换为 String
  
  public static String valueOf(int i)：返回 int 参数的字符串表示形式，该方法是String 类中的方法
2. String 转化为 int
  
  public static int parseInt(String s)：将字符串解析为int类型，该方法是Integer类中的方法

    public static void main(String[] args) {
        //int 转化为 String
        //方式一
        int number = 100;
        String s1 = "" + number;
        System.out.println(s1);
		//方式二
        String s2 = String.valueOf(number);
        System.out.println(s2);

        //String 转化为 int
        //方式一  String --- Integer --- int
        String s = "100";
        Integer i = Integer.valueOf(s);
        int x = i.intValue();
        System.out.println(x);
        //方式二
        int y = Integer.parseInt(s);
        System.out.println(y);
    }

自动装箱和拆箱

装箱：把基本数据类型转换为对应的包装类类型
拆箱：把包装类类型转换为对应的基本数据类型
注意：在使用包装类类型的时候，如果做操作，最好先判断是否为null，只要是对象，在使用前就必须进行不为null的判断

Integer ii = 100;//自动装箱
ii += 200;// i + 200 自动拆箱；i = i + 200自动装箱

WH3H3H3

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫