常用类(工具类)之Scanner，包装类，数学类，日期类

爱被打了一巴掌 2022-11-05 15:54 458阅读 0赞

[Scanner][]  
**包装类**  
包装类(封装类) 1.5版本之后 自动拆装包

<table> 
 <thead> 
  <tr> 
   <th>byte</th> 
   <th>Byte</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer 【特殊】</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character 【特殊】</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

1.  八个包装类都在同一个包下 java.lang包 不需要import导包直接使用
2.  八个包装类中有六个是与数字相关 都默认继承父类Number
3.  八个包装类都实现了Serializable, Comparable
4.  八个包装类都有带自己对应类型参数的构造方法  
    八个包装类中有七个(除了Character)还有构造方法重载 带String类型
5.  创建对象 对象调用方法  
    有六个与数字相关的类都继承Number xxxValue(); 将一个包装类类型转化为对应的基本类型(拆包)

> Integer i1 = new Integer(10);//引用数据类型 包装类 int value = i1.intValue();
> 
> Integer i2 = 10; int value = new Integer(10);
> 
> int value = Integer.parseInt(“123”); Float.parseFloat(“123.45”)  
> int value = new Integer(“123”);

1.  经常在笔试中出现的问题

Integer i1 = 10;
    		Integer i2 = 10;
    		Integer i3 = new Integer(10);
    		Integer i4 = new Integer(10);
    		System.out.println(i1==i2);//  true--->如果数字范围超过127false
    		System.out.println(i1==i3);//  false
    		System.out.println(i3==i4);//  false
    		System.out.println(i1.equals(i2));//true
    		System.out.println(i1.equals(i3));//true
    		System.out.println(i3.equals(i4));//true

**1.==与equals()区别**

> == 可以比较基本数据类型 也可以比较引用数据类型 (变量中存储的内容) 如果比较基本类型比较是变量中存储的值 如果比较引用类型比较是变量中存储的地址引用 equals()是Object类中继承过来的方法 每一个引用类型都可以调用默认继承的equals()方法比较与==一致  
> 如果想要改变比较规则 可以重写equals方法  
> 由于Integer类就重写了equals() 所以Integer比较的是数值

**2.考察Integer类加载的时候 自己有一个静态的空间**

> 空间内立即加载 Integer类型的数组 内存储256个Integer对象 -128 ~ 127  
> 如果我们用的对象范围在这之内Integer i1 = 10; 直接取静态区中找对应的对象  
> 如果我们用的对象范围超出了这个Integer i1 = 1000; 会帮我们创建一个新的Integer对象

**示例代码：**

public class TestUtil {
    
        public static void main(String[] args){
            new TestUtil().equals(null);
            Integer i1 = 1000;//10自动包装成Integer对象
            Integer i2 = 1000;
            Integer i3 = new Integer(1000);
            Integer i4 = new Integer(1000);
            System.out.println(i1==i2);//true-->false
            System.out.println(i1==i3);//false
            System.out.println(i3==i4);//false
            System.out.println(i1.equals(i2));//true
            System.out.println(i1.equals(i3));//true
            System.out.println(i3.equals(i4));//true
    
        }
    
    }

**与数学相关的类**  
**Math**

1.  所属的包java.lang
2.  Math构造方法是私有的 我们不能直接调用创建对象
3.  由于Math中提供的属性及方法都是static 不需要创建对象
4.  常用的方法

abs()返回给定数字的绝对值    (参数 int long float double)
    		double = ceil()向上取整
    		double = floor()向下取整
    		double = rint()临近的整数 如果两边距离一样 则返回偶数
    		int = round()  四舍五入的整数
    		max(a,b)  min(a,b)    (参数int  long  float  double)
    		pow(a,b)  a的b次方  (参数double 返回值double)
    		sqrt(double a)  获取给定参数的平方根
    		double = random();	  随机产生一个     [0.0--1.0)

1.  Math.random()计算小数的时候精确程度可能有些损失

> 0-9之间的随机整数  
> int value = (int)(Math.random()\*10);

> 5.0—10.9之间的小数  
> (Math.random()\*6)+5

> 0.0—0.99999 \* 6  
> (0.0—5.49999)+5

**Random类**

1.  在java.util包中的类 需要import导入
2.  没有任何继承关系 默认继承Object类
3.  查找构造方法—>如何创建对象  
    Random r = new Random();
4.  类中提供的常用方法

> 获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt()  
> 获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3)  
> 实际上代表的含义是：\[0,3)，也就是0~2

注意：bound必须为正数 否则会出现如下的运行时异常  
IllegalArgumentException

