API常用类-其他类

Math类

java.lang.Math
public final class Math extends Object
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
字段

• public static final double E;比任何其他值都更接近 e（即自然对数的底数）的 double 值。
• public static final double PI;比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

没有构造方法
成员方法

• public static int abs(int x);绝对值
• public static double ceil(double a);向上取整
• public static double floor(double a);向下取整
• public static int max(int a,int b);最大值
• public static double pow(souble a,double b);a 的b 次幂
• public static double random();[0,1)的随机数
• public static int round(float a);四舍五入
• public static double squrt(double a);正平方根

//获取一个1-100之间的随机数
System.out.println("random:"+(int)(Math.random()*100) +1);//981   字符串拼接
System.out.println("random:"+((int)(Math.random()*100)+1));//99

Random类

java.util.Random
public class Random extends Object implements Serializable
此类用于产生随机数，如果用相同的种子创建两个Random实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列
构造方法

• public Random（）；没有给种子，用的是默认种子，用的是当前时间的毫秒值，相当于种子不一样
• public Random（long seed）；给出指定的种子
• 给定种子后每次得到的随机数是相同的

成员方法

• public int nextInt();返回int 范围内的随机数
• public int nextInt(int n);返回的是[0,n)范围内的随机数

System 类

java.lang.System
public final class System extends Object
System类包含一些有用的类字段和方法，它不能被实例化。没有构造方法

字段

• public static final PrintStream err;”标准”错误输出流
• public static final InputStream in;”标准”输入流
• public static final PrintStream out; ”标准”输出流

成员方法

• public static void gc();运行垃圾回收器
• public static void exit(int status);终止当前正在运行的java虚拟机，一般状态码给0
• public static long currentTimeMillis();返回以毫秒为单位的当前时间，即与协调世界时间1970年1月1日午夜之间的时间差（以毫秒为单位测量）
• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);从指定原数组中某个起始位置开始，复制一定长度的数组到目标数组的起始位置。

system.gc()可用于垃圾回收。当使用System.gc()回收某个对象所占用的内存之前，通过要求程序调用适当的方法来清理资源。在没有明确指定资源清理的情况下，java提高了默认机制来清理该对象的资源，就是调用Object类的finalize()方法。finalize()方法的作用是释放一个对象占用的内存空间时，会被JVM调用。而子类重写该方法，就可以清理对象占用的资源，该方法没有链式调用，所以必须手动实现。
从程序的运行结果可以发现，执行System.gc()前，系统会自动调用finalize()方法清除对象占有的资源，通过super.finalize()方法可以实现从下到上的finalize()方法的调用，即先释放自己的资源，再去释放父类的资源。
但是，不要在程序中频繁的调用垃圾回收，因为每一次执行垃圾回收，JVM都会强制启动垃圾回收器运行，这会消耗更多的系统资源，会与正常的java程序运行争抢资源，只有在执行大量的对象的释放，才调用垃圾回收最好。

public class Person(){
    private String name;
    private int age;
    public Person(){};
    public Person(String name,int age){
        this.name = name;
        this.age= age
    }
    @Override
    protected void finalize() throw Throwable{
        System.out.println("当前的对象被回收了"+this);
        super.finalize();
    }
}
public class systemDemo{
    public static void main(String[] args){
        Person p = new Person("李艾",45);
        System.out.println(p);
        p = null;//让p不再指向堆内存

        System.gc();

    }
}

//统计下列程序的运行时间
long start = System.currentTimeMillis();
for(int x = 0;x<100000;x++){
    System.out.println("hello"+x);
}
long end = System.currentTimeMillis();
System.out.println("共耗时："+(end - start));

//定义数组
int[] arr = {11,22,33,44,55};
int[] arr2={6,7,8,9,10};

System.out.println(arr,1,arr2,2,2);
System.out.println(Arrays.toString(arr));//[11,22,33,44,55]
System.out.println(Arrays.toString(arr2));//[6,7,22,33,10]

BigInteger 类

java.Math.BigInteger

public class BigInteger extends Number implements Comparable<BigInteger>

可以让超过Integer范围内的数据进行计算
构造方法

public BigInteger(String val);将 BigInteger 的十进制字符串表示形式转换为 BigInteger

成员方法

• 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)；返回商和余数的数组

BigDecimal类

不可变的，任意精度的有符号十进制数。
由于在运算的时候，float类型和double很容易丢失精度，所以为了能精确的表示，计算浮点数，java提供了BigDecimal。

System.out.println(0.09+0.01);//0.09999999999999999
System.out.println(1.0-0.32);//0.6799999999999999
System.out.println(1.015*100);//101.49999999999999
System.out.println(1.301/100);//0.013009999999999999
//float类型的数据存储和整数不一样导致的，大部分的时候，它们都带有有效数字

构造方法

public BigDecimal(String val)

成员方法

public BigDecimal add(BigDecimal augend);
* public BigDecimal substract(BigDecimal substrahend);
* public BigDecimal multiply(BigDecimal multiplicand);
* public BigDecimal divide(BigDecimal divisor);
* public BigDecimal divide(BigDecimal divisor，int scale,int roundingMode);商，几位小数，如何舍取

