Day_16_常用API

最新推荐文章于 2024-08-12 16:47:32 发布

势不可挡の内鬼

最新推荐文章于 2024-08-12 16:47:32 发布

阅读量72

点赞数

分类专栏：学习日志文章标签： java

本文链接：https://blog.csdn.net/m0_51589970/article/details/120853138

版权

学习日志专栏收录该内容

52 篇文章 0 订阅

订阅专栏

1. 包装类

1.1 包装类为什么存在、什么是包装类

Java是面向对象的语言，但是java中的基本数据类型不是对象，而我们在实际应用中经常需要将基本数据类型转化为对象，所以就有了包装类，包装类的产生就是为了解决基本数据类型存在的这样一些问题，通过包装类可以让基本数据类型获取对象一样的特征，以便于我们操作。

1.2 基本使用

public class Integer_01 {

	public static void main(String[] args) {
		//基本类型
		byte b= 10;
		//转为了引用类型
		byte b1 = new Byte(b);
		Integer i1 = new Integer(11);
		Boolean b2 = new Boolean(false);
		//方法调用传递
		m1(b1);
	}
	//需求：声明一个方法，该方法可以接受所有类型的值
	//多态
public static void m1(Object obj) {
	//包装类都覆写了equals和toString
	System.out.println(obj);
}
}

1.3 Integer

1.3.1 基本使用

public static void main(String[] args) {
		//获得最大值和最小值
		System.out.println("int最大值为："+Integer.MAX_VALUE);
		System.out.println("int最小值为："+Integer.MIN_VALUE);
		System.out.println(Byte.MAX_VALUE);
		System.out.println(Long.MAX_VALUE);
		
		//创建Integer对象
		//int类型转换为Integer类型
		Integer i1 = new Integer(10);
		//可以直接把纯数字的字符串转为Integer类型
		Integer i2 = new Integer("10");
		System.out.println(i1);
		System.out.println(i2);
		System.out.println(i1 == i2);
		//true     覆写了equals
 		System.out.println(i1.equals(i2));
	}

1.3.2 常用方法

public static void main(String[] args) {
		//1.对象int ----> Integer
		Integer i1 = new Integer(10);
		//2.Integer ----> int
		int i2 = i1.intValue();
		System.out.println(i2);
		//3.static int parselnt(String s);  把纯数字字符串转换为int类
		//String ---->int 必须是纯数字字符串，小数也不行
		int i3 = Integer.parseInt("123");
		System.out.println(i3);
		//小数允许有一个小数点
		double d = Double.parseDouble("3.14");
		System.out.println(d);
		
		//将int类型的值，转换为二进制的字符串表示
		//static String toBinaryString(int value);
		String s1 = Integer.toBinaryString(11);
		System.out.println(s1);
		//转为16进制
		System.out.println(Integer.toHexString(11));
		//转为8进制
		System.out.println(Integer.toOctalString(11));
		//int ----> Integer
		Integer i4 = Integer.valueOf(11);
		//String ----> Integer
		Integer i5 = Integer.valueOf("11");
		System.out.println( i4 == i5 );
		
	    }

1.3.3 类型转换

public static void main(String[] args) {
		//1. int ---->Integer
		Integer i1 = Integer.valueOf(11);
		//2. Integer ---->int
		int i2 = i1.intValue();
		//3. String ---->Integer
		Integer i3 = Integer.valueOf("22");
		//4. Integer ---->String
		String s1 = i3.toString();
		//5. String ---->int
		int i4 = Integer.parseInt("1234");
		//6. int ---->String
		String s2 = 2 + "";
	}

1.3.4 自动装箱和自动拆箱

JDK1.5开始新特性：

自动装箱:把基本类型自动转换为对应的包装类类型

自动拆箱:把对应的包装类类型自动转换为基本类型

自动装箱和自动拆箱是在编译阶段完成的

public static void main(String[] args) {
		//装箱和拆箱
		Integer i1 = Integer.valueOf(11);
		int i2 = i1.intValue();
		
		//自动装箱和拆箱
		Integer i3 = 2;
		int i4 = i3;
		//此时10是int类型，int类型是没办法转换为Object类型的
		//所以需要把int自动装箱为Integer类型，然后发生多态转换为Object类型
		m1(10);
	}
	public static void m1(Object obj){
		System.out.println(obj);
	}

1.3.5 整型常量池

  深入理解自动装箱自动拆箱
        1.都是编译时进行的操作
        2.自动装箱的时候会把赋值的操作改编为Integer.valueOf(值)

  Integer.valueOf() 底层实现：

        public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
   return IntegerCache.cache[i + (-IntegerCache.low)];
   return new Integer(i);
        }
