API是应用程序编程接口，他是软件系统不同组成部分衔接的约定。可以理解为预先定义的函数。设计目的在于可以提供应用程序得以访问某些特定软件或硬件的能力，而又无需获知这些软硬件源码，也无需理解他们的内部工作机制细节。
java中很多类的很多方法的参数类型都是Object，即这些方法接收的参数都是对象，同时，又需要用这些方法来处理基本数据类型的数据，这时就用到包装类。

使用包装类：将字符串变为整型基本数据
class IntegerDemo
{
public static void main(String args[])
{
String a="3";
int i=Integer.parseInt(a);     //将字符串转为整型。通过Integer类将字符串a包装为整数i。
System.out.println(i)
}
}

将字符串变为double型数据
class jdjd
{
    public static void main(String args[])
    {
        String a="3.14";
        Double b=Double.parseDouble(a);   //将字符串变为double型
        System.out.println(b);
    }
}


将字符串变为boolean型数据
class jdjd
{
    public static void main(String args[])
    {
        String a="true";
        boolean b=Boolean.parseBoolean(a);
        if(b)
        {
            System.out.println("条件满足");     //条件为真输出提示
            }
            else
            {
                System.out.println("条件不满足");      //条件为假输出提示
            }
        }
}

parseInt()方法在Integer类中是将一个字符串转换成基本数据类型。

装箱与拆箱
所谓装箱就是基本类型用他们相对应的引用类型包起来。使他们具有对象的特质比如int型包装成Integer类的对象。拆箱相反例Integer这样的引用类型的对象重新简化为值类型的数据。

class jdjd
{
    public static void main(String args[])
    {
    Integer x=new Integer(10);     //基本类型变为包装类，装箱
    int i=x.intValue();    //包装类变为基本类型，拆箱
    System.out.println(i);
    }
}

装箱操作：将基本数据类型变为包装类，利用各个包装类的构造方法完成。
拆箱操作：将包装类变为基本数据类型，利用Number类的xxxValue()方法完成。

基本数据类型与字符串的转换
使用包装类有一个最大的特点：可以将字符串变为指定的基本类型。例

Integer:public static int parseInt(String s)
Double:public static double parseDouble(String s)
Boolean:public static Boolean parseBoolean(String s)
//  以上操作方法的形式对于Character是不存在的，因为String类中
有一个charAt()方法可以取得指定索引的字符。

System类
Java中不支持全局变量和全局方法，Java设计者将一些系统相关的重要的方法和变量收集到一个统一的类中，这就是System类。此类中所有成员都是静态的，要引用这些变量和方法，可直接使用System类名作为前缀。

常用方法
exir(int status)方法提前终止虚拟机的运行。对于发生了异常情况而想终止虚拟机的运行，传递一个非零值作为参数。若在用户正常操作下终止虚拟机的运行，则传递零值作为参数。
CurrentTimeMillis方法返回自1970年1月1日0点0分0秒起至今以毫秒为单位的时间，这是一个long类型的最大数值。但通过这个数值能够准确推算出其对应的具体日期时间。
getProperties方法获取当前虚拟机环境属性。每一个属性都是变量与值以成对的形式出现的。同样道理，Java作为一个虚拟的操作系统，他也有自己的环境属性。Properties是Hashtable的子类，正好可以用于存储环境属性中的多个“变量/值”，对格式的数据，getProperties方法返回值是包含了当前虚拟机的所有环境属性的Properties类型的对象。

打印当前虚拟机的所有环境属性的变量和值
import java.util.*;
class canyue
{
public static void main(String args[])
{
Properties p=System.getProperties(); //获取当前虚拟机的环境属性
Enumeration e=p.propertyNames(); //获取环境属性中所有的变量
//循环打印出当前虚拟机的所有环境属性的变量和值
while(e.hasMoreElements())
{
String key=(String)e.nextElement();
System.out.println(key+"="+p.getProperty(key));
}
}
}

