常用API

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量780 收藏 23
点赞数 16
文章标签： java ide
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_78280224/article/details/139819708
版权

System

System.exit(int status) 停止当前运行的虚拟机

  • status为0:当前虚拟机正常停止
  • status非0：当前虚拟机异常停止
    long start = System.curentTimeMillis();
    long end = System.currentTimeMillis();
    end-start 可以计算在此期间执行的代码的时间ms单位
    System.arraycopy(数据源(要copy的数组从哪来),从数据源第几个索引开始copy,目的地(要把数据源数组copy到哪个数组),目的地地址的索引)
    如果数据源数组和目的地数组都是基本数据类型，那么两者的数据类型要保持一致
  • 在copy时要考虑数组的长度，超出范围报错
  • 如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型

Runtime

public static Runtime getRuntime()		//当前系统的运行环境对象
public void exit(int status)			//停止虚拟机
public int availableProcessors()		//获得CPU的线程数
public long maxMemory()				    //JVM能从系统中获取总内存大小（单位byte）
public long totalMemory()				//JVM已经从系统中获取总内存大小（单位byte）
public long freeMemory()				//JVM剩余内存大小（单位byte）
public Process exec(String command) 	//运行cmd命令

        //1.获取Runtime的对象
        Runtime r1 =Runtime.getRuntime();

        //2.exit 停止虚拟机
    	Runtime.getRuntime().exit(0);
        System.out.println("看看我执行了吗?");


        //3.获得CPU的线程数
        System.out.println(Runtime.getRuntime().availableProcessors());//8
        //4.总内存大小,单位byte字节
        System.out.println(Runtime.getRuntime().maxMemory() / 1024 / 1024);//4064
        //5.已经获取的总内存大小,单位byte字节
        System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);//254
        //6.剩余内存大小
        System.out.println(Runtime.getRuntime().freeMemory() / 1024 / 1024);//251

        //7.运行cmd命令
        //shutdown :关机
        //加上参数才能执行
        //-s :默认在1分钟之后关机
        //-s -t 指定时间 : 指定关机时间
        //-a :取消关机操作
        //-r: 关机并重启
        Runtime.getRuntime().exec("shutdown -s -t 3600");

Object

public String toString()				//返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj)		//比较两个对象地址值是否相等；true表示相同，false表示不相同
protected Object clone()    			//对象克隆

java中的顶级父类，所有类都直接或者间接继承它
Object的构造方法public Object()
成员方法

  • toSting() 返回对象字符串的表示形式 一般会重写
    当我们打印一个对象时，底层会调用对象的toString方法，把对象变成字符串，然后打印在控制台上
    如果我们打印一个对象，如果要看到属性值的话，要重写toString方法，在重写的方法在，把对象的属性进行拼接
  • equal
    可以alt+insert重写equals方法，重写的equals方法比较的时里面的对象，不是地址值
    如果没有重写equals方法，那么默认使用Object类中的方法进行比较，比较地址值是否相等
  • clone 把A对象的属性值完全copy给B对象，也叫对象copy，对象复制
    • 重写Object中的clone方法，让javabean类继承Cloneable接口
    • 创建对象调用clone方法
    • Object的clone为浅克隆
    • 深克隆 用第三方工具
      • 导入第三方代码
      • 编写代码Gson gson = new Gson();
      • 把对象变成字符串String s = gson.toJson(ui);
      • 把字符串变回对象User user = gson.fromJson(s,User.class)

Objects

public static String toString(Object o) 					// 获取对象的字符串表现形式
//方法的底层hui
public static boolean equals(Object a, Object b)			// 先做非空判断，比较两个对象是否相等

public static boolean isNull(Object obj)					// 判断对象是否为null
public static boolean nonNull(Object obj)					// 判断对象是否不为null

null不允许调用方法，会报空指针异常
public static boolean equals(Object a, Object b)
方法的底层会判断s1是否为null，如果为null，直接返回false

  • 如果不为null，那么就会利用s1调用equals方法

BigInteger

