1.包装类

java有八大基本数据类型 ，都有与之对应的包装类

包装类能实例化对象，包装类下面封装了很多方法可供使用

基本数据是没有的，所以要学他们的包装类

int —> Integer

short —> Short

byte —> Byte

long —> Long

char —> Character

boolean —> Boolean

float —> Float

double —> Double

除了char和int ，其他都是首字母大写

【重点】

  1. 1.JDK1.5版本以后，有装箱和拆箱
  3.     装箱：将基本数据类型转为包装类对象
  5.     拆箱：将包装类转为基本数据类型
  7. 2.***Value();将包装类对象转为基本数据类型（类似上面的自动拆箱）的一个方法
  9. 3.toString(变量名);将基本数据类型转为字符串类型的数据
  11. 4.【重点】 parse***(变量名);将字符串类型转为基本数据类型
  13. 5.valueOf(变量名);将基本数据类型转为包装类类型（类似于自动装箱）
  1. package com.qfedu.test1;
  3. //装箱、拆箱
  4. public class Demo1 {
  5.     public static void main(String[] args) {
  6.         //30本身是int 有自动的强转（byte和short都有）
  7. //        byte byte1 = (byte)30;
  8.         byte byte1 = 30;
  10.         //自动强转未byte类型
  11.         //然后自动装箱，将byte类型的数据变成Byte包装类的对象
  12.         Byte byte2 = 20;
  14.         //这是不自动装箱的效果
  15.         Byte byte3 = new Byte((byte) 50);
  17.         //byte3是byte的包装类型数据，byte4是byte的基本数据类型
  18.         //自动拆箱，将包装类对象转为基本数据类型
  19.         byte byte4 = byte3;
  21.         //***Value   使用方法进行拆箱
  22.         Integer i1 = new Integer(45);
  23.         int i2 = i1.intValue();
  24.         System.out.println(i2);
  26.         Short s1 = 45;
  27.         short s2 = s1.shortValue();
  29.         //toString();将基本数据类型转为字符串类型的数据
  30.         String string1 = Integer.toString(i2);
  31.         System.out.println(string1);//转为字符串了
  33.         //parse***();将字符串类型转为基本数据类型  【重点】
  34.         //将字符串78转为int78
  35.         int int6 = Integer.parseInt("78");
  36.         System.out.println(int6);
  38.         //valueOf();将基本数据类型转为包装类类型（类似于自动装箱）
  39.         byte b9 = 56;
  40.         Byte byte9 = Byte.valueOf(b9);
  42.     }
  43. }

简约版

  1. package com.qfedu.test1;
  3. public class Demo2Test {
  4.     public static void main(String[] args) {
  5.         int i1 = 16;
  6.         Integer i2 = i1;//装箱
  8.         Short short3 = 30;
  9.         short short4 = short3;//拆箱
  11.         Byte byte5 = 20;
  12.         byte byte6 = byte5.byteValue();//类似拆箱
  14.         int i7 = 78;
  15.         String string8 = Integer.toString(i7);//基本类型转字符串
  17.         String string9 = "999";
  18.         int i10 = Integer.parseInt(string9);//字符串转基本类型
  20.         byte b11 = 56;
  21.         Byte b12 = Byte.valueOf(b11);//类似装箱
  22.     }
  23. }

2.Math

专门用来处理数学公式的一个类，都是静态方法，直接类名调用

绝对值 Math.abs(-100)

最大值 Math.max(12, 88) Math.max(10, Math.max(20, 30))//三个数比

最小值 Math.min(10, 20)

向上取整 Math.ceil(3.3) 输出4.0

向下取整 Math.floor(3.3) 输出3.0

四舍五入 Math.round(4.3) 返回值int

随机数 Math.random() [0,1)左开右闭 (int)(Math.random()*(100-50)+50)

指数 Math.pow(2, 3) 2的3次方

离最近的整数 Math.rint(1.5) 1.5离1.0和2.0一样远近，如果有两个，返回偶数

3.Random

专门处理随机数的，比Math.random提供的方法多

  1. package com.qfedu.test3Random;
  3. import java.util.Random;
  5. //Random 随机数生成器
  6. public class Demo1 {
  7.     public static void main(String[] args) {
  8.         Random random = new Random();
  9.         //在自己的范围内进行随机
  10.         System.out.println(random.nextBoolean());//在T、F范围随机
  11.         System.out.println(random.nextInt());//在int范围内随机
  12.         System.out.println(random.nextDouble());//在double范围内随机
  13.     }
  14. }

4.System

系统类，不能被实例化（没有构造方法），提供了静态属性和静态方法

  1. package com.qfedu.test4System;
  3. import java.util.Properties;
  5. public class Demo1 {
  6.     public static void main(String[] args) {
  7.         System.out.println("out流");
  8. //        System.err.println("错误流");
  10.         //从197.1.1 0：0：0 到现在的毫秒数
  11.         System.out.println(System.currentTimeMillis());
  13.         //获取电脑的信息,确定系统属性
  14.         Properties properties = System.getProperties();
  15.         //系统名字
  16.         System.out.println(properties.get("os.name"));
  17.         //系统版本
  18.         System.out.println(properties.get("os.version"));
  19.         //系统用户名字
  20.         System.out.println(properties.get("user.name"));
  21.         //当前项目路径
  22.         System.out.println(properties.get("user.dir"));
  23.         //使用java的版本
  24.         System.out.println(properties.get("java.version"));
  25.     }
  27. }
  29. 输出：
  30. out流
  31. 1649387512875
  32. Windows 10
  33. 10.0
  34. ZHU
  35. D:\eclipse-workspace\day408
  36. 1.8.0_241