-------------------------------------------------------------------
**Runtime类**
在Java程序运行时，每一个jvm进程中都会存在唯一的一个Runtime类的实例化对象。这个类明显是一个单例设计模式，此类将构造方法私有化了，既然是单例设计模式，那么一定会在类的内部提供一个static定义的方法，用于取得本类的实例化对象。
取得Runtime类对象：public static Runtime getRuntime();
取得了Runtime类的实例化对象以后，可以利用以下的方法取得一些内存的相关信息。
最大可用内存数:  public long maxMemory();
总共可用内存数: public long totalMemory();
空闲内存数:  public long freeMomery();

如果在程序中出现了过多的垃圾，则会影响性能，此时可利用Runtime类的如下方法清理垃圾```public long gc();```

取得内存值
class canyue
{
public static void main(String args[])
{
Runtime r=Runtime.getRuntime(); //单例设计 (通过静态方法Runtime.getRuntime获得正在运行的Runtime对象的引用)
String s=""; //定义一个字符串
for(int x=0;x<5000;x++) //通过循环产生垃圾
{
s+=x; //垃圾产生
}
System.out.println("1，最大可用内存："+r.maxMemory());
System.out.println("1，总共可用内存："+r.totalMemory());
System.out.println("1，最大可用内存："+r.freeMemory());
r.gc(); //清理垃圾
System.out.println("--------------///----/----------");
System.out.println("2，最大可用内存："+r.maxMemory());
System.out.println("2，总共可用内存："+r.totalMemory());
System.out.println("2，最大可用内存："+r.freeMemory());
}
}

----------------------------------------------------------------
**日期操作类**

Calendar  本地化时间类
Instant：瞬时实例。
LocalDate：本地日期，不包含具体时间 例如：2014-01-14 可以用来记录生日、纪念日、加盟日等。
LocalTime：本地时间，不包含日期。
LocalDateTime：组合了日期和时间，但不包含时差和时区信息。
ZonedDateTime：最完整的日期时间，包含时区和相对UTC或格林威治的时差。

类名|说明
-|-
LocalDateTime|存储时间和日期如2010-08-01T14:43:14.539
LocalDate|存储日期，如2010-01-01
LocalTime|存储时间，如14:43:14.539

取得当前日期时间
import java.time.*;
class can
{
public stcatic void main(String args[])
{
//新建一个LocalDateTime对象获取当前时间(存储当前时间)
LocalDateTime aaa=LocalDateTime.now();
System.out.println(aaa); //直接输出对象
}
}

//判断是否闰年
import java.time.*;
class aaa
{
public stcatic void main(String args[])
{
//用指定的年获取一个Year
Year y=Year.of(2012);
//从Year获取YearMonth
YearMonth ym=y.atMonth(2);
//从YearMonth指定日得到LocalDate
LocalDate l=YearMonth.atDay(29);
System.out.println("时间"+l);
//判断是否为闰年
System.out.println("是否为闰年"+l.isLeapYear());
//自动处理闰年的2月日期
//创建一个MonthDay
MonthDay s=MonthDay.of(2,29);
LocalDate v=s.atYear(2012);
System.out.println("闰年"+v)
//同一个MonthDate关联到另一个年份上
LocalDate can =s.atYear(2014);
System.out.println("非闰年"+can);
}
}
isLeapYear()方法判断该年是否为闰年。

Java.time的API提供方法|说明
-|-
of|静态方法，如：Year.of(2012)
parse|静态工厂方法，关注于解析
get|获取某些东西的值
is|检查某些东西是否为true
with|不可变的setter等价物
plus|加一些量到某个对象
minus|从某个对象减去一些量
to|转换到另一个类型
at|把这个对象与另一个对象组合起来

