java中常见API

code..

已于 2022-12-14 21:49:57 修改

阅读量691

点赞数 2

分类专栏： java 文章标签： java 接口

于 2021-11-13 20:55:00 首次发布

本文链接：https://blog.csdn.net/weixin_46416904/article/details/121309932

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

API

1. Math

Math没有构造方法，但是成员是static可以直接用.方法名的形式获取

package com;

public class MathList {
    public static void main(String[] args) {
        System.out.println(Math.abs(-22));//abs去绝对值

        System.out.println(Math.max(20,30)); //max去最大值

        System.out.println(Math.pow(2,3)); //pow(x,y) x的y次方

        System.out.println(Math.ceil(3.14));//ceil 向上取整

        System.out.println(Math.floor(3.14)); //floor 向下取整

        System.out.println(Math.round(3.14)); //round 四舍五入

        //System.out.println(Math.random());
        System.out.println((int)(Math.random()*100));//取随机数[0.0,1.0)
    }
}

2. Sytem

2.1 System类的常用方法

方法名	说明
public static void exit(int staus)	终止当前运行的java虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间（以毫秒为单位）

package com.API;

public class SytemList {
    public static void main(String[] args) {
        SytemList sytemList = new SytemList();
       // sytemList.exitS();
        sytemList.timer();
    }
    public void exitS(){
        for (int i=0;i<10;i++){
            System.out.print(i+" ");
            if (i==4){
                System.exit(0);
            }
        }
        System.out.println("直接终止java虚拟机，后面程序不会执行");
    }
    public void timer(){
        long start = System.currentTimeMillis();
        for (int i=0;i < 10000;i++){
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        long time = end - start;
        System.out.println("所耗时间："+time);
    }
}

3. Object

3.1 Object类的概述

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类

构造方法：public Object()

回想构造方法默认为什么是无参构造方法？

因为它们的顶级父类只有无参构造方法

3.2 Object类的toString()方法

package com.object;

public class Constructor {
    private String name;
    private int ID;
    //无参构造方法
    public Constructor(){

    }
    public Constructor(String name,int ID){
        this.name = name;
        this.ID = ID;
    }
//toString方法重载,Object类中默认的格式改写
    @Override
    public String toString() {
        return "Constructor{" +
                "name='" + name + '\'' +
                ", ID=" + ID +
                '}';
    }
}

package com.object;

public class ConstructorDemo {
    public static void main(String[] args) {
        Constructor c = new Constructor("小米",1999);
        //return getClass().getName() + "@" + Integer.toHexString(hashCode()
        System.out.println(c);
        System.out.println(c.toString());
    }
}

3.3 Object类的equals()方法

package com.API;

public class equalsList {
    private String name;
    private int age;
    public equalsList(){};
    public equalsList(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;
    }
    //equals方法的重写
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        //this = s1
        //o = s2
        //判断两个对象地址是否相等
        if (o == null || getClass() != o.getClass()) return false;
        //判断是否为null
        //判断两个对象是否来自同一个类
        equalsList that = (equalsList) o;//向下转型
        if (age != that.age) return false; //比较年龄
        return name != null ? name.equals(that.name) : that.name == null;//比较姓名
    }
}

package com.API;

public class equalListDemo {
    public static void main(String[] args) {
        equalsList s1 = new equalsList("小明",20);
        equalsList s2 = new equalsList("小明",20);
        System.out.println(s1==s2);//因为直接比较的是地址，不同对象地址不同
        System.out.println("-------------------------");
        //没重载equals方法时
//        public boolean equals(Object obj) {
//            return (this == obj);
        //this = s1
        //obj = s2
//        }
        System.out.println(s1.equals(s2));
    }
}

方法名	说明
public String toString()	返回对象的字符串表示形式。建议所有子类重写该方法，自动生成
public boolean equals(Object obj)	比较对象是否相等。默认比较地址，重写可以比较内容，自动生成

4.Arrys

4.1 冒泡排序

排序：将一组数据按照固定的规则排序

冒泡排序：一种排序方式。对要进行排序的数据中相邻的数据进行两两比较，依次对所有数据进行操作，直至所有数据按要求完成排序

如果有n个数据进行排序，总共需要比较n-1次
每次比较完，下一次少比较一次

package com.API;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
     int[] arr = {23,56,34,78,12,45};
     for (int i=0;i<arr.length-1;i++){//因为最后一次不用排，所以只需排n-1次
        for (int j=0;j<arr.length-i-1;j++){//因为每排一次，值最大元素移到最后，下一次排序可以少一个元素
            if (arr[j]>arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
     }
        System.out.println(Arrays.toString(arr));
    }
}

4.2 Arrays类的概述和常用方法

方法名	说明
public static toString(int[] a)	返回数组内容的字符串表示形式
public static void sort(int[] a)	按照顺序排列指定的数组

工具类的设计思想：

构造方法用private修饰
成员用public static修饰

5.基本类型包装类

5.1常见基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一：用于基本数据类型与字符串之间的转换

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

5.2 Integer类的概述和使用

Integer:包装一个对象中原始类型int的值

方法名	说明
public static Integer valueOf(int i)	返回表示指定的int值的Integer实例
public static Integer valueOf(String s)	返回一个保存指定值的Integer对象String

public class IntegetList {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //System.out.println(Double.MAX_VALUE);
        Integer i = Integer.valueOf(10);
        System.out.println(i);
        System.out.println(Integer.valueOf("134"));
    }
}

5.3 int和String类型的相互转换

基本类型包装类的最常见操作：用于基本类型和字符串之间的相互转换

int转换为String

public static String valueOf(int i)

返回int参数的字符串表示形式。该方法是String类中的方法
String转换为int

public static parseInt(String s)

将字符串解析为int类型。该方法时Integer类中的方法