r.nextFloat() 随机产生一个 \[0.0—1.0)  
r.nextBoolean() 随机产生一个boolean值 true false

**练习**：帮助理解  
用代码模拟猜数字的小游戏。

思路：
    1. 首先需要产生一个随机数字，并且一旦产生不再变化。用Random的nextInt方法
    2. 需要键盘输入，所以用到了Scanner
    3. 获取键盘输入的数字，用Scanner当中的nextInt方法
    4. 已经得到了两个数字，判断（if）一下：
        如果太大了，提示太大，并且重试；
        如果太小了，提示太小，并且重试；
        如果猜中了，游戏结束。
    5. 重试就是再来一次，循环次数不确定，用while(true)。
     */
    public class Demo04RandomGame {
    
        public static void main(String[] args) {
            Random r = new Random();
            int randomNum = r.nextInt(100) + 1; // [1,100]
            Scanner sc = new Scanner(System.in);
    
            while (true) {
                System.out.println("请输入你猜测的数字：");
                int guessNum = sc.nextInt(); // 键盘输入猜测的数字
    
                if (guessNum > randomNum) {
                    System.out.println("太大了，请重试。");
                } else if (guessNum < randomNum) {
                    System.out.println("太小了，请重试。");
                } else {
                    System.out.println("恭喜你，猜中啦！");
                    break; // 如果猜中，不再重试
                }
            }
    
            System.out.println("游戏结束。");
        }
    
    }

**UUID类**

1.  所属的包 java.util 需要import导入
2.  没有任何继承关系 默认继承Object类
3.  构造方法有 没有无参数的 我们通常不会创建对象

> UUID uuid = UUID.randomUUID();  
> System.out.println(uuid.toString());//数据库表格主键 primary key 产生一个32位的随机元素 每一个位置是一个16进制的数字

**BigInteger类**  
大整数 long -2的63次方 ~ 2的63次方-1

1.  所属的包java.math 需要import导入
2.  继承自Number
3.  如何创建对象 提供的构造方法全部都是带参数的

> 通常利用带String参数的构造方法创建这个类的对象  
> BigInteger bi = new BigInteger(“123”);

1.  类中的常用方法

> 做四则运算 ： add() subtract() multiply() divide()

**小例子 设计一个方法 用来计算给定数字的阶乘 5 1*2*3*4*5==120**

//设计一个方法  用来计算给定数字的阶乘
    		//参数   返回值
    		public BigInteger factorial(int num){
    			BigInteger result = new BigInteger("1");
    			for(int i=1;i<=num;i++){
    				result = result.multiply(new BigInteger(i+""));
    			}
    			return result;
    		}

**BigDecima类**  
超过了double取值范围

1.  所属的包 java.math包
2.  继承Number类
3.  通常也是可以通过 带String参数 构建对象
4.  类中的常用方法

> 做四则运算 ：add() ， subtract() ， multiply() ， divide()  
> 两个参数前面是保留小数点之后的位数  
> 后面参数是设置的模式  
> 对象.setScale(2,BigDecimal.ROUND\_DOWN);

**DecimalFormat**  
将小数点之前和之后的位数都能处理的类---->格式化

1.  所属的包 java.text
2.  import导入才能使用
3.  通过带String参数的构造方法创建一个格式化对象 0 \#
4.  调用format方法将一个小数格式化成一个字符串

DecimalFormat df = new DecimalFormat("000.###");// 0 #
    		String value = df.format(12.45);
    		System.out.println(value);

**实例代码：**

public class TestMath {
    
        //设计一个方法  用来计算给定数字的阶乘
        //参数   返回值
        public BigInteger factorial(int num){
            BigInteger result = new BigInteger("1");
            for(int i=1;i<=num;i++){
                result = result.multiply(new BigInteger(i+""));
            }
            return result;
        }
    