BigInteger所在包是在java.math包下，因此在使用的时候就需要进行导包。我们可以使用BigInteger类进行大整数的计算`

public BigInteger(int num, Random rnd) 		//获取随机大整数，范围：[0 ~ 2的num次方-1]
public BigInteger(String val) 				//获取指定的大整数,字符串中val必须是整数，否则会报错
public BigInteger(String val, int radix) 	//获取指定进制的大整数 radix表示进制
    //1.字符串中的数字必须是整数
    //2.字符串中的数字必须要跟进制吻合。``    //比如二进制中，那么只能写日和1，写其他的就报错。
下面这个不是构造，而是一个静态方法获取BigInteger对象
public static BigInteger valueOf(long val) 	//静态方法获取BigInteger的对象，内部有优化

		public static BigInteger valueOf(long val)
		//细节:
        //1.能表示范围比较小，只能在long的取值范围之内，如果超出long的范围就不行了。
        //默认为int类型，超过int数值需要在数字后面加L，表示long类型
        //2.在内部对常用的数字: -16 ~ 16 进行了优化。
        //  提前把-16~16 先创建好BigInteger的对象，如果多次获取不会重新创建新的。
        //如果超过此范围，地址值就不一样了``
        BigInteger bd5 = BigInteger.valueOf(16);
        BigInteger bd6 = BigInteger.valueOf(16);
        System.out.println(bd5 == bd6);//true

对象一旦创建，内部的值不能改变
只要计算就会产生一个新的BigInteger方法

//此时，不会修改参与计算的BigInteger对象中的借，而是产生了一个新的BigInteger对象记录
        BigInteger result=bd9.add(bd10);
        System.out.println(result);//3

     public BigInteger add(BigInteger val) 加法
            public BigInteger subtract(BigInteger val) 减法
            public BigInteger multiply(BigInteger val) 乘法
            public BigInteger divide(BigInteger val) 除法，获取商
            public BigInteger[] divideAndRemainder(BigInteger val) 除法，获取商和余数
            public boolean equals(Object x) 比较是否相同
            public BigInteger pow(int exponent) 次幂
            public BigInteger max/min(BigInteger val) 返回较大值/较小值
            public int intValue(BigInteger val) 转为int类型整数，超出范围传出数据有误
            doubleValue 转换为double类型小数

对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。

数组中最多能存储元素个数：21亿多

数组中每一位能表示的数字：42亿多

理论上，BigInteger能表示的最大数字为：42亿的21亿次方。

但是还没到这个数字，电脑的内存就会撑爆，所以一般认为BigInteger是无限的。
把数字转化为2进制，32分为一组

在这里插入图片描述
BigDecima
float占用4个字节，总bit位：32个bit位，小数部分bit位：23个
double占用8个字节，总bit位：64个，小数部分bit位：52个
BigDecima可以表示很大的小数
用于小数的精确运算`

  BigDecimal b1 = new BigDecimal(0.3) ;
  BigDecimal b2 = new BigDecimal(0.44) ;
//这样传递的值不精确，不建议使用，传递的值不是字符串类型
  		BigDecimal b1 = new BigDecimal("0.3") ;
        BigDecimal b2 = new BigDecimal("0.4") ;
        //传递的是字符串类型建议使用

//通过静态方法获取对象
BigDecima.valueOf(10);

差别：如果表示的数字不大，没有超出double的取值范围，建议使用静态方法，反之使用构造方法
如果我们传递的是0-10之间的整数，包含0，包含10，那么方法会调用已经创建好的对象，不会重新new

// 调用方法进行b1和b2的四则运算，并将其运算结果在控制台进行输出
        System.out.println(b1.add(b2));         // 进行加法运算
        System.out.println(b1.subtract(b2));    // 进行减法运算
        System.out.println(b1.multiply(b2));    // 进行乘法运算
        System.out.println(b1.divide(b2));      // 进行除法运算
  // 如果使用BigDecimal类型的数据进行除法运算的时候，得到的结果是一个无限循环小数，那么就会报错
        BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
divisor:			除数对应的BigDecimal对象；
scale:				精确的位数；
roundingMode:		取舍模式；

取舍模式被封装到了RoundingMode这个枚举类中。最常见的取舍方式有如下几个：

  • UP：远离0方向的舍入模式 ，
  • DOWN:向0方向的舍入模式
  • CEILING:：向正无穷大的舍入模式
  • FLOOR：向负无穷大方向摄入的舍入模式
  • HALF_UP(4舍五入)：向最近数字方向的舍入模式， 如果与两个数字的距离相等，那么向上舍入
  • HALF_DOWN：向最近数字方向的舍入模式， 如果与两个数字的距离相等，那么向下舍入
  • 我们可以通过如下格式直接访问这些取舍模式：枚举类名.变量名