BigDecimal bd1 = new BigDecimal("0.09");
BigDecimal bd2 = new BigDecimal("0.01");
System.out.println("add"+bd1.add(bd2));//0.10

Date类

java.util.Date

public class Date extends Object implements Serializable,Cloneable,Comparable<Date>

Date类表示特定的瞬间，精确到毫秒；从JDK1.1 开始，应该使用Calendar 类实现日期和时间字段之间转换，使用DateFormat类来格式化和解析日期字符串。Date中的响应的方法已经废弃

构造方法

• public Date();分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）；
• public Date(long date);根据给定的毫秒值创建日期对象

//创建对象
Date d = new Date（）;
System.out.println("d:"+d);//d: thur Fiv 3 13:07:23 CST 2018

//创建对象
long time = System.currentTimeMillis();
Date d2 = new Date(time);
System.out.println("d2:"+d2);//d2: thur Fiv 3 13:09:23 CST 2018

成员方法

• public long getTime();获取时间，以毫秒为单位
• public void setTime(long time);设置时间

//创建对象
Date d = new Date();
//获取时间
long time = d.getTime();
System.out.println(time);
//System.out.println(System.currentTimeMillis());

System.out.println("d:"+d);

//设置时间
d.getTime(1000);
System.out.println("d:"+d);//Thu Jan 01 08:00:01  CST 1970   东八区时间

//从Dated得到一个毫秒值
//getTime()
//把一个毫秒值转成Date
//构造方法
//setTime（long date）;

DateFormat抽象类—子类SimpleDateFormat

日期和字符串的相互转换
java.text.DateFormat
public abstract class DateFormat extends Format
Date —–String(格式化)
String —-Date （解析）
成员方法

• public final String format(Date date);

DateFormat可以进行日期和字符串的格式化和解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat

SimpleDateFormat类

java.text.SimpleDateFormat
public class SimpleDateFormat extends DateFormat
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
构造方法

• public SimpleDateFormat();用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
• public SimpleDateFormat(String pattern);
  年—Y 月—M 日—d 时—H 分—m 秒—s
• public Date parse(String source);

//Date---String
//创建日期对象
Date d = new Date();
//创建格式化对象
//默认模式SimpleDateFormat sdf = new SimpleDateFormat();
//给定模式
SimpleDateFormat sdf = new SimpleDateFormat(“YY-MM-dd HH:mm:ss”);
//public final String format(Date date);
String s = sdf.format(d);
System.out.println(s);//18-05-03 下午3:14   2018-05-03  15:32:34

//String --Date
String str = "2018-05-03 15:32:45";
//在把一个字符串解析成一个日期的时候，格式必须给定的字符串的格式匹配
SimpleDateFormat sdf2 = new SimpleDateFormat(“YY-MM-dd HH:mm:ss”);
Date dd = sdf2.parse(str);
System.out.println(dd);//

Calendar 抽象类

java.util.Calendar
子类 GregorianCalendar

public abstract class Calendar extends Object implements Serializable,Cloneable,Comparable<Calendar>

Calendar是一个抽象类，它为特定瞬间与一组诸如YEAR,MONTH,DAY_OF_MONTH,HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供一些方法。

成员方法

• public int get(int field);返回给定日历字段的值，日历类找那个的每一个日历字段是静态的成员变量，并且是int类型
• public static Calendar getInstance()
• public void add(int field,int amount),根据日历的规则，为给定的日历字段添加或者减去指定的时间量。例如，要从当前的日历时间减去5天，可以通过用一下方法做到add（Calendar.DAY_OF_MONTH,-5）
• public final void set(int year,int month,int date):设置当前日历的年月日

与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化：
Calendar rightNow = Calendar.getInstance();

abstract class Person{
    public static Person getPerson(){
        return new Student();
    }
}
class Student extends Person{
}

//其日历字段已由当前日期和时间初始化
Calendar rightNow = Calendar.getInstance();//子类对象

//获取年
int year = rightNow.get(Calendar.YEAR);
//获取月
int month = rightNow.get(Calendar.MONTH);
//获取日
int date= rightNow.get(Calendar.DATE);
System.out.println(year+"年"+（month+1）+"月"+date+“日”);//2018年5月3日

//获取当前的日历时间
Calendar c = Calendar.getInstance();//子类对象

//获取年
int year = c.get(Calendar.YEAR);
//获取月
int month = c.get(Calendar.MONTH);
//获取日
int date=c.get(Calendar.DATE);
System.out.println(year+"年"+（month+1）+"月"+date+“日”);//2018年5月3日

/三年前的今天
c.add(Calendar.YEAR,-3);
//获取年
int year = c.get(Calendar.YEAR);
//获取月
int month = c.get(Calendar.MONTH);
//获取日
date=c.get(Calendar.DATE);
System.out.println(year+"年"+（month+1）+"月"+date+“日”);//2015年5月3日

//五年后的十天前
c.add(Calendar.YEAR,5);
c.add(Calendar.DATE,-10);

//设置时间
c.set(2011,11,11);