        public static void main(String[] args){
    //        System.out.println(Math.ceil(1.4));//1.0
    //        System.out.println(Math.floor(1.4));//1.0
    //        System.out.println(Math.rint(1.4));//1.0
    //        System.out.println(Math.round(1.4));//1
    //        System.out.println(Math.sqrt(16));
    //
    //        Random r = new Random();
    //        int value = r.nextInt();//随机产生一个整数
    //        System.out.println(value);// -2147483648 ~  2147483647
    //
    //        int result = r.nextInt(10);
    //        System.out.println(result);//  [0--10)
    //
    //        float f = r.nextFloat();
    //        System.out.println(f);//  [0.0---1.0)
    //
    //        //5.0---10.9范围
    //        float x = (r.nextInt(6)+5 + r.nextFloat());
    //
    //        UUID uuid = UUID.randomUUID();
    //        System.out.println(uuid.toString());//数据库表格主键 primary key
    //
    //        BigInteger  bi1 = new BigInteger("123");
    //        BigInteger  bi2 = new BigInteger("456");
    //        bi1.add(bi2);
    //        bi1.subtract(bi2);
    //        bi1.multiply(bi2);
    //        bi1.divide(bi2);
    
    
            //创建对象 调用计算阶乘的方法
            TestMath tm = new TestMath();
            BigInteger result = tm.factorial(25);
            System.out.println(result);
    
            BigDecimal decimal = new BigDecimal("123.456");
            //小数点之后保留两位  按照向下取整的方式进行截取
            decimal = decimal.setScale(2,BigDecimal.ROUND_DOWN);
            System.out.println(decimal);
    
            DecimalFormat df = new DecimalFormat("000.###");// 0 #
            String value = df.format(12.45);
            System.out.println(value);
        }
    }

**补充**

> System类  
> 1.所属的包java.lang包 不需要导入  
> 2.不需要创建对象 通过类名就可以访问  
> 3.有三个属性及若干的方法 三个属性out in err 方法gc() exit(0); currentTimeMillis();

**日期相关**  
**Date类**

1.  通常使用的是java.util包
2.  导包 拿来使用 构建对象
3.  通常使用无参数的构造方法 或者带long构造方法
4.  Date类中常用的方法

before();  after();
    	setTime()  getTime();----->long
    	compareTo();   -1  1  0

1.  可以处理一个Date日期的格式

**DateFormat类**

1.  包java.text 需要导包使用
2.  此类是一个抽象类 不能创建对象 子类来使用
3.  SimpleDateFormat类 是DateFormat的子类
4.  调用带String参数的构造方法创建format对象

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String v = sdf.format(date1);//通过sdf对象将date1格式化成你描述的样子

**Calendar类** 1.1版本

1.  所属的包java.util 需要导包
2.  有构造方法 用protected修饰的 通常访问不到 通常会调用默认的getInstance();
3.  常用方法

after()  before()
    		setTime()  getTime()---->Date
    		getTimeInMillis()----time
    		getTimeZone()---TimeZone
    		Calendar里面包含一个date属性  可以操作date的某一个局部信息
    		set   get
    		calendar.set(Calendar.YEAR,2015);
            		int year = calendar.get(Calendar.YEAR);

**TimeZone**

1.  java.util包
2.  可以通过calendar对象.getTimeZone()获取 或 TimeZone.getDefault();
3.  常用方法

tz.getID()	   ---->    Asia/Shanghai
    tz.getDisplayName()   中国标准时间

**示例代码：**

public class TestDate {
    
        public static void main(String[] args){
            //返回当前系统时间与计算机元年之间的毫秒差
            //1970-1-1  00:80:00
            long time = System.currentTimeMillis();
            System.out.println(time);
            //1545364985172
            //1545365000042
            //1545365012877
            Date date1 = new Date(1545364985172L);//15分钟之前的时间
            Date date2 = new Date();//默认就是用当前的系统时间构建的date对象
            System.out.println(date2);//重写了toString  格林威治格式Fri Dec 21 12:12:12 CST 2018
    
            boolean x = date1.before(date2);//date1是否在date2之前
            boolean y = date1.after(date2);//date1是否在date2之后
    
            //date对象中应该有一个long的属性 time
            date1.setTime(1545365012877L);//设置date1的时间 毫秒值
            long reTime= date1.getTime();//获取date1的时间 毫秒值
            System.out.println(x+"--"+y);
            System.out.println(date2.compareTo(date1));//按照顺序比较  -1调用在前参数在后  1刚好相反
    
            //2018-12-21 12:19:16
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String v = sdf.format(date1);//通过sdf对象将date1格式化成你描述的样子
            System.out.println(v);
    
            Calendar calendar = Calendar.getInstance();//系统当前时间的calendar对象
            //java.util.GregorianCalendar[name=value,name=value]
            System.out.println(calendar);
            calendar.set(Calendar.YEAR,2015);
            int year = calendar.get(Calendar.YEAR);
            int month = calendar.get(Calendar.MONTH);//从0开始数
            int day = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(year+"--"+month+"--"+day);
    
            TimeZone tz = calendar.getTimeZone();
            //TimeZone tz = TimeZone.getDefault();
            System.out.println(tz);
            System.out.println(tz.getID());
            System.out.println(tz.getDisplayName());
    
        }
    
    }

[Scanner]: https://editor.csdn.net/md/?articleId=113901664