java中API中数据类型包装类(Integer),System,Runtime,Date

一．基本数据类型对象包装类：

将基本数据类型值封装成了对象，提供了更多的属性和行为；可以对具体数据进行操作。

byte      Byte

short    Short

int         Integer

long      Long

char      Character

boolean Boolean

float     Float

duoble Double

基本数据类型对象包装类的功能；可以完成基本数据和字符串之间的转换。

Integer:static  int parseInt(numberstring);

Byte : static byteparseByte(string);

规律：

XXXparseXXX(xxxstring);

 

只有一个类型没有。

Character:

代码体现：

class IntegerDemo {

       public static void main(String[] args) {

              method_6();

       }

       public static void method_6(){

              Integer x = newInteger("123");

              Integer y = new Integer(123);

              System.out.println(x==y);//false

              System.out.println(x.equals(y));//true//复写了Object类中的方法，Integer对象比较的是对象中的封装的整数是否相同。

       }

       public static void method_5(){

              String s = Integer.toString(5);

              //String s = 5+"";

              System.out.println(s+6);

              String s1 =Integer.toString(60,16);//可以获取指定十进制数对应其他进制。

              System.out.println(s1);

       }

       public static void method_4(){

              int num =Integer.parseInt("110",2);//可以将指定的进制转成十进制。

              System.out.println(num);

       }

       public static void method_3(){

              Integer i = newInteger("123");//将一个数字格式的字符串封装成了一个Integer对象。

              int num = i.intValue();//将一个Integer对象转成对应的int数值。

              System.out.println(num+4);

       }

       public static void method_2(){

              //将字符串转成一个基本数据类型值。

              String s = "123";

              int num =Integer.parseInt("qq");//NumberFormatException

              System.out.println(num+4);

       }

       public static void method_1(){

              //把一个整数封装成对象有什么好处呢？

              System.out.println(Integer.MAX_VALUE);

              System.out.println(Integer.toBinaryString(-6));

              System.out.println(Integer.toHexString(60));

       }

}

二．在JDK1.5版本以后，有了新特性。

操作基本数据类型对象时，可以象操作基本数据类型一样：

jdk1.5新特性，自动装箱拆箱。

class IntegerDemo2{

       public static void main(String[] args) {

              Integer i  = new Integer(4);//这时老版本写法。

              Integer x = 4;//Integer x = newInteger(4);//基本数据类型的装箱。自动封装成对象。

              //注意：在使用时，需要判断一下x是否为null。简化书写，有好处，也有弊端。

              x = x + 5;//x.intValue()+5;拆箱，把一个x对象转成基本数据类型。//相加完的结果9，又本装箱成Intger对象，赋给x.

              System.out.println(x);

               新特性后，这样一个小插曲。

              Integer a = new Integer(127);

              Integer b = new Integer(127);

              System.out.println(a==b);//false

              System.out.println(a.equals(b));//true

              Integer aa = 127;

              Integer bb = 127;//当使用新特性自动装箱时，注意：如果取值在byte范围内；那么两个变量取值一致，不会在内存中开辟新的对象空间；所以这两个变量如果取值一致，而且都在byte范围内，两个变量指向的是同一个对象。

              System.out.println(aa==bb);//true

              System.out.println(aa.equals(bb));//true

       }

}

三.Runtime类:

Runtime类不可以被实例化;但是自身还有非静态的方法;所以该类一定对外提供了获取其对象的功能;而且该功能是静态的;所以，Runtime类其实是用单例设计模式设计出来的。保证了一个运行时程序对象在内存中的唯一性。

class RuntimeDemo {

       public static void main(String[] args)throws Exception{

              //获取runtime对象。

              Runtime r  = Runtime.getRuntime();

              //调用exec方法。

              r.exec("notepad.exeSystemDemo.java");//可以通过指定应用程序，去解析指定的文件。

              Process p =r.exec("winmine.exe");// 本地文件的执行。

              Thread.sleep(4000);

              p.destroy();//只能杀Runtime exec开启的进程。

//      windows中的已有进程杀不了。

       }

}

四：System类  java.lang：

System类中的方法都是静态方法，不需要被实例化。

importjava.util.*;

class  SystemDemo{

       public static void main(String[] args) {

              Properties prop =System.getProperties();//获取系统的属性信息。

              String name =System.getProperty("mykey");

              System.out.println("name="+name);

              //在jvm启动时，临时给系统加载一些自定义的属性信息。

              //通过java 命令的参数-Dkey=value的形式给系统加载临时配置信息。

              Set keySet = prop.keySet();

              Iterator<String> it =keySet.iterator();

              while(it.hasNext()){

                     //String key = it.next();

                     System.out.println(it.next().length());

                     //String value =(String)prop.get(key);

                     //System.out.println(key+"::"+value);

              }

       }

}

五：Date类

Date():将当前日期和时间封装成对象

Date(long time):将指定毫秒值封装成Date对象。

1、日期对和毫秒值之间的转换

  毫秒值----->日期对象

        1.通过Date对象的构造方法new Date（timeMilles)

Date d = newDate(122394272384947)

        2.还可以通过setTime方法设置

Date d = new Date();

d.setTime(122394272384947);

  为什么要把毫秒值转成日期对象呢？

       因为你可以通过Date对象的方法对该日期中的各个字段（年月日等）进行操作

  日期对象----->毫秒值long  getTime()方法

  为什么要把日期对象转成毫秒值呢？

       因为可以通过绝缘体的数值进行运算。

2、对日期对象进行格式化

将日期对象----->日期格式的字符串，使用的是DateFormat类中的format方法

获取日期格式对象，具体默认的风格。FULL、LONG等可以指定风格

public static voiddateFormatDemo(){

       Date d = new Date();

       //使用默认风格

       DateFormat df =DateFormat.getDateInstance();//获取DateFormat对象

       //使用指定风格

       df =DateFormat.getDateInstance(DateFormat.FULL);

       //使用指定风格，包含日期和时间

df =DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);

       //使用自定义风格

       df = newSimpleDateFormat("yyyy/MM/dd HH:mm:ss");

       String str_date = df.format(d);//将日期对象----->日期格式的字符串

       System.out.println(str_date);

}

将日期格式的字符串----->日期对象，使用的是DateFormat类中的parse方法

public static voiddateFormatDemo1() throws ParseException{

       //日期字符串

       String str_date = "2012-8-1";

       //定义日期格式化对象

       DateFormat df =DateFormat.getDateInstance();

       Date date = df.parse(str_date);

       System.out.println(date);

}

自定义日期格式，使用SimpleDateFormat构造完成

小练习应用一下：2012/4/12和2012/6/2相差多少天？

public classDateTest {

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

              String str1 ="2012/4/12";

              String str2 ="2012/6/2";

              long day = getDay(str1, str2);

              System.out.println(day);

       }

       public static long getDay(Stringstr1,String str2) throws ParseException{

              DateFormat df = newSimpleDateFormat("yyyy/MM/dd");

              Date d1 = df.parse(str1);

              Date d2 = df.parse(str2);

              long time1 = d1.getTime();

              long time2 = d2.getTime();

              long time =Math.abs(time1-time2)/1000/60/60/24;

              return time;

       }

}