存储方式

把数据看成字符串，遍历得到里面的每一个字符，把这些字符在ASCII码表上的值，都存储到数组中。
在这里插入图片描述

正则表达式

charAt()获取第几个字符
正则表达式可以校验字符串是否满足一定的规则，并且用来校验数据格式的合法性
作用

  • 校验字符串是否满足一定的规则
  • 在一段文本中查找满足条件的内容

校验字符串是否满足一定的规则

语法（只能校验一个字符）

  1. [abc]：代表a或者b，或者c字符中的一个，出现两个报错
  2. [^abc]：代表除a,b,c以外的任何字符。
  3. [a-z]：代表a-z的所有小写字符中的一个。
  4. [A-Z]：代表A-Z的所有大写字符中的一个。
  5. [0-9]：代表0-9之间的某一个数字字符。
  6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
  7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符。(包括头尾的范围)
  8. [a-d[m-p]] a到d，或m到p
    如果写成一个&，那么此时表示就不是交集了，而是一个简简单单的&符号
  9. [a-z&&[def]] a-z和def的交集。为:d，e，f
  10. [a-z&&[^bc]] a-z和非bc的交集。(等同于[ad-z])
  11. [a-z&&[^m-p]] a到z和除了m到p的交集。(等同于[a-1q-z])
System.out.println("zz".matches("[^abc][^abc]")); //true
第一个z和第一个方括号判断，第二个z和第二个方括号判断

逻辑运算符

  • &&：并且
  • | ：或者
  • \ ：转义字符 改变了后面字符原本的含义
    预定义字符(只能校验一个字符)
  1. “.” ： 匹配任何一个字符。 System.out.println("你".matches("..")); //false任意两个字符
  2. “\d”：任何数字[0-9]的简写；\d只能是任意的一位数字，两个\表示一个\
  3. “\D”：任何非数字[^0-9]的简写；
  4. “\s”： 空白字符：[ \t\n\x0B\f\r] 的简写
  5. “\S”： 非空白字符：[^\s] 的简写
  6. “\w”：单词字符：[a-zA-Z_0-9]的简写
  7. “\W”：非单词字符：[^\w]

数量词

  1. X? : 0次或1次
  2. X* : 0次到多次
  3. X+ : 1次或多次
  4. X{n} : 恰好n次
  5. X{n,} : 至少n次
  6. X{n,m}: n到m次(n和m都是包含的)

写正则表达式时，要用正确的数据，从左到右依次写

       //座机电话号码
        //020-2324242 02122442 027-42424 0712-3242434
        //思路:
        //在书写座机号正则的时候需要把正确的数据分为三部分
        //一:区号@\\d{2,3}
        //      0:表示区号一定是以0开头的
        //      \\d{2,3}:表示区号从第二位开始可以是任意的数字，可以出现2到3次。
        //二:- ?表示次数，日次或一次
        //三:号码 号码的第一位也不能以日开头，从第二位开始可以是任意的数字，号码的总长度:5-10位
        String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
        System.out.println("020-2324242".matches(regex2));
        System.out.println("02122442".matches(regex2));
        System.out.println("027-42424".matches(regex2));
        System.out.println("0712-3242434".matches(regex2));

插件
去掉开头的^和末尾的$，再把\改成\
能看懂就行
在正则表达式中，?i 本身并不是一个标准的修饰符或模式。但在某些上下文中，特别是在某些编程语言或工具中，i 可以用来表示不区分大小写的匹配。
在这里插入图片描述