IntegerCache是Integer中的静态内部类，也就是我们说的整型常量池
        static final int low = -128;
        static final int high = 127;
        static final Integer cache[];
        在static语句块中，对cache数组进行初始化操作
   cache = new Integer[(high)-(low)+1];       长度为256
   初始化数组中的数据
   cache[k] = new Integer(j++);
   数组中数据为-128，-127，-126......127 共256个数字，下标为0~255
   此时整型常量池初始化完成，在堆内存中创建了256个对象

   valueOf方法中这么写的
   // 判断要赋值的数据值是否在-128到127之间
   if (i >= IntegerCache.low && i <= IntegerCache.high)
   // 如果在这个范围内的话,之间在case数组中把对应的对象的地址拿出来,返回回去
   return IntegerCache.cache[i + (-IntegerCache.low)];
   // 如果不再这个范围内的话,就new一个新的对象,保存这个数据
     return new Integer(i);
   所以我们写Integer i1 = 123; Integer i2 = 123; 使用==判断时他们两个是相等的，因为他们指向堆内存吗，反之，我们写Integer i3 = 128; 就等于 Integer i3 = new Integer(128)，如果使用==判断，那么显然是不相等的，使用equals判断才可以

2. System

2.1 是什么

System代表系统，系统中很多的控制方法和属性都在这个类中，位于java.lang包下
longcurrentTime Millis(): 获取当前系统时间的毫秒数，从1970-1-1 0:0:0 000 开始，我们这个地区时间初始值为 1970.1.1 8:00:00 000

void exit(int status): 退出虚拟机，参数为0代表正常退出，非0代表异常退出，常用于图形界面，实现退出功能

2.2 怎么用

public static void main(String[] args) {
		//计算时间差
		long startTime = System.currentTimeMillis();
		String[] strs = { "a", "b", "c", "d", "e", "f", "a", "b", "c", "d" };
		String temp = "";
		// for (int i = 0; i < strs.length; i++) {
		// temp += strs[i] + ",";
		// }
		//数据量小的时候观察不出来二者的时间差
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < strs.length; i++) {
			sb.append(strs[i] + ",");
		}
		temp = sb.toString();
		System.out.println(temp);
		long endTime = System.currentTimeMillis();
		// 关闭JVM , 0 正常退出, 非0 异常退出, 一般用于关闭图形界面
		System.exit(0);
		System.out.println("耗时 : " + (endTime - startTime) + "毫秒");
	}

3. Date

3.1 是什么

表示特定的瞬间，精确到毫秒

3.2 构造方法

//获取当前系统时间
		Date d1 = new Date();
		//获取时间原点到指定毫秒数的时间
		d1 = new Date(1000000000);
		System.out.println(d1);

3.3 时间格式化

Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat

类是一个不与语言环境有关的方式来格式化和解析日期的具体类。

//年 y , 月 M , 日 d , 小时 H , 分 m , 秒 s , 毫秒 S
		//创建格式化对象，并指定格式
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
		//对时间进行格式化，返回字符串类型
		String strDate = sdf.format(d1);
		// 1970年01月01日 08:00:01 000
		System.out.println(strDate);
		
		// 解析 , 字符串格式 必须和解析格式一致
		Date d2 = sdf.parse(strDate);
		System.out.println(d2);

public static void main(String[] args) {
		//获取当前时间的毫秒数
		long time = System.currentTimeMillis();
		//减去十分钟的毫秒数
		time -= 10*60*1000;
		Date d= new Date(time);
		
		//格式化
		SimpleDateFormat sdf =  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss 	SSS");
		System.out.println(sdf.format(d));
	
		}

4. Calendar

4.1 是什么

Calendar是一个抽象基类（日历类），主用用于完成日期字段之间相互操作的功能

4.2 方法

获取Calendar实例的方法

使用Calendar.getInstance()方法

调用它的子类GregorianCalendar的构造器。

3、一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、 MINUTE、SECOND

public void set(int field,int value)

public void add(int field,int amount)

public final Date getTime()

public final void setTime(Date date)

4、注意:

获取月份时：一月是0，二月是1，以此类推，12月是11

获取星期时：周日是1，周一是2.........周六是7

public class Calendar_01 {

