黑马程序员----java基础--JDK新特性和集合其他类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、JDK1.5新特性

JDK升级的三大原因：

(1)、提高代码的复用性

(2)、提高代码的安全性

(3)、简化书写

1、泛型机制

JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

(1)、泛型概念

泛型是根据数组的思想设计出来的，因为数组一旦建立成功就已经明确了数据类型，所以可根据数组思想给集合指定类型。

如：数组：int[] arr=new int[4];

而集合的泛型：ArrayList<String> al=new ArrayList<String>();

ArrayList-->int; <>-->[]；al-->arr

为什么使用泛型？

在使用泛型前，存入集合中的元素可以是任何类型的，当从集合中取出时，所有的元素都是Object类型，需要进行向下的强制类型转换，转换到特定的类型。

好处：

1：将运行时期的问题ClassCastException问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。

2：避免了强制转换的麻烦。 

只要带有<>的类或者接口，都属于带有类型参数的类或者接口，在使用这些类或者接口时，必须给<>中传递一个具体的引用数据类型。

泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。

为什么? 因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。

在运行时，如何知道获取的元素类型而不用强转呢？

泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。 

什么时候用泛型类呢？

当类中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。

泛型类型参数只能被类或接口类型赋值，不能被基本数据类型赋值，基本数据类型需要使用对应的包装类。

泛型前：

import java.util.*;
//没有使用泛型前。有很大的安全隐患，在编译时期不会检查出来错误，但是运行的时候就出现了错误
class GenericDemo 
{
    public static void main(String[] args) 
    {
        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add(545);
        for (Iterator it=al.iterator();it.hasNext() ; )
        {
            String str=(String)it.next();//这里需要强转。.ClassCastException
            System.out.println(str);
        }
    }
}

 泛型后：

import java.util.*;
//泛型出现后，增加了程序的安全性，直接把问题在编译时期暴露出来
class GenericDemo 
{
    public static void main(String[] args) 
    {
        //增加泛型，明确集合中存放的对象是String，直接把错误暴露在编译时期
        ArrayList<String> al=new ArrayList<String>();
        al.add("java01");
        al.add("java02");
        al.add("java03");
//      al.add(545);//error；
        for (Iterator<String> it=al.iterator();it.hasNext() ; )
        {
            String str=it.next();//这里不用强制转换
            System.out.println(str);
        }
    }
}

 示例：

import java.util.*;
class GenericDemo 
{
    public static void main(String[] args) 
    {

        ArrayList<String> al=new ArrayList<String>();
        al.add("abc");
        al.add("abqqe");
        al.add("k");
        al.add("fd");        
        Collections.sort(al,Collections.reverseOrder(new LenComparator()));//逆转LenComparator比较器的比较顺序
        for (Iterator<String> it=al.iterator();it.hasNext() ; )
        {
            String str=it.next();
            System.out.println(str);
        }
    }
}
//按照字符串的长度进行排序
class LenComparator implements Comparator<String>
{
    public int compare(String s1,String s2){
        int num= s1.length()-s2.length();
        return num==0?s1.compareTo(s2):num;
    }
}

 (2)、泛型类：将泛型定义在类上

在定义带类型参数的类时，在紧跟类命之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取 值范围进行限定，多个类型参数之间用,号分隔。

泛型出现前设计类方法：用Object来代替任意对象，但是这种设计方式编译时期不会报错（因为Object任何类型都能接收）运行时期容易出现ClassCastException异常，而且还得强转。

泛型出现前：

class Student{}
class Worker{}
class Tool{
    private Object obj;
    public void setObject(Object obj){
        this.obj=obj;
    }
    public Object getObject(){
        return obj;
    }
}
class Dmeo{
    public static void main(Sting[] args){
        Tool t=new Tool();
        t.setObject(new Student());//Object obj=new Student();这里可以传入任意类型的对象，Objec都可以接收
        Student s=(Student)t.getObject();//强转，容易出现ClassCastException异常
    }
}

 泛型出现后的设计思想：当类中要操作的引用数据类型不确定的时候，这是把泛型定义在类上。泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

import java.util.*;
class Student
{
}
class Worker
{
}
class Utils<T>
{
    private T t;    
    public void setObject(T t){
        this.t=t;
    }
    public T getObject(){
        return t;
    }
}
class GenericDemo2 
{
    public static void main(String[] args)     {
        
        Utils<Student> u=new Utils<Student>();
        u.setObject(new Student());//如果传入的不是Student对象，编译时期就会直接报错。
        Student s=u.getObject();//避免强转
    }
}

 (3)、泛型方法；泛型定义在方法上