在一段文本中查找满足条件的内容

 //获取正则表达式的对象
        Pattern p = Pattern.compile("Java\\d{0,2}");
        //获取文本匹配器的对象
        //m:文本匹配器的对象
        //str:大串
        //p:规则
        //m要在str中找符合p规则的小串
        Matcher m = p.matcher(str);

        //拿着文本匹配器从头开始读取，寻找是否有满足规则的子串
        //如果没有，方法返回false
        //如果有，返回true。在底层记录子串的起始索引和结束索引+1
        // 0,4
        boolean b = m.find();

        //方法底层会根据find方法记录的索引进行字符串的截取
        // substring(起始索引，结束索引);包头不包尾
        // (0,4)但是不包含4索引
        // 会把截取的小串进行返回。
        String s1 = m.group();
        System.out.println(s1);


        //第二次在调用find的时候，会继续读取后面的内容
        //读取到第二个满足要求的子串，方法会继续返回true
        //并把第二个子串的起始索引和结束索引+1，进行记录
        b = m.find();

        //第二次调用group方法的时候，会根据find方法记录的索引再次截取子串
        String s2 = m.group();
        System.out.println(s2);

 String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";


        //1.获取正则表达式的对象
        Pattern p = Pattern.compile("Java\\d{0,2}");
        //2.获取文本匹配器的对象
        //拿着m去读取str，找符合p规则的子串
        Matcher m = p.matcher(str);

        //3.利用循环获取
        while (m.find()) {
            String s = m.group();
            System.out.println(s);
        }

只写+和表示贪婪匹配，如果在+和后面加问号表示非贪婪爬取
+? 非贪婪匹配
*? 非贪婪匹配
贪婪爬取:在爬取数据的时候尽可能的多获取数据
非贪婪爬取:在爬取数据的时候尽可能的少获取数据

举例：
如果获取数据：ab+
贪婪爬取获取结果:abbbbbbbbbbbb
非贪婪爬取获取结果:ab

public String[] split(String regex)
//参数regex表示正则表达式。可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。
String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
//细节:
//方法在底层跟之前一样也会创建文本解析器的对象
//然后从头开始去读取字符串中的内容，只要有满足的，那么就切割。
String[] arr = s.split("[\\w&&[^_]]+");//数组接收
public String replaceAll(String regex,String newStr)
//参数regex表示一个正则表达式。可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。
String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
//细节:
//方法在底层跟之前一样也会创建文本解析器的对象
//然后从头开始去读取字符串中的内容，只要有满足的，那么就用第一个参数去替换。
String result1 = s.replaceAll("[\\w&&[^_]]+", "vs");

replace不识别正则表达式
replaceAll识别正则表达式

分组

分组就是一个小括号
每组都有组号，也就是序号

  • 从1开始，连续不间断
  • 以左括号为基准，最左边的是第一组，其次为第二组，以此类推
    捕获分组就是把这一组的数据捕获出来，再用一次
    当看到一致等内容，用捕获分组
    // (.)表示把重复内容的第一个字符看做一组
    // \1表示第一字符再次出现
    // + 至少一次
    // * 作用于\1,表示后面重复的内容出现0次或者多次
    // $1 表示把正则表达式中第一组的内容，再拿出来用
  • 后续还要继续使用本组的数据
  • 正则内部使用：\组号
  • 正则外部使用：$组号
//(?i) ：表示忽略后面数据的大小写
//忽略abc的大小写
String regex = "(?i)abc";

非捕获分组：分组之后不需要再用本组数据，仅仅是把数据括起来。
不占用组号，(?😃(?!)(?+)就是非捕获分组

JDK7前时间相关类

Date

导包一定倒java.util包下的
以前标准时间为格林威治时间（GMT）
现在标准时间由原子钟而来 ，利用铯原子的震动的频率计算出来的时间，作为世界标准时间(UTC)
中国标准时间=世界标准时间+8
Date类是一个JDK写好的javabean类，用来描述时间，精确到毫秒

  • 利用空参构造创建的对象，默认表示系统当前时间
  • 利用有参构造创建的对象，表示指定时间
  • 使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数(可以在结尾加L)，可以自定义毫秒时刻
    new Date(0L)) //Thu Jan 01 08:00:00 CST 1970（时间原点）
    public long getTime():获取的是日期对象从1970年1月1日 00:00:00/中国08:00:00到现在的毫秒值
    public void setTime(long time)` 把方法参数给定的毫秒值设置给日期对象

SimpleDateFormat

  • 格式化：把时间变成我们喜欢的格式
  • 解析：把字符串表示的时间变成Date对象
    public SimpleDateFormat(String pattern)`：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，代表日期时间的自定义格式。空参表示使用默认格式
 public String format(Date date)`：将Date对象格式化为字符串。
 public Date parse(String source)`：将字符串解析为Date对象