--------------------------------------------------------------------
**日期格式化类**
在某些情况下，开发者可能要对日期对象进行转换。例如，程序中用的另外一个类的方法要求一个LocalDate类型的参数。有时，要将用LocalDate对象表示的日期以指定格式输出，或将用特定格式显示的日期字符串转换成LocalDate对象，Java.time.format包是专门用来格式化输出时间/日期的。

import java.time.;
import java.time.format.;
class ddd
{
public static void main(String args[])
{
//获取当前时间
LocalDate d=LocalDate.now();
//指定格式化规则
DateTimeFormatter f=DateTimeFormatter.ofPattern("dd/MM/uuuu");
//将当前时间格式化
String str=d.format(f);
System.out.println("时间"+str);
}
}

-------------------------------------------------------------------
**正则表达式**

class can
{
public static void main(String args[])
{
if(isNumber("123")) //判断字符串是否有数字组成
{
System.out.println("由数字组成");
}
else
{
System.out.println("不是由数字组成");
}
}
public static boolean isNumber(String str)
{
char data[]=str.toCharArray(); //将字符转换为char数组
for(int x=0;x<data.length;x++) //循环遍历数组
{
if(data[x]<'0'||data[x]>'9') //判断数组中的每个元素是否是数字
{
return false;
}
}
return true;
}
}

上面代码用正则表达式简化为例：

class can
{
public static void main(String args[])throws Exception
{
if("123".matches("\d+")) //利用正则表达式
{
System.out.println("由数字组成");
}
else
{
System.out.println("不是由数字组成");
}
}
}

程序中“\\d+”实际上属于正则表达式的概念。提供API包java.util.regex开发包，此包提供正则的操作类，这个包中只有两个操作类：Pattern 和 matcher，一般很少使用。
jdk1.4以后对String类进行了修改，里面增加了与正则表达式有关的操作方法如下

方法名称|描述
-|-
public boolean matches(String regex)|将字符串与给出的正则进行匹配验证
public String replaceAll(String regex,String replacement)|按照指定的正则全部替换
public String replaceFirst(String regex,String replacement)|按照指定的正则替换首个
public String[] spIit(String regex)|按照指定的正则拆分
public String[] spIit(String regex,int Inmit)|拆分为指定长度的字符串数组

想要操作这些方法，那么必须清楚正则标记
**正则标记**
在正则操作之中，使用一系列的标记符号是一件非常重要的任务，不光是Java，只要是支持正则操作的程序，例如：JavaScript标记都是统一的。所有的标记都在java.util.regex.Pattern类提供，下面给出核心的正则标记
1，字符，表示单个字符，只能出现一位。

标记符号|解释
-|-
x|表示是一个指定的一位字符，例如：编写一个a，表示的是字母a
\ \ |表示一位字符“\”，由于“\”有数个含义，所以用“\ \”表示一位“\”
\n|匹配换行


2，字符范围，在指定的字符范围之中选1位，只能出现1位

标记符号|解释
-|-
[abc]|表示可以是a，b，c中的任意一位
[^abc]|表示不是a，b，c中的任意一位
[a-zA-Z]|表示是任意一位字母(大写或小写)
[0-9]|表示是任意一位数字

3，简洁表达式，表示1位

标记符号|解释
-|-
.|表示任意一位字符
\d|表示一位数字，等价于“[0-9]”
\D|表示一位非数字，等价于“[^0-9]”
\s|表示一位空格，等价于“[\t\n\x0B\f\r]”
\S|表示一位非空格，等价于“[……\t\n\x0B\f\r]”
\w|表示一位字母,数字,_,等价于“[a-zA-Z0-9_]”
\W|表示一位非字母,数字,_,等价于“[^a-zA-Z0-9_]”

4边界匹配，Java用不上

标记符号|解释
-|-
^|表示正则开头
$|表示正则结尾

5，数量表示，之前的正则每个符号只表示1位，如果要表示多位，则必须用以下数量关系