为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。当方法和类上都有泛型的时候，方法内的操作以方法上的泛型为依据，与类上的泛型无关。

注意：方法上的泛型定义在返回值类型的前面即可，如：<T>返回值。

import java.util.*;
class Demo<T>
{
    public void show(T t){
        System.out.println(t);
    }
    public void print(T t){
        System.out.println(t);
    }
}
class GenericDemo3 
{
    public static void main(String[] args) 
    {
        Demo<String> d=new Demo<String>();
        d.show("你好");
        d.print("你也好");
//        d.print(234);//error;不兼容的类型: int无法转换为String
        //怎么既能让print()打印Integer又能打印String呢？
        Demo<Integer> d1=new Demo<Integer>();
        d1.print(45);
        //上面的方法有点繁琐，而且内存中的对象太多，可以采用把泛型定//义在方法上解决。
    }
}

 代码修正后：

import java.util.*;
class Demo<T>
{
    public void show(T t){
        System.out.println(t);
    }
    public<E> void print(E e){
        System.out.println(e);
    }
    public<Q> void run(Q q){
        System.out.println(q);
    }
}
class GenericDemo3
{
    public static void main(String[] args){
        Demo<String> d=new Demo<String>();        
        d.print(78);
        d.print("你好");
        d.show("你也好");
        d.show(34);//不兼容的类型: int无法转换为String.该方法上没有定义泛型，所以还是跟着类上的泛型走的。
        d.run(65);
    }
}

 特殊之处：

静态方法不可以访问类上定义的泛型。(静态优先于对象存在)

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

public static <Q> void function(Q t) {

       System.out.println("function:"+t);

}

(4)、泛型接口：泛型定义在接口上

如果子类明确了父类(接口)的类型，在创建对象的时候不需要再次明确泛型的类型了。

interface Inter<T>{
    public abstract void show(T t);
}
class Demo implements Inter<Stirng>{
    public void show(String s){
        System.out.println(“show==”+s);
    }
}
class GenericDemo{
    public static void main(String[] args){
        Demo d=new Demo();//这里不带泛型，因为子类实现接口的时候已经指定了泛型的类型，如果加上会出现错误: Demo不带有参数
        d.show(“hhahah”);
    }
}

 如果子类实现父类(接口)的时候也不确定什么类型的时候，子类也可以加上泛型，这时候创建子类对象的时候必须明确泛型类型。

interface Inter<T>{
    public abstract void show(T t);
}
class Demo<T> implements Inter<t>{
    public void show(T t){
        System.out.println(“show==”+t);
    }
}
class GenericDemo{
    public static void main(String[] args){
        Demo<Integer> d=new Demo<Integer>();
        d.show(4);
    }
}

 (5)、泛型通配符：<?>

泛型中的通配符：可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

class GenericDemo{
    public static void main(String[] args){
        ArrayList<String> al =new ArrayList<String>();
        al.add(“abc1”);
        al.add("abc2");
        al.add("abc3");
        ArrayList<Integer> al1=new ArrayList<Integer>();
        al1.add(4);
        al1.add(7);
        al1.add(1);
        //怎么可以方便的获取到两个集合中的数据呢？
        printColl(al);
        printColl(al1);
    }
    public static void printColl(ArrayList<?> al){
    //这里的？也可以换成T，效果都是一样的，但是换成T有个好处就是可以对T进行操作。
    //如果换成T要在函数上定义一下。
        for(Iterator<?>it =al.iterator();it.hasNext();){
            //T t=it.next();
        System.out.println(it.next());
        }
    }
}

 (6)、泛型限定

上限：？extends E：可以接收E类型或者E的子类型对象。

下限：？super E：可以接收E类型或者E的父类型对象。

上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

TreeSet(Comparator<? super E> comparator)

Comparable<? super E>

TreeSet(Collection<? extends E> c)

代码演示：

import java.util.*;
class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
    public String toString()
    {
        return name;
    }
}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}
class Worker extends Person
{
    Worker(String name)
    {
        super(name);
    }
}
class Comp implements Comparator<Person>
{
    public int compare(Person p1,Person p2)
    {
        return p2.getName().compareTo(p1.getName());
    }
}
class GenericDemo
{
    public static void main(String[] args) 
    {        
        TreeSet<Student> ts = new TreeSet<Student>(new Comp());
        ts.add(new Student("abc03"));
        ts.add(new Student("abc02"));
        ts.add(new Student("abc06"));
        ts.add(new Student("abc01"));            
        TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
        ts1.add(new Worker("wabc--03"));
        ts1.add(new Worker("wabc--02"));
        ts1.add(new Worker("wabc--06"));
        ts1.add(new Worker("wabc--01"));
        printSet(ts);
        printSet(ts1);    
    }
　　　　//可以迭代Person类以及Person类的子类
    public static void printSet(TreeSet<? extends Person> ts){
        for (Iterator<? extends Person> it=ts.iterator();it.hasNext() ; )
        {
            System.out.println(it.next().toString());
        }
    }    
}

 泛型的细节：