格式化：把时间变成我们喜欢的格式
标识字母（区分大小写）含义
y年
M月
d日
H时
m分
s秒
  	  SimpleDateFormat s = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");  
      Date now = new Date(); // 获取当前日期和时间  
      String s1 = s.format(now); // 将当前日期和时间格式化为字符串  
      System.out.println(s1); // 输出格式化后的字符串
解析：把字符串表示的时间变成Date对象

public Date parse(String source)：将字符串解析为Date对象

 		//1.定义一个字符串表示时间
        String str = "2023-11-11 11:11:11";
        //2.利用空参构造创建simpleDateFormat对象
        // 细节:
        //创建对象的格式要跟字符串的格式完全一致
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(str);
        //3.打印结果
        System.out.println(date.getTime());//1699672271000

Calendar

  • java.util.Calendar类表示一个“日历类”，可以进行日期运算。
  • 它是一个抽象类，不能创建对象，我们可以使用它的子类：java.util.GregorianCalendar类。
  • 有两种方式可以获取GregorianCalendar对象：
    • 直接创建GregorianCalendar对象；
    • 通过Calendar的静态方法getInstance()方法获取GregorianCalendar对象
方法名说明
public static Calendar getInstance()获取一个它的子类GregorianCalendar对象。
public int get(int field)获取某个字段的值。field参数表示获取哪个字段的值，
可以使用Calender中定义的常量来表示：
Calendar.YEAR : 年 索引：1
Calendar.MONTH ：月 索引：2（向下依次加以）
Calendar.DAY_OF_MONTH：月中的日期
Calendar.HOUR：小时
Calendar.MINUTE：分钟
Calendar.SECOND：秒
Calendar.DAY_OF_WEEK：星期
*int field 也可以为索引1-7 *
public void set(int field,int value)设置(修改)某个字段的值
public void add(int field,int amount)为某个字段增加(正数)/减少(负数)指定的值 ，时间超出范围不会报错，而是顺延进位
 //查表法，查询星期几，因为外国的星期日是一周中的第一天
    public static String getWeek(int w) {//w = 1 --- 7
        //做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        //查表
        return weekArray[w - 1];
    }

日历中月份的范围为0-11

jdk8时间相关类

JDK8时间类类名作用
ZoneId时区
Instant时间戳
ZoneDateTime带时区的时间
DateTimeFormatter用于时间的格式化和解析
LocalDate年、月、日
LocalTime时、分、秒
LocalDateTime年、月、日、时、分、秒
Duration时间间隔（秒，纳，秒）
Period时间间隔（年，月，日）
ChronoUnit时间间隔（所有单位）

Date类

ZoneId

        static Set<string> getAvailableZoneIds() 获取Java中支持的所有时区
        static ZoneId systemDefault() 获取系统默认时区
        static Zoneld of(string zoneld) 获取一个指定时区
        


//1.获取所有的时区名称
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
System.out.println(zoneIds.size());//600
System.out.println(zoneIds);// Asia/Shanghai

//2.获取当前系统的默认时区
ZoneId zoneId = ZoneId.systemDefault();

//3.获取指定的时区
ZoneId zoneId1 = ZoneId.of("Asia/Pontianak");
Instant时间戳
		static Instant now() 获取当前时间的Instant对象(标准时间)
        static Instant ofXxxx(long epochMilli) 根据(秒/毫秒/纳秒)获取Instant对象
        ZonedDateTime atZone(ZoneIdzone) 指定时区
        boolean isxxx(Instant otherInstant) 判断系列的方法
        Instant minusXxx(long millisToSubtract) 减少时间系列的方法
        Instant plusXxx(long millisToSubtract) 增加时间系列的方法

//2.根据(秒/毫秒/纳秒)获取Instant对象
Instant instant1 = Instant.ofEpochMilli(0L);//ms
System.out.println(instant1);//1970-01-01T00:00:00z

Instant instant2 = Instant.ofEpochSecond(1L);//s
System.out.println(instant2);//1970-01-01T00:00:01Z

Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);//s+ms
System.out.println(instant3);//1970-01-01T00:00:027

//3. 指定时区
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));

//5.用于时间的判断
//isBefore:判断调用者代表的时间是否在参数表示时间的前面(4在5前面)
boolean result1=instant4.isBefore(instant5);
System.out.println(result1);//true

//isAfter:判断调用者代表的时间是否在参数表示时间的后面（4在5后面）
boolean result2 = instant4.isAfter(instant5);