标记符号|解释
-|-
正则?|表示此正则可以出现0此或1次
正则+|表示此正则可以出现1次或多次
正则*|表示此正则可以出现0次，1次或多次
正则{n}|表示此正则正好出现n次
正则{n,}|表示此正则正好出现n次以上
正则{n,m}|表示此正则出现n到m此

6，逻辑操作

标记符号|解释
-|-
正则1正则2|正则1后紧随正则2操作
正则1/正则2|表示或的关系，有一套正则标记匹配即可(斜线为竖线)
(正则)|表示按照一组来使用


**利用String类进行正则操作**
在String 类中提供了于正则直接有关的操作方法，例

//字符串替换
class can
{
public static void main(String args[])shrows Exception
{
String str ="a11b22c2d5e5v7";
String str="[0-9]+"; //数字出现1次或多次
//String st="\d+"; //数字出现1次或多次
System.out.println(str.replaceAll(st,""));
}
}

**验证邮箱格式**

class can
{
public static void main(String args[])throws Exception
{
String str="mldnqa@163.com";
String st="\w+@\w+\.\w+";
System.out.println(str.matches(st));
}
}

---------------------------------------------------------------------
**Math与Random类**
Math类提供了包含所有用于几何和三角的浮点运算方法，这些方法都是静态的，如四舍五入：```public static long round(double a);```
Random类是一个随机数产生器，随机数是按照某种算法产生的，一旦一个初值创建Random对象，就可以得到一系列随机数。但如果用相同的初值创建Random对象，得到的随机数是相同的，针对这个问题在Random类中的Random构造方法使用的的是当前时间来初始化Random对象，因为没有任何时刻的时间是相同的，所以减少随机数相同的可能性。

//产生0到100随机数10位
import java.util.Random.;
import java.util.;
public class Main
{
public static void main(String[] args)
{
Random r=new Random();
for(int i=0;i<10;i++)
{
System.out.println(r.nextInt(100));
}
}
}

**大数字操作类**
两个大数字操作类 ```java.math.BigInteger```
和```java.math.BigDecimal```
如果对一个非常大的数字进行操作，并且已经超过了double的范畴，唯一做法便是吧数字变成字符串。在BigInteger类的构造方法```public BigInteger(String val)```里如果数据过大，只能用字符串保存，在BigInteger类之中提供若干基本数学操作。

import java.math.BigInteger;
class sjdj
{
public static void main(String args[])throws Exception
{
BigInteger a=new BigInteger("46676767679797949461646464"); //定义大整数(以字符串形式保存)
BigInteger b=new BigInteger("647697644646464679767");
System.out.println("加法操作"+a.add(b));
System.out.println("减法操作"+a.subtract(b));
System.out.println("乘法操作"+a.multiply(b));
System.out.println("除法操作"+a.divide(b));
//对两个数进行除法操作，并同时保存商和余数
BigInteger r[]=a.divideAndRemainder(b);
System.out.println("商："+r[0]+"，余数："+r[1]);
}
}

**大型浮点操作类BigDecimal**
BigDecimal的实现用到了BigInteger，不同的是BigDecimal加入了小数概念，一般float型Double型数据只可以用来做科学计算或者工程计算，由于商业计算中，要求精度较高，所以要用到java.math.BigDecimal类，他支持任何精度的定位数。


方法名称|描述
-|-
add(BigDecimal)|BigDecimal对象的值相加，然后返回这个对象
subtract(BigDecimal)|BigDecimal对象的值相减，然后返回这个对象
multiply(BigDecimal)|BigDecimal对象的值相乘，然后返回对象
divide(BigDecimal)|BigDecimal对象的值相除，然后返回对象
toString|将BigDecimal对象的数值转换成字符串
doubleValue()|将BigDecimal对象中的值以双精度数返回
floatValue()|将BigDecimal对象的值以单精度返回
longValue()|将BigDecimal对象的值以长整数返回
intValue()|将BigDecimal对象的值以整数返回