）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；

2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；

       原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；

3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；

ArrayList<String> al = new ArrayList<Object>();  //错

//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。

ArrayList<? extends Object> al = new ArrayList<String>();

al.add("aa");  //错

//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。 ？extends Object 代表Object的子类型不确定，怎么能添加具体类型的对象呢？

public static void method(ArrayList<? extends Object> al) {

　　al.add("abc");  //错

    //只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。

}

2、高级for循环

它的出现简化了集合的遍历。简化书写。

(1)、格式

for(数据类型  变量名 : 被遍历的集合(Collection或者数组)

{

}

(2)、高级for循环和传统for循环的区别

高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，必须使用迭代器。如果使用的是ListIterator，还可以在遍历的过程中对集合进行增删改查的动作。

如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。

代码演示：

import java.util.*;
class ForDemo 
{
    public static void main(String[] args) 
    {
        method_1();
        method_2();
        method_3();
    }

    //对List集合的遍历
    public static void method_1(){
        ArrayList<String> al=new ArrayList<String>();
        al.add("小明");
        al.add("老王");
        al.add("赵四");
        al.add("王五");
        al.add("钱枫");

        //用ListIterator进行迭代取出
        for (ListIterator<String> it=al.listIterator();it.hasNext() ; )
        {
            String name=it.next();
            if(name.equals("王五"))
                it.add("黑马");
            System.out.println(name);
        }
        

        //高级for循环

        for(String name:al){
            System.out.println(name);
        }
    }

    //对Map集合进行遍历
    public static void method_2(){
        HashMap<Integer,String> hm=new HashMap<Integer,String>();
        hm.put(2,"小明");
        hm.put(17,"赵柳");
        hm.put(6,"王五");
        hm.put(4,"孙莉");

        //转换成set集合，然后再使用迭代器
        for (Iterator<Map.Entry<Integer,String>> it= hm.entrySet().iterator();it.hasNext() ; )
        {
            Map.Entry<Integer,String> me=it.next();
            Integer key=me.getKey();
            String value=me.getValue();
            System.out.println(key+"...."+value);
        }

        //高级for
        for(Map.Entry<Integer,String> me:hm.entrySet()){
            Integer key=me.getKey();
            String value=me.getValue();
            System.out.println(key+":::::"+value);
        }
    }
    
    //对数组的遍历
    public static void method_3(){
        int[] arr={4,8,6,2,7,3};

        //普通遍历
        for (int x=0;x<arr.length ;x++ )
        {
            System.out.println(arr[x]);
        }

        //高级for
        for(int i:arr){
            System.out.println(i);
        }
    }
}

 3、可变参数(...)

可变参数其实就是上一种数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。这个参数可以接受任意个数的同一类型的数据。

方法的可变参数在使用时注意：可变参数一定要定义在参数列表最后面。

和以前接收数组不一样的是：

以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。所以简化了用户的书写，少了调用者定义数组的动作。

import java.util.*;
class ParamMethodDemo{
    public static void main(String[]args){
        show(“黑马”,2,5,4,6);
    }
    public static void show(String str,int...arr){//...三个点，多写少写都会报错
        System.out.pintln(Arrays.toString(arr));
    }
}

 4、静态导入：import static

import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。

静态导入注意事项：

当类名重名时，需要指定具体的包名。

当方法重名是，指定具备所属的对象或者类。

import static java.util.Arrays.*;
class StaticImport {
    public static void main(String[] args){
        int[] arr={5,1,7,6,2};
        sort(arr);
        int index=binarySearch(arr,5);
        Systm.out.println(Arrays.toString(arr));//此处不能忽略不写Arrays.因为toString方法和Object类中的toString方法重复，而Object类中的toString方法没有参数的。所以编译会失败的。
    }
}

 5、自动拆装箱

java中数据类型分为两种 ： 基本数据类型   引用数据类型(对象)

在 java程序中所有的数据都需要当做对象来处理，针对8种基本数据类型提供了包装类，如下：

int --> Integer

byte --> Byte

short --> Short

long --> Long

char --> Character

double --> Double

float --> Float

boolean --> Boolean

jdk1.5以前基本数据类型和包装类之间需要互转：

基本---引用   Integer x = new Integer(x);

引用---基本   int num = x.intValue();

1)、Integer x = 1; x = x + 1;  经历了什么过程？装箱-->拆箱-->装箱；

