Math

Math类概述

Math包含执行基本数字运算的方法

由于Math的成员都是静态的，所以可以通过类名直接调用

Math类的常用方法

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值，等于一个整数
public static double floor(double)	返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)	按照四舍五入返回最接近参数的int
public static int max(int a, int b)	返回两个int值中的较大值
public static int min(int a , int b)	返回两个int值中的较小值
public static double pow(double a, double b)	返回a的b次幂
public static double random()	返回值为double的正值，[0.0, 1.0)

例：

package com.test;

public class MathDemo {
    public static void main(String[] args) {

        System.out.println(Math.abs(88));
//        输出88
        System.out.println(Math.abs(-88));
//        输出88

        System.out.println(Math.ceil(12.34));
//        输出13.0
        System.out.println(Math.ceil(12.56));
//        输出13.0

        System.out.println(Math.floor(12.34));
//        输出12.0
        System.out.println(Math.floor(12.56));
//        输出12.0

        System.out.println(Math.round(12.34));
//        输出12
        System.out.println(Math.round(12.56));
//        输出13

        System.out.println((int)(Math.random()*100) + 1);
//        输出[1,100]的随机数
    }
}

System

System类概述

System包含几个有用的类字段和方法，它不能被实例化

System类的常用方法

方法名	说明
public static void exit(int status)	终止当前运行的Java虚拟机，非0表示异常终止
public static long currentTimeMillis()	返回当前时间（以毫秒为单位）自1970年1月1日零点到目前所经历的毫秒数

例：计算循环1000次所需要的时间

public class SystemDemo {
    public static void main(String[] args) {
        
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

Object

Object类的概述

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

构造方法：public Object()

在面向对象中，之所以子类的构造方法默认访问的是父类的无参构造方法，
是因为他们的*父类只有无参构造方法

Object类中的toString()方法

返回对象的字符串表示形式。一般来说，toString方法返回一个" toString代表"这个对象的字符串。结果应该是一个简明瓶要的表达，容易让人阅读。建议所有子类覆盖此方法。

该toString类方法Object返回一个由类的名称，其中所述对象是其实例，该符号字符"的字符串@ ”，并且对象的哈希码的无符号的十六进制表示。换句话说，这个方法返回一个等于下列值的字符串:

​ getClass.getName( ) + '@' + Integer.toHexString(hashCode( ) )

结果为妒忌心的字符串表示形式

SystemDemo.java

package com.zeng;

public class SystemDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setId("001");
        s.setName("zeng");
        s.setAge(18);
        s.setAddress("jiangxi");
        System.out.println(s);
    }
}

重写toString( )方法前的结果：com.zeng.Student@1b6d3586

重写toString( )方法后的结果：Student{id='001', name='zeng', age=18, address='jiangxi'}

Object类的常用方法

方法名	说明
public String toString( )	返回对象的字符串表示形式。建议所有子类重写该方法，自动生成
public boolean equals(Object obj)	比较对象是否相等。默认比较地址，重写可以比较内容，自动生成
public Class<?> getClass()	获取对象的运行时对象的类,一般 对象.getClass().getName() 返回全包名

Arrays

冒泡排序

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

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

• 如果有n个数据就行排序，总共需要比较n-1次
• 每一次比较完毕，下一次的比较就会少一个数据参与

Arrays类的概述和常用方法

Arrays类包含用于操作数组的各种方法

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

例：

package com.test;

import java.util.Arrays;

/**
 * 排序前：[3, 5, 9, 1, 7]
 * 排序后：[1, 3, 5, 7, 9]
 */
public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {3,5,9,1,7};

        System.out.println("排序前：" + Arrays.toString(arr));

        Arrays.sort(arr);

        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

工具类设计思想：

• 构造方法用private修饰（防止外界创建对象）
• 成员用public static修饰（使用类名来访问该成员方法）

基本类型包装类

基本类型包装类概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换

基本数据类型和包装类的对应关系

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

Integer类的概述和使用

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

方法名	说明
public Integer(int value)	根据int值创建Integer对象（过时）
public Integer(String s)	根据String值创建Integer对象（过时）
public static Integer valueOf(int i)	返回表示指定的int值的Integer实例
public static Integer valueOf(String s)	返回一个报错指定值的Integer对象String

例：

package com.test;

/**
 * 100
 * 100
 */
public class IntegerDemo {
    public static void main(String[] args) {

        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);

        Integer i2 = Integer.valueOf("100");
        System.out.println(i2);
    }
}

int和String的相互转换

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

• int转换为String

public static String valueOf (int i)：返回int参数的字符串表示形式。该方法是String类中的方法

• String转换为int

public static int parseInt (String s)：将字符串解析为int类型。该方法是Integer类中的方法

例：

package com.test;

/**
* int和String的相互转换
*/
public class IntegerDemo {
   public static void main(String[] args) {

//        int->String
       int num = 100;
//        public static String valueOf (int i)
       String s1 = String.valueOf(num);
       System.out.println(s1);

//        String->int
       String s = "100";
//        public static int parseInt (String s)
       int x = Integer.parseInt(s);
       System.out.println(x);
   }
}

案例：字符串中数据排序

需求：有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：“27 38 46 50 91”

思路：

1. 定义一个字符串

2. 把字符串中的数字数据存储到一个int类型的数组中

   • 得到字符串中每一个数字数据？

     public String[] split (String regex)

   • 定义一个int数组，把String[]数组中的每一个元素存储到int数组中

     public static int parseInt(String s)