//6.Instant minusXxx(long millisToSubtract) 减少时间系列的方法
Instant instant6 =Instant.ofEpochMilli(3000L);//ms
ZoneDateTime带时区的时间
/*
            static ZonedDateTime now() 获取当前时间的ZonedDateTime对象
            static ZonedDateTime ofXxxx(。。。) 获取指定时间的ZonedDateTime对象
            ZonedDateTime withXxx(时间) 修改时间系列的方法
            ZonedDateTime minusXxx(时间) 减少时间系列的方法
            ZonedDateTime plusXxx(时间) 增加时间系列的方法
         */
//1.获取当前时间对象(带时区)
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);

//2.获取指定的时间对象(带时区)1/年月日时分秒纳秒方式指定
ZonedDateTime time1 = ZonedDateTime.of(2023, 10, 1,
                                       11, 12, 12, 0, ZoneId.of("Asia/Shanghai"));
System.out.println(time1);

//通过Instant + 时区的方式指定获取时间对象
Instant instant = Instant.ofEpochMilli(0L);
ZoneId zoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(time2);


//3.withXxx 修改时间系列的方法
ZonedDateTime time3 = time2.withYear(2000);
System.out.println(time3);

//4. 减少时间
ZonedDateTime time4 = time3.minusYears(1);
System.out.println(time4);

//5.增加时间
ZonedDateTime time5 = time4.plusYears(1);
System.out.println(time5);
DateTimeFormatter
		 static DateTimeFormatter ofPattern(格式) 获取格式对象
         String format(时间对象) 按照指定方式格式化
LocalDate 年、月、日
//1.获取当前时间的日历对象(包含 年月日)
LocalDate nowDate = LocalDate.now();
//System.out.println("今天的日期:" + nowDate);
//2.获取指定的时间的日历对象
LocalDate ldDate = LocalDate.of(2023, 1, 1);
System.out.println("指定日期:" + ldDate);

System.out.println("=============================");

//3.get系列方法获取日历中的每一个属性值//获取年
int year = ldDate.getYear();
System.out.println("year: " + year);
//获取月//方式一:
Month m = ldDate.getMonth();
System.out.println(m);
System.out.println(m.getValue());

//方式二:
int month = ldDate.getMonthValue();
System.out.println("month: " + month);


//获取日
int day = ldDate.getDayOfMonth();
System.out.println("day:" + day);

//获取一年的第几天
int dayofYear = ldDate.getDayOfYear();
System.out.println("dayOfYear:" + dayofYear);

//获取星期
DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
System.out.println(dayOfWeek);
System.out.println(dayOfWeek.getValue());

//is开头的方法表示判断
System.out.println(ldDate.isBefore(ldDate));
System.out.println(ldDate.isAfter(ldDate));

//with开头的方法表示修改，只能修改年月日
LocalDate withLocalDate = ldDate.withYear(2000);
System.out.println(withLocalDate);

//minus开头的方法表示减少，只能减少年月日
LocalDate minusLocalDate = ldDate.minusYears(1);
System.out.println(minusLocalDate);


//plus开头的方法表示增加，只能增加年月日
LocalDate plusLocalDate = ldDate.plusDays(1);
System.out.println(plusLocalDate);
LocalTime 时、分、秒 LocalDateTime 年、月、日、时、分、秒

和LocalDate一样

Duration 时间间隔（秒，纳，秒）
// 本地日期时间对象。
LocalDateTime today = LocalDateTime.now();
System.out.println(today);

// 出生的日期时间对象
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1, 0, 0, 0);
System.out.println(birthDate);

Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数
System.out.println("相差的时间间隔对象:" + duration);

System.out.println("============================================");
System.out.println(duration.toDays());//两个时间差的天数
System.out.println(duration.toHours());//两个时间差的小时数
System.out.println(duration.toMinutes());//两个时间差的分钟数
System.out.println(duration.toMillis());//两个时间差的毫秒数
System.out.println(duration.toNanos());//两个时间差的纳秒数
Period 时间间隔（年，月，日）
// 当前本地 年月日
LocalDate today = LocalDate.now();
System.out.println(today);

// 生日的 年月日
LocalDate birthDate = LocalDate.of(2000, 1, 1);
System.out.println(birthDate);