2)、为了优化，虚拟机为包装类提供了缓冲池，Integer池的大小 -128~127 一个字节的大小；

3)、String池：Java为了优化字符串操作 提供了一个缓冲池；

6、同步显式锁

在多线程中，同步代码块和同步函数都是隐式的锁。而 JDK1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作。

Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式操作变成显示锁操作。
lock()：获取锁。
unlock()：释放锁，锁的关闭动作要放在finally中。

创建锁对象的方法：Lock lock=new ReentrantLock();

Condition接口：出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象，可以任意锁进行组合。
await方法对应Object中的wait方法。
signal方法对应Object中的notify方法。
signalAll方法对应Object中的notifyAll方法。

获取Condition con= lock.newCondition();

多生产---多消费代码演示：

import java.util.concurrent.locks.*;
class Resource
{
    private String name;
    private int count=1;
    private boolean flag;
    //获取锁对象
    private Lock lock=new ReentrantLock();
    //通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者
    private Condition pro_condition=lock.newCondition();
    private Condition con_condition=lock.newCondition();
    public void set(String name){
        lock.lock();        
        try{
            while(flag)
                try
                {
                    pro_condition.await();
                }
                catch (Exception e)
                {
                    System.out.println(e);
                }
                this.name=name+"..."+count++;
                System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
                flag=true;
                con_condition.signal();
        }
        finally{
            lock.unlock();
        }
    }
    public void out(){
        lock.lock();
        try{
            while(!flag)
                try
                {
                    con_condition.await();
                }
                catch (Exception e)
                {
                    System.out.println(e);
                }
                System.out.println(Thread.currentThread().getName()+"+++++++++++消费者+++"+this.name);
                flag=false;
                pro_condition.signal();
        }
        finally{
            lock.unlock();
        }
    }
}
class Producer implements Runnable
{
    private Resource r;
    Producer(Resource r){
        this.r=r;
    }
    public void run(){
        while (true)
        {
            r.set("商品");
        }        
    }
}
class Consumer implements Runnable
{
    private Resource r;
    Consumer(Resource r){
        this.r=r;
    }
    public void run(){
        while (true)
        {
            r.out();
        }
    }
}
class ProducerConsumerDemo 
{
    public static void main(String[] args) 
    {
        Resource r=new Resource();
        new Thread(new Producer(r)).start();
        new Thread(new Producer(r)).start();
        new Thread(new Consumer(r)).start();
        new Thread(new Consumer(r)).start();
    }
}

 二、其他对象API

1、System类

(1)、System类中的字段和方法都是静态的。

out：标准输出，默认是控制台

in：标准输入，默认是键盘。

Windows系统中换行为 两个转义字符，Linux只有一个 。

(2)、常见方法

1.获取当前时间的毫秒值

 long    System.currentTimeMillis(); 

 可以通过此方法检测程序执行的时间。

public static void main(String[] args){
  long start=System.currentTimeMilis();
  code();//这里是封装运行代码函数
  long end=System.currentTimeMillis();
  System.out.println("毫秒："+(end-start));  
}

 2.退出java虚拟机

System.exit(0);

 3.运行垃圾回收机

System.gc()

 4.获取当前的系统属性信息

Properties    getProperties();

 因为Properties是Hashtable的子类，也就是Map集合的一个子类对象，那么可以通过Map的方法取出该集合中的元素。该集合中存储的都是字符串，没有泛型定义。

//获取所有属性信息
public static void main(String[] args){
    Properties p=System.getProperties();
    for(Object obj:p.keySet()){
        String value=(String)(p.get(obj));
        System.out.println(obj+”..”+value);
    }
}

//获取指定属性信息。
String value = System.getProperty("os.name");//获取指定键所对应的值
System.out.println("value="+value);
//如何在系统中自定义一些特有信息呢？
String s=System.setProperty(“你好吗”,”我还好”);//设置指定键值信息
给属性设置一些属性信息，这些信息是全局的，其他程序都可以使用。例：System.setPeroperty("myclasspath","c:myclass");。

 5.修改标准的输入和输出流

static void  setIn(InputStream in);//分配“标准”输入流。 
static void  setOut(PrintStream out);//分配“标准”输出流。 

 2、Runtime类