3. 对int数组进行排序

4. 把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现

5. 输出结果

代码演示：

package com.test;

import java.util.Arrays;

public class IntegerTest {
    public static void main(String[] args) {

        String s = "91 27 46 38 50";

        String[] strArray = s.split(" ");

        int[] arr = new int[strArray.length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(strArray[i]);
        }

        Arrays.sort(arr);

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                sb.append(arr[i] + " ");
            } else {
                sb.append(arr[i]);
            }
        }
        String res = sb.toString();

        System.out.println(res);
    }
}

自动装箱与拆箱

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

Integer i = 100;	//自动装箱
i += 200;	//i = i + 200;	i + 200自动拆箱；	i = i + 200；是自动装箱

注意：在使用包装类类型的时候，如果做操作，最好先判断是否为null

​ 只要是对象，在使用前就必须进行不为null的判断

日期类

Date类概述和构造方法

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

方法名	说明
public Date()	分配一个Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)	分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

注：标准基准时间（称为“时代”）即1970年1月1日00：00：00GMT起的指定毫秒数

package com.test;

import java.util.Date;

public class DateDemo {
 public static void main(String[] args) {

     Date d1 = new Date();
     System.out.println(d1);

     long date = 1000*60*60;
     Date d2 = new Date(date);
     System.out.println(d2);
 }
}

Date类的常用方法

方法名	说明
public long getTime()	获取的是日期对象从1970年1月1日00：00：00到现在的毫秒值
public void setTime(long time)	设置时间，给的是毫秒值''

package com.test;

import java.util.Date;

public class DateDemo {
 public static void main(String[] args) {

//        创建日期对象
     Date d = new Date();
     System.out.println(d.getTime());

     long time = System.currentTimeMillis();
     d.setTime(time);
     System.out.println(d);
 }
}

SimpleDateFormat类概述

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。我们重点学习日期格式化和解析

日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从‘A’到‘Z’以及从‘a’到‘z’引号的字母被解释为表示日期或时间字符串的组件的模式字母

采用的模式字母以及对应关系如下

字母	含义
y	年
M	月
d	日
H	时
m	分
s	秒

SimpleDateFormat的构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

SimpleDateFormat格式化和解析日期

• 格式化（从Date到String）

  public final String format(Date date)：将日期格式化成日期/时间字符串

• 解析（从String到Date）

  public Date parse(String source)：从给定字符串的开始解析文本以生成日期

package com.test;

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 d = new Date();
//        SimpleDateFormat sdf = new SimpleDateFormat();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);

//        从 String 到 Date
        String ss = "2018-06-08 00:00:00";
//        ParseException
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}

案例：日期工具类

需求：定义一个日期工具类（DateUtils），包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类（DateDemo），测试日期工具类的方法

思路：

1. 定义日期工具类（DateUtils）
2. 定义一个方法dateToString，用于把日期转换为指定格式的字符串
   • 返回值类型：String
   • 参数：Date date，String format
3. 定义一个方法stringToDate，用于字符串解析为指定格式的日期
   • 返回值类型：Date
   • 参数：String s，String format
4. 定义测试类DateDemo，调用日期工具类中的方法

代码实现：

工具类

package com.test;

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 sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }

//    把字符串转换为指定格式的日期
    public static Date stringToDate(String s, String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(s);
        return d;
    }
}

测试类

package com.test;

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

public class DateDemo {
    public static void main(String[] args) throws ParseException {

//        创建日期对象
        Date d = new Date();

        String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        String s2 = DateUtils.dateToString(d,"yyyy-MM-dd");
        System.out.println(s2);

        String s = "2018-01-01 10:00:00";
        Date dd = DateUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);
    }
}

Calendar类概述(日历类)

Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：

Calendar rightNow = Calendar.getInstance();

例：

package com.test;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {

//        获取对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);

//        public int get (int field)
        int year = c.get(Calendar.YEAR);
//        月份区间是[0,11]，故需要+1
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "-" + month + "-" + date);
    }
}

Calendar的常用方法

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstract void add(int field, int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year, int month, int date)	设置当前日历的年月日

例：

package com.test;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {

//        获取对象
        Calendar c = Calendar.getInstance();

//        add：三年前的今天
        c.add(Calendar.YEAR,-3);
        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：设置为2060-11-11
        c.set(2060,10,11);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH) + 1;
        date = c.get(Calendar.DATE);
        System.out.println(year + "-" + month + "-" + date);
    }
}

案例：二月天

需求：获取任意一年的二月有多少天

思路：

1. 键盘录入任意的年份
2. 设置日历对象的年、月、日
   • 年：来自键盘输入
   • 月：设置为3月，月份是从0开始的，所以设置的值为2
   • 日：设置为1日
3. 3月1日往前推一天，计算2月的最后一天
4. 获取这一天输出即可

代码实现：

package com.test;

import java.util.Calendar;
import java.util.Scanner;

public class CalendarTest {
    public static void main(String[] args) {

//        键盘输入年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = sc.nextInt();

//        设置日历对象的年月日
        Calendar c = Calendar.getInstance();
        c.set(year, 2, 1);

//        3月1日往前推一天
        c.add(Calendar.DATE, -1);

//        获取日输出
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年的2月份有" + date + "天");
    }
}