Period period = Period.between(birthDate, today);//第二个参数减第一个参数

System.out.println("相差的时间间隔对象:" + period);
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());

System.out.println(period.toTotalMonths());
ChronoUnit 时间间隔（所有单位）
// 当前时间
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 生日时间
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1,0, 0, 0);
System.out.println(birthDate);

System.out.println("相差的年数:" + ChronoUnit.YEARS.between(birthDate, today));
System.out.println("相差的月数:" + ChronoUnit.MONTHS.between(birthDate, today));
System.out.println("相差的周数:" + ChronoUnit.WEEKS.between(birthDate, today));
System.out.println("相差的天数:" + ChronoUnit.DAYS.between(birthDate, today));
System.out.println("相差的时数:" + ChronoUnit.HOURS.between(birthDate, today));
System.out.println("相差的分数:" + ChronoUnit.MINUTES.between(birthDate, today));
System.out.println("相差的秒数:" + ChronoUnit.SECONDS.between(birthDate, today));
System.out.println("相差的毫秒数:" + ChronoUnit.MILLIS.between(birthDate, today));
System.out.println("相差的微秒数:" + ChronoUnit.MICROS.between(birthDate, today));
System.out.println("相差的纳秒数:" + ChronoUnit.NANOS.between(birthDate, today));
System.out.println("相差的半天数:" + ChronoUnit.HALF_DAYS.between(birthDate, today));
System.out.println("相差的十年数:" + ChronoUnit.DECADES.between(birthDate, today));
System.out.println("相差的世纪(百年)数:" + ChronoUnit.CENTURIES.between(birthDate, today));
System.out.println("相差的千年数:" + ChronoUnit.MILLENNIA.between(birthDate, today));
System.out.println("相差的纪元数:" + ChronoUnit.ERAS.between(birthDate, today));

System.currentTimeMillis();当前时间

包装类

基本类型对应的包装类（位于java.lang包中）
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

基本数据类型不能存储在集合中，因此需要把数据转化为对应的包装类，存入集合中
性能优化（通过整数缓存）：
Integer.valueOf() 方法对于 -128 到 127（包括两端）之间的整数值，会返回缓存的 Integer 对象实例，地址值相同，而不是创建新的对象。这是因为这些整数在 Java 程序中非常常见，通过缓存这些对象，可以减少对象的创建和垃圾收集的开销，从而提高性能。new出来的对象都会在堆内存开辟一个新的存储空间，地址值不同
字符串到整数的转换：
除了接受基本类型的 int 作为参数外，Integer.valueOf() 方法还接受一个 String 参数，并尝试将其解析为一个整数。如果字符串表示一个有效的整数，则该方法会返回相应的 Integer 对象；否则，会抛出 NumberFormatException。
显式类型转换：
在某些情况下，你可能希望明确地将一个基本类型转换为它的包装类类型，以便可以使用包装类提供的额外方法或将其存储在需要对象的集合中。使用 Integer.valueOf() 可以实现这种显式类型转换
装箱（Autoboxing 的替代）：
在 Java 5 及以后的版本中，Java 提供了自动装箱（Autoboxing）和自动拆箱（Autounboxing）的特性。这意味着你可以自动地将基本类型（如 int）和它们的包装类（如 Integer）之间进行转换，int和Integer可以看作同一个对象

		 public static string tobinarystring(int i) 得到二进制
         public static string tooctalstring(int i) 得到八进制
         public static string toHexstring(int i) 得到十六进制
         public static int parseInt(string s) 将字符串类型的整数转成int类型的整数

//4.将字符串类型的整数转成int类型的整数
//强类型语言:每种数据在java中都有各自的数据类型
//在计算的时候，如果不是同一种数据类型，是无法直接计算的。
int i = Integer.parseInt("123");
System.out.println(i);
System.out.println(i + 1);//124
//细节1:
//在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
//细节2:
//8种包装类当中，除了Character都有对应的parseXxx的方法，进行类型转换
String str = "true";
boolean b = Boolean.parseBoolean(str);
System.out.println(b);
  • 8种包装类当中，除了Character都有对应的parseXxx的方法，进行类型转换
  • 在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错