该类并没有提供构造函数。说明不可以new对象。那么会直接想到该类中的方法都是静态的。发现该类中还有非静态方法。说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。由这个特点可以看出该类使用了单例设计模式完成。该方式是static Runtime getRuntime()。

import java.io.*;
class Demo{
    public static void main(String[] args)throws IOException{
        Runtime run=Runtime.getRuntime();
        Process p=run.exec(“notepad.exeD:\mystudy\HelloWorld.java”);//用记事本打开指定文件
    }
}

 3、Date、DateFormat、SimpleDateFormat类

日期对象和毫秒值之间的转换：

1.日期对象转成毫秒值。Date类中的getTime方法。

2.如何将获取到的毫秒值转成具体的日期呢？  Date类中的setTime方法。也可以通过构造函数new Date(timeMillis)。

对日期对象进行格式化：

将日期对象-->日期格式的字符串。

使用的是DateFormat类中的format方法。

将日期格式的字符串-->日期对象。

使用的是DateFormat类中的prase方法。

String  format(Date date);将一个Date格式化为日期/时间字符串

SimpleDateFormat(String pattern);用给定的模式和日期符号构造

eg：SimpleDateFormat sdf=new SimpleDateFormat(“yyyy年MM月dd日E kk点mm分ss秒”);

　　　　 //日期对象转成毫秒值
        Date d = new Date();
        long time1 = d.getTime();
        long time2 = System.currentTimeMillis(); / /毫秒值。
        
        //毫秒值转成具体的日期
        long time = 1439889065620;
        Date d = new Date();
        d.setTime(time);

import java.text.*;
class Demo{
    pubic static void main(String[] args){
        Date d=new Date();
        //将模式封装到SimpleDateformat对象中。
        SimpleDateFormat sdf=new SimpleDateFormat(“yyyy年MM月dd日E HH点mm分ss秒”);
        //调用format方法让模式格式化指定Date对象。
        String date=sdf.format(d);
        System.out.println(date);
    }
}

import java.text.*;
import java.util.*;
class Demo{
    public static void main(String[] args){
        Date d=new Date();
        DateFormat df=DateFormat.getDateInstance(DateFormat.FULL);
        String date=df.format(d);
        System.out.println(date);

　　　　　df = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.LONG);
         String str_date2 = df.format(date);
         System.out.println(str_date2);

    }
}

 4、Calendar类

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

Calender    getInstance();//获取Calendar对象
int  get(int field);//返回给定日历字段的值
abstract  void add(int field, int amount)//给日历字段添加或减去指定的时间量.
c.add(Calendar.YEAR,-2);//年数减去2年。
void  set(int year, int month, int date)//设置年月日 

mport java.util.*;
class CalendarDemo 
{
    public static void main(String[] args) 
    {
        Calendar c=Calendar.getInstance();
        String[] weeks={" ","星期日","星期一", "星期二","星期三","星期四","星期五","星期六"};
        String[] months={"一月","二月","三月","四月","五月", "六月","七月","八月","九月","十月","十一月","十二月"};
        int year=c.get(Calendar.YEAR);//获取年
        int month=c.get(Calendar.MONTH);//获取月份
        int day=c.get(Calendar.DAY_OF_MONTH);//获取月份中的日期
        int week=c.get(Calendar.DAY_OF_WEEK);//获取星期
        System.out.println(year+"年"+months[month]+day+"日"+weeks[week]);
    }
}

 5 、Math类

Math：提供了操作数学运算的方法，都是静态的。

常用方法：

(1)、返回大于指定数据的最小整数

double    ceil(double a);
eg: double d=Math.ceil(16.34);//17

 (2)、返回小于指定数据的最大整数

double    floor(double a);
eg: double d=Math.floor(-12.34);//-13

 (3)、返回四舍五入的整数

long    round(double a);
int    round(double a);
eg:  long l = Math.round(12.54);//13

 (4)、a的b次方

pow(a,b);
eg: double d2=Math.pow(2,3);//8.0

 (5)、返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。

double random();
eg: int d=(int)(Math.random()*10+1);/1到10的整数

 其实该方法可以用util包中的Random工具类来方便的完成、

Random类中的方法

new Random();
int  nextInt( int n);// 随机生成0（包括）和指定值（不包括）之间的 int 值
double  nextDouble();//随机生成在 0.0 和 1.0 之间的 double 值


Random r=new Random();
int i = (int)(r.nextDouble() * 6 + 1);//1到6之间的整数
int x=r.nextInt(6)+1;//1到6之间的整数