5.Runtime

获取java运行时的一些信息，不能被实例化（没有构造方法），通过getRuntime在获取

Runtime runtime = Runtime.getRuntime();

  1. package com.qfedu.test5Runtime;
  3. import java.io.IOException;
  5. public class Demo1 {
  6.     public static void main(String[] args) throws IOException {
  7.         //不能实例化，只能靠这种方式搞出对象
  8.         Runtime runtime = Runtime.getRuntime();
  9.         //返回java虚拟机尝试使用的最大内存量，以字节为单位/1024/1024 变成M单位
  10.         System.out.println(runtime.maxMemory()/1024/1024);
  11.         //java虚拟机可用的内存量
  12.         System.out.println(runtime.freeMemory()/1024/1024);
  13.         //java虚拟机的内存总量，会随着时间变化
  14.         System.out.println(runtime.totalMemory()/1024/1024);
  16.         //exec(String command)
  17.         //可以使用这个打开电脑的某个程序-->微信的.exe位置
  18.         runtime.exec("D:\\微信\\WeChat\\WeChat.exe");
  20.     }
  21. }

6.util包下的Date类

过期的一些方法

  1. package com.qfedu.test6Date;
  3. import java.util.Date;
  5. import javax.xml.crypto.Data;
  7. public class Demo1 {
  8.     public static void main(String[] args) {
  9.         Date date = new Date();
  10.         //Fri Apr 08 14:14:56 CST 2022
  11.         System.out.println(date);
  13.         //获取年份-1900
  14.         System.out.println(date.getYear() + 1900);
  16.         //老外的0代表1月 所以要 + 1
  17.         System.out.println(date.getMonth() + 1);
  19.         //打印的是这周的第几天 0是星期天 1星期一 5星期五 6星期六
  20.         System.out.println(date.getDay());
  22.         System.out.println(date.getHours());//时
  23.         System.out.println(date.getMinutes());//分
  24.         System.out.println(date.getSeconds());//秒
  25.     }
  26. }

7.Calendar类

用来处理日期、时间的一个抽象类，不能被实例化，替换了Date。

通过getInstance()来获取他的方法

Calendar calendar = Calendar.getInstance();

  1. package com.qfedu.test7Calendar;
  3. import java.text.SimpleDateFormat;
  4. import java.time.Year;
  5. import java.util.Calendar;
  6. import java.util.Date;
  8. public class Demo1 {
  9.     public static void main(String[] args) {
  10.         Calendar calendar = Calendar.getInstance();
  12.         System.out.println(calendar.get(Calendar.YEAR));
  13.         //外国习惯从0开始 所以 + 1 
  14.         System.out.println(calendar.get(Calendar.MONTH) + 1);
  15.         //获取当月的第几天
  16.         System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
  17.         //获取这一周的第几天  周日是第一天 周五是第六天
  18.         System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
  19.         //获取这一年的第几天 
  20.         System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
  21.         //时 12小时制
  22.         System.out.println(calendar.get(Calendar.HOUR));
  23.         System.out.println(calendar.get(Calendar.MINUTE));//分
  24.         System.out.println(calendar.get(Calendar.SECOND));//秒
  26.         System.out.println("----------------------------");
  28.          Date date = calendar.getTime();
  29.          System.out.println(date);
  30.          //对上面date格式化，弄成能看懂的格式
  31.          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  32.          SimpleDateFormat sdf1 = new SimpleDateFormat("y-M-d H:m:s");
  33. //         SimpleDateFormat sdf1 = new SimpleDateFormat("YYYY-MM-DD HH:MM:SS");
  34.          System.out.println(sdf.format(date));
  35.          System.out.println(sdf1.format(date));
  36.     }
  38. }

练习：指定日期到现在的天数

  1. package com.qfedu.test7Calendar;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Calendar;
  6. import java.util.Date;
  8. public class Demo2 {
  9.     public static void main(String[] args) throws ParseException {
  11.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  13.         String string = "2022-04-01";
  14.         //讲字符串类型数据进行解析成Date类型才可以计算
  15.         Date date = sdf.parse(string);
  16.         //将时间转换成毫秒数 long 才能进行计算差值
  17.         long dateTime = date.getTime();//2022.4.1到1970.1.1之间的毫秒数
  19.         Date date1 = new Date();
  20.         long todayTime = date1.getTime();//获取当前日期到1970.1.1的毫秒数
  22.         long time = todayTime - dateTime;
  24.         //除1000毫秒变秒 除60变分 除60变小时 除24变天
  25.         System.out.println(time/1000/60/60/24);
  26.     }
  28. }