//BigDecimalDemo的四则运算
import java.math.BigDecimal;
class jdjdjd
{
public static void main(String args[])
{
BigDecimal A=new BigDecimal("6767677664646467676767");
BigDecimal B=new BigDecimal("6446464.7");
System.out.println("加法操作："+A.add(B));
System.out.println("减法操作："+A.subtract(B));
System.out.println("乘法操作："+A.multiply(B));
System.out.println("除法操作："+A.divide(B,BigDecimal.ROUND_CEILING));
System.out.println("进一法保留一位小数："+A.multiply(B).setScale(1,BigDecimal.ROUND_UP));
}
//ROUND_DOWN表示舍弃一位
//ROUND_UP表示进一位
}

**Integer类**

//Integer类的三种创建方法
class jdjdjd
{
public static void main(String args[])
{
Integer num1=new Integer(100); //使用new关键字
Integer num2=Integer.valueOf(200); //使用Integer中的方法valueOf创建
Integer num3=300; //利用自动装箱
System.out.println("三种不同创建方式"+num1+" "+num2+" "+num3);
}
}

**Boolean类**
java.lang.Boolean类与Integer一样是在对象中封装了一个基本布尔值的值。Boolean类型的对象包含在一个单一的字段中，其类型为布尔值。

class jdjdjd
{
public static void main(String args[])
{
Boolean b1,b2; //创建两个Boolean类型变量b1,b2
b1 =new Boolean(true); //给b1赋值
b2 =new Boolean(false); //给b2赋值
int res; //创建一个整型数res
res=b1.compareTo(b2); //比较b1和b2的值
String str1="你好啊";
String str2="我不好";
String str3="都不好";
if(res==0)
{
System.out.println(str1);
}
else if(res>0)
{
System.out.println(str2);
}
else if(res<0)
{
System.out.println(str3);
}
}
}

**Byte类**
Byte类将基本类型byte的值包装在一个对象中。一个Byte类型的对象只包含一个类型为byte的字段。此外该类还为byte和String的相互转换提供了几种方法。

方法名称|返回类型|功能说明
-|-|-
byteValue()|byte|返回Byte类的一个byte类型值
compareTo(Byte anotherByte)|int|在数值上比较两个类对象，相等返回0，如果调用对象小于anotherByte对象则返回负值，否则返回正值
doubleValue|double|返回一个Byte类的一个double类型值
intValue|int|返回一个Byte类的一个int类型值
parseByte(String str)|byte|将String类型转换为byte类型
toString:|String|返回一个Byte类的一个String类型值
equals(Byte anotherByte| |若调用对象值等于anotherByte对象的值返回true，否则返回false)
valueOf(String str byte x)|Bytr对象|返回值为str或者x的Byte对象

**Byte类的基本使用方法**

class jdjd
{
public static void main(String args[])
{
byte b=23; //声明一个byte变量
Byte b1=new Byte(b); //返回表示b的一个Byte实例
Byte b2=Byte.valueOf("23"); //返回"23"的Byte对象
Byte b3=12; //返回"12"的Byte对象
int x1=b1.intValue(); //作为一个int型b1值
int x2=b2.intValue(); //作为一个int型b2值
int x3=b3.intValue(); //作为一个int型b3值
System.out.println("b1:"+x1+"b2:"+x2+"b3:"+x3);
String str1=Byte.toString(b); //返回b的String对象
String str2=Byte.toString(b2); //返回b2的String对象
String str3=b3.toString(); //返回b3的String对象
byte bb=Byte.parseByte("23"); //将String参数解析为有符号的十进制byte
System.out.println("Byte.parseByte("23"):"+bb);
boolean bool1=b1.equals(b2); //将b1与b2比较
boolean bool2=b1.equals(b3); //将b1与b3比较
System.out.println("b1.equals(b2):"+bool1+",b1.equals(b3):"+bool2);
}
}