在每次键盘录入接受数据时，sc.nextInt(),sc.next() 遇到空格/回车就停止了
sc.nextLine()遇到回车才停止 因此建议使用nextLine接收数据，在用参数.Intvalue()/doubleValue()/包装类型.parseXxx()进行转换

  • 方式一：先将字符串数字转成Integer，再调用valueOf()方法
  • 方式二：通过Integer静态方法parseInt()进行转换
   //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }

建议：获取Integer对象的时候不要自己new，而是采取直接赋值或者静态方法valueOf的方式

charAt(i)表示一个字符，i为字符的索引

窝窝哇
关注
Java 常用API
weixin_57807561的博客
10-10 2292
Scanner、String、StringBuilder、Math、System、Object、时间日期类、包装类
Windchill 开发常用API介绍
12-19
Windchill 开发常用API介绍，可以参考学习。
PyTorch常用API
qq_61563765的博客
08-21 786
不能保证output在内存中的连续性，需要使用。在指定位置扩展1个维度。按照指定维度拼接在一起。中所有为1的维度删掉。，默认在0维新增一个维度。
Java常用API汇总
Achooyo的博客
08-10 6248
全称应用程序编程接口，就是Java自己写好的程序，给程序员调用的，方便完成一些功能的。使用可查阅API文档。
JAVA常用API
热门推荐
tuoniaoxs的博客
06-06 1万+
Java常用API String、StringBuilder、Math、System、Object、Objects、BigDecimal等
String常用API
qq_46244116的博客
02-14 1815
String常用API 1、public int length​() 返回此字符串的长度 2、public char charAt​(int index) 获取某个索引位置处的字符 3、public char[] toCharArray​()： 将当前字符串转换成字符数组返回 4、public String substring(int beginIndex, int endIndex) 根据开始和结束索引进行截取，得到新的字符串（包前不包后） 5、public String substring(int be
Redis 常用 API
m0_52462015的博客
05-31 4434
Redis 常用 API 1、官方文档 Redis API 官方文档：http://redisdoc.com/ 2、数据库相关 API select 数据库下标 ：切换数据库 Dbsize：查看当前数据库 key 的数量 Flushdb：清空当前数据库 FlushAll：清空所有数据库 注意：Redis 不区分大小写，并且支持自动补全（按 Tab 键）！ 3、key 相关 API keys *：查看当前数据库所有 key exists key key的名字：判断
uniapp常用api
qq_45796592的博客
03-09 3313
uniapp的常用api
Java常用API总结
岛森年的博客
12-18 1212
包括基本数据类型的包装类、String类、Object类等。：包括List、Set、Map等。常用的有ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等。：包括字节流和字符流的API，常用的有InputStream、OutputStream、Reader、Writer等。：包括Socket和ServerSocket等。：包括多线程编程的API，如Thread、Runnable、Executor、Semaphore等。
node常用api
liangzhenmeng的博客
09-06 2686
两种模块化规范、createServer服务、mime、静态资源服务、zlib、gzip、crypto、event、http
Cesium常用API
qq_41366268的博客
11-15 3670
写量测时用到的接口的一点总结
labview 常用API工具 vi
03-02
在"labview 常用API工具 VI"中，我们通常会遇到以下几类API工具VI： 1. **窗口操作**：LabVIEW通过调用user32.dll中的函数，可以实现对窗口的创建、显示、隐藏、移动、大小调整等操作。例如，`CreateWindowEx`用于...
Java学习常用API
09-01
在这个“Java学习常用API”中，我们可能会涵盖以下关键知识点： 1. **基础类库**： - **String类**：用于处理文本字符串，提供了大量的操作方法如concat、substring、indexOf等。 - **ArrayList和LinkedList**：...
Linux-C编程常用API接口-函数
07-18
linux中常用API详细介绍，包含应用例程 1 字符测试篇 2 2 字符串转换篇 10 3 内存控制篇 17 4 日期时间篇 22 5 内存及字符串操作篇 28 6 常用数学函数篇 45 7 用户组篇 56 8 数据结构及算法篇 78 9 文件操作篇 85 10...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 401
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 918
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 965
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 958
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
PowerBuilder常用API详解与示例
"PB常用API汇总，用于学习和参考，包含多个Windows API的介绍，如图形绘制、文件操作、窗口管理等。" 在PowerBuilder（PB）开发中，熟悉和运用Windows API可以扩展应用程序的功能，解决一些PB内置函数无法处理的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值