	public static void main(String[] args) {
		//获取日历对象
		Calendar c = Calendar.getInstance();
		//获取当前是本周的第几天，第一天为周日，最后一天为周六
		int i = c.get(Calendar.DAY_OF_WEEK);
		System.out.println(i);
		//获取年
		int year = c.get(Calendar.YEAR);
		//获取月，从0开始，所以要加一
		int month = c.get(Calendar.MONTH)+1;
		//获取日
		int day = c.get(Calendar.DAY_OF_MONTH);
		//时
//		int hour = c.get(Calendar.HOUR);
		//24小时制
		int hour = c.get(Calendar.HOUR_OF_DAY);
		//分
		int minute = c.get(Calendar.MINUTE);
		//秒
		int second = c.get(Calendar.SECOND);
		//获取星期
		int weekday = c.get(Calendar.DAY_OF_WEEK);
		String weekdayStr = getWeekday(weekday);
		System.out.println(year + "年" + month + "月" + day + "日 " + hour + ":"
				+ minute + ":" + second + " " + weekdayStr);
			
	}
	public static String getWeekday(int weekday) {
		String weekdayStr ="";
		switch (weekday) {
		case 1:
			weekdayStr = "星期日";
			break;
		case 2:
			weekdayStr = "星期一";
			break;
		case 3:
			weekdayStr = "星期二";
			break;
		case 4:
			weekdayStr = "星期三";
			break;
		case 5:
			weekdayStr = "星期四";
			break;
		case 6:
			weekdayStr = "星期五";
			break;
		case 7:
			weekdayStr = "星期六";
			break;
		default:
			break;
		}
		return weekdayStr;
		}
}

5. Math

5.1 是什么

提供科学计算和基本的数字操作，常用方法都为静态，都可以直接调用

都在java.lang下，使用不需要导包

public class Math_01 {

	public static void main(String[] args) {
		// abs 绝对值
		System.out.println(Math.abs(-1.2));
		// ceil : 向上取整
		System.out.println(Math.ceil(1.0001));
		// floor : 向下取整
		System.out.println(Math.floor(2.999999));
		// max : 比较谁大
		System.out.println(Math.max(2.3, 2.2));
		// min : 比较谁小
		System.out.println(Math.min(2.3, 2.2));
		// 平方根  开平方
		System.out.println(Math.sqrt(16));
		// 立方根  开立方
		System.out.println(Math.cbrt(8));
		// 随机数 : 获取一个大于等于0 且 小于1 的数
		System.out.println(Math.random());
		// 向下取整( 随机数*(最大-最小 +1) + 最小)
		System.out.println(Math.random()*10 + 10);
		// 四舍五入 : 四舍六入五留双, 小数大于0.5 就进位,小于0.5就舍弃,如果是0.5整 , 取偶数
		// 2.50001 : 3  , 3.50000 : 4 , 2.50000 : 2
		System.out.println(Math.rint(2.5001));
		// 2的3次方
		System.out.println(Math.pow(2, 3));
			}
		}

6. BigInteger

6.1 是什么

1、Integer类作为int的包装类，能存储的最大整型值为231-1，Long类也是有限的,最大为263-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

2、java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供

所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

6.2 常用方法

public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger。

BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger

BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger

BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger

BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。

BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger。

BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组。

BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的 BigInteger。

6.3 使用

package BigInteger_01;

import java.math.BigDecimal;
import java.math.BigInteger;

public class BigInteger_01 {

	public static void main(String[] args) {
		//参数时字符串
		BigInteger v0 = new BigInteger("11");
		//参数是数值
		BigDecimal  v1 = new BigDecimal("20");
		BigDecimal  v2 = new BigDecimal("10");
		
		//+
		BigDecimal v3 = v1.add(v2);
		// -
		v3 = v1.subtract(v2);
		// *
		v3 = v1.multiply(v2);
		// /
		v3 = v1.divide(v2);
		// %	
		v3 = v1.remainder(v2);
		System.out.println(v3);
		System.out.println(Long.MAX_VALUE);
		BigDecimal sum = new BigDecimal(1);
		for (int i = 1; i <=100; i++) {
			sum = sum.multiply(new BigDecimal(i));
		}
		System.out.println(sum);
	}

}

7. Random

package Random_01;

import java.util.Random;

public class Random_01 {

	public static void main(String[] args) {
		//random随机数生成器    默认大于0小于1
		Random r = new Random();
		//大于等于=且小于10的整数
		int result = r.nextInt(10);
		System.out.println(result);
		
		//生成10~20
		//nextln(最大值-最小值+1)+最小值
		result = r.nextInt(11)+10;
		System.out.println(result);
		
		//生成a~z
		result  = r.nextInt(26);
		char c = (char) (result + 97);
		System.out.println(c);
		
	}

}

势不可挡の内鬼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day_16_常用API

1. 包装类1.1 包装类为什么存在、什么是包装类 Java是面向对象的语言，但是java中的基本数据类型不是对象，而我们在实际应用中经常需要将基本数据类型转化为对象，所以就有了包装类，包装类的产生就是为了解决基本数据类型存在的这样一些问题，通过包装类可以让基本数据类型获取对象一样的特征，以便于我们操作。1.2 基本使用public class Integer_01 { public static void main(String[] args) { //基本类型...
复制链接

扫一扫