案例：将字符串排序

import java.util.Arrays;

//字符串排序
public class case1 {
    public static void main(String[] args) {
        String str1 = "34 23 67 45 78 45";
        //用split分割字符串,用字符串数组接受
        String[] str2 = str1.split(" ");
        int[] str3 = new int[str2.length-1];
        //将字符串转换为数字存入数组中
        for (int i = 0; i < str3.length; i++) {
            str3[i] = Integer.parseInt(str2[i]);
        }
        //数组排序
        Arrays.sort(str3);
        //用stringBuilder拼接字符串
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < str3.length; i++) {
            if (i==str3.length-1){
                s.append(str3[i]);
            }else
                s.append(str3[i]+" ");
        }
        String result = s.toString();
        //System.out.println(s.toString());
        System.out.println(result);
    }
}

5.4 自动装箱和拆箱

装箱：把基本数据类型转换为对应的包装类类型

拆箱：把包装类类型转换为对应的基本数据类型

public class autoBox {
    public static void main(String[] args) {
        Integer ii = Integer.valueOf(100);//手动装箱
        Integer i = 200;//自动装箱
        System.out.println(i);
        int i2 = i.intValue() + 200;//手动拆箱
        if( i!= null){
            i += 200;//自动拆箱
        }
        System.out.println(i);
    }

6. 日期

6.1 Date类概述和构造方法

Date代表了一个特定的时间，精确到秒

import java.util.Date;

public class DateList {
    public static void main(String[] args) {
        Date d = new Date(); //分配一个Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
        System.out.println(d);
        long date = 1000*60*60;//分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
        Date d2 = new Date(date);
        System.out.println(d2);
        Date d3 = new Date();//public long getTime();获取日期对象从1970年1月1日开始算的毫秒值
        System.out.println(d3.getTime()*1.0/1000/60/60/24/365+"年");
        long time = System.currentTimeMillis();
        d3.setTime(time);
        System.out.println(d3);
    }
}

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //格式化：从Date到String
        Date date = new Date();
        //无参构造
        //SimpleDateFormat s = new SimpleDateFormat();
        //有参构造
        SimpleDateFormat s = new SimpleDateFormat("yyyy年mm月dd日 HH:mm:ss");
        String sdf = s.format(date);
        System.out.println(sdf);
        //解析：从String到Date
        String str = "2021-12-10";
        SimpleDateFormat s2 = new SimpleDateFormat("yyyy-mm-dd");
        Date date1 = s2.parse(str);
        System.out.println(date1);

    }
}

案例：日期工具类

1.创建一个DateUtils类

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

public class DateUtils {
    private DateUtils(){};
    //将一个类的构造函数私有化，可以使得该类不被实例化，和不能被继承。要创建这个类的实例，唯一的办法是提供一个公共静态方法。
    // 这种方式被称为单例模式。
    public static String dateTostring(Date date,String format){
        SimpleDateFormat s = new SimpleDateFormat(format);
        String format1 = s.format(date);
        return format1;
    }
    public static Date StringTodate(String s, String format) throws ParseException {
        SimpleDateFormat si = new SimpleDateFormat(format);
        Date date1 = si.parse(s);
        return date1;
    }
}

2.创建一个测试类

import java.text.ParseException;
import java.util.Date;

public class DateUtilsDemo {
    public static void main(String[] args) throws ParseException {
        Date date = new Date();
        String s1 = DateUtils.dateTostring(date, "yyyy-mm-dd HH:mm:ss");
        String s2 = DateUtils.dateTostring(date, "yyyy年mm月dd日");
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("---------------------------------");
        String strTime = "2021-11-20 12:12:12";
        Date date1 = DateUtils.StringTodate(strTime, "yyyy-mm-dd HH:mm:ss");
        System.out.println(date1);
    }
}

6.2 Dalendar

用于设置和获取日期数据的特定部分，Dalendar类是抽象类，需要调用其子类来实现

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        //如果该类返回类型是抽象类，需要的是该类的子类对象
        Calendar c = Calendar.getInstance();//多态的形式，默认是当前日期
        System.out.println(c);
        //获取年月日
        int year = c.get(Calendar.YEAR);
        //月是从0开始
        int month = c.get(Calendar.MONTH)+1;
        int date = c.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+date+"日");   
    }
}

import java.util.Calendar;
public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        //如果该类返回类型是抽象类，需要的是该类的子类对象
        Calendar c = Calendar.getInstance();//多态的形式，默认是当前日期
        //System.out.println(c);
        //三年前的后5天
        c.add(Calendar.YEAR,-3);
        c.add(Calendar.DATE,5);
        //获取年月日
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int date = c.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+date+"日");
        //set设置日历
        Calendar b = Calendar.getInstance();
        b.set(2022,11,12);//将b设置成2022-11-12
    }
}

案例：求输入年份二月的天数

import java.util.Calendar;
import java.util.Scanner;
public class FebruaryDay {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入year：");
        int year = sc.nextInt();
        Calendar c = Calendar.getInstance();
        //Calendar中的月份是从0开始的，所以设置的是3月
        c.set(year,2,1);
        //将3月1日减去一天就是二月份了
        c.add(Calendar.DATE,-1);
        int day = c.get(Calendar.DATE);
        System.out.println("今年的二月份有"+day+"天");
    }
}

code..

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java中常见API

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类构造方法：public Object()回想构造方法默认为什么是无参构造方法？因为它们的顶级父类只有无参构造方法方法名说明返回数组内容的字符串表示形式按照顺序排列指定的数组构造方法用private修饰成员用public static修饰Integer:包装一个对象中原始类型int的值方法名说明返回表示指定的int值的Integer实例返回一个保存指定值的Integer对象String。
复制链接

扫一扫