码迷,mamicode.com
首页 > 编程语言 > 详细

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

时间:2015-08-20 14:51:56      阅读:246      评论:0      收藏:0      [点我收藏+]

标签:

------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来进行扩展的,现在可以用泛型来表示。这样可以避免强转的麻烦,而且将运行问题转移到的编译时期。

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

泛型前:

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

 泛型后:

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

 示例:

 1 import java.util.*;
 2 class GenericDemo 
 3 {
 4     public static void main(String[] args) 
 5     {
 6 
 7         ArrayList<String> al=new ArrayList<String>();
 8         al.add("abc");
 9         al.add("abqqe");
10         al.add("k");
11         al.add("fd");        
12         Collections.sort(al,Collections.reverseOrder(new LenComparator()));//逆转LenComparator比较器的比较顺序
13         for (Iterator<String> it=al.iterator();it.hasNext() ; )
14         {
15             String str=it.next();
16             System.out.println(str);
17         }
18     }
19 }
20 //按照字符串的长度进行排序
21 class LenComparator implements Comparator<String>
22 {
23     public int compare(String s1,String s2){
24         int num= s1.length()-s2.length();
25         return num==0?s1.compareTo(s2):num;
26     }
27 }

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

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

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

泛型出现前:

 1 class Student{}
 2 class Worker{}
 3 class Tool{
 4     private Object obj;
 5     public void setObject(Object obj){
 6         this.obj=obj;
 7     }
 8     public Object getObject(){
 9         return obj;
10     }
11 }
12 class Dmeo{
13     public static void main(Sting[] args){
14         Tool t=new Tool();
15         t.setObject(new Student());//Object obj=new Student();这里可以传入任意类型的对象,Objec都可以接收
16         Student s=(Student)t.getObject();//强转,容易出现ClassCastException异常
17     }
18 }

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

 1 import java.util.*;
 2 class Student
 3 {
 4 }
 5 class Worker
 6 {
 7 }
 8 class Utils<T>
 9 {
10     private T t;    
11     public void setObject(T t){
12         this.t=t;
13     }
14     public T getObject(){
15         return t;
16     }
17 }
18 class GenericDemo2 
19 {
20     public static void main(String[] args)     {
21         
22         Utils<Student> u=new Utils<Student>();
23         u.setObject(new Student());//如果传入的不是Student对象,编译时期就会直接报错。
24         Student s=u.getObject();//避免强转
25     }
26 }

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

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

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

 1 import java.util.*;
 2 class Demo<T>
 3 {
 4     public void show(T t){
 5         System.out.println(t);
 6     }
 7     public void print(T t){
 8         System.out.println(t);
 9     }
10 }
11 class GenericDemo3 
12 {
13     public static void main(String[] args) 
14     {
15         Demo<String> d=new Demo<String>();
16         d.show("你好");
17         d.print("你也好");
18 //        d.print(234);//error;不兼容的类型: int无法转换为String
19         //怎么既能让print()打印Integer又能打印String呢?
20         Demo<Integer> d1=new Demo<Integer>();
21         d1.print(45);
22         //上面的方法有点繁琐,而且内存中的对象太多,可以采用把泛型定//义在方法上解决。
23     }
24 }

 代码修正后:

 1 import java.util.*;
 2 class Demo<T>
 3 {
 4     public void show(T t){
 5         System.out.println(t);
 6     }
 7     public<E> void print(E e){
 8         System.out.println(e);
 9     }
10     public<Q> void run(Q q){
11         System.out.println(q);
12     }
13 }
14 class GenericDemo3
15 {
16     public static void main(String[] args){
17         Demo<String> d=new Demo<String>();        
18         d.print(78);
19         d.print("你好");
20         d.show("你也好");
21         d.show(34);//不兼容的类型: int无法转换为String.该方法上没有定义泛型,所以还是跟着类上的泛型走的。
22         d.run(65);
23     }
24 }

 特殊之处:

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

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

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

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

}

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

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

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

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

 1 interface Inter<T>{
 2     public abstract void show(T t);
 3 }
 4 class Demo<T> implements Inter<t>{
 5     public void show(T t){
 6         System.out.println(“show==”+t);
 7     }
 8 }
 9 class GenericDemo{
10     public static void main(String[] args){
11         Demo<Integer> d=new Demo<Integer>();
12         d.show(4);
13     }
14 }

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

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

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

 (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)

代码演示:

 1 import java.util.*;
 2 class Person
 3 {
 4     private String name;
 5     Person(String name)
 6     {
 7         this.name = name;
 8     }
 9     public String getName()
10     {
11         return name;
12     }
13     public String toString()
14     {
15         return name;
16     }
17 }
18 class Student extends Person
19 {
20     Student(String name)
21     {
22         super(name);
23     }
24 }
25 class Worker extends Person
26 {
27     Worker(String name)
28     {
29         super(name);
30     }
31 }
32 class Comp implements Comparator<Person>
33 {
34     public int compare(Person p1,Person p2)
35     {
36         return p2.getName().compareTo(p1.getName());
37     }
38 }
39 class GenericDemo
40 {
41     public static void main(String[] args) 
42     {        
43         TreeSet<Student> ts = new TreeSet<Student>(new Comp());
44         ts.add(new Student("abc03"));
45         ts.add(new Student("abc02"));
46         ts.add(new Student("abc06"));
47         ts.add(new Student("abc01"));            
48         TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
49         ts1.add(new Worker("wabc--03"));
50         ts1.add(new Worker("wabc--02"));
51         ts1.add(new Worker("wabc--06"));
52         ts1.add(new Worker("wabc--01"));
53         printSet(ts);
54         printSet(ts1);    
55     }
    //可以迭代Person类以及Person类的子类
56 public static void printSet(TreeSet<? extends Person> ts){ 57 for (Iterator<? extends Person> it=ts.iterator();it.hasNext() ; ) 58 { 59 System.out.println(it.next().toString()); 60 } 61 } 62 }

 泛型的细节:

)、泛型到底代表什么类型取决于调用者传入的类型,如果没传,默认是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循环,它的出现为了简化书写。

代码演示:

 1 import java.util.*;
 2 class ForDemo 
 3 {
 4     public static void main(String[] args) 
 5     {
 6         method_1();
 7         method_2();
 8         method_3();
 9     }
10 
11     //对List集合的遍历
12     public static void method_1(){
13         ArrayList<String> al=new ArrayList<String>();
14         al.add("小明");
15         al.add("老王");
16         al.add("赵四");
17         al.add("王五");
18         al.add("钱枫");
19 
20         //用ListIterator进行迭代取出
21         for (ListIterator<String> it=al.listIterator();it.hasNext() ; )
22         {
23             String name=it.next();
24             if(name.equals("王五"))
25                 it.add("黑马");
26             System.out.println(name);
27         }
28         
29 
30         //高级for循环
31 
32         for(String name:al){
33             System.out.println(name);
34         }
35     }
36 
37     //对Map集合进行遍历
38     public static void method_2(){
39         HashMap<Integer,String> hm=new HashMap<Integer,String>();
40         hm.put(2,"小明");
41         hm.put(17,"赵柳");
42         hm.put(6,"王五");
43         hm.put(4,"孙莉");
44 
45         //转换成set集合,然后再使用迭代器
46         for (Iterator<Map.Entry<Integer,String>> it= hm.entrySet().iterator();it.hasNext() ; )
47         {
48             Map.Entry<Integer,String> me=it.next();
49             Integer key=me.getKey();
50             String value=me.getValue();
51             System.out.println(key+"...."+value);
52         }
53 
54         //高级for
55         for(Map.Entry<Integer,String> me:hm.entrySet()){
56             Integer key=me.getKey();
57             String value=me.getValue();
58             System.out.println(key+":::::"+value);
59         }
60     }
61     
62     //对数组的遍历
63     public static void method_3(){
64         int[] arr={4,8,6,2,7,3};
65 
66         //普通遍历
67         for (int x=0;x<arr.length ;x++ )
68         {
69             System.out.println(arr[x]);
70         }
71 
72         //高级for
73         for(int i:arr){
74             System.out.println(i);
75         }
76     }
77 }

 3、可变参数(...)

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

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

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

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

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

 4、静态导入:import static

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

静态导入注意事项:

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

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

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

 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();

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

 1 import java.util.concurrent.locks.*;
 2 class Resource
 3 {
 4     private String name;
 5     private int count=1;
 6     private boolean flag;
 7     //获取锁对象
 8     private Lock lock=new ReentrantLock();
 9     //通过已有的锁获取两组监视器,一组监视生产者,一组监视消费者
10     private Condition pro_condition=lock.newCondition();
11     private Condition con_condition=lock.newCondition();
12     public void set(String name){
13         lock.lock();        
14         try{
15             while(flag)
16                 try
17                 {
18                     pro_condition.await();
19                 }
20                 catch (Exception e)
21                 {
22                     System.out.println(e);
23                 }
24                 this.name=name+"..."+count++;
25                 System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
26                 flag=true;
27                 con_condition.signal();
28         }
29         finally{
30             lock.unlock();
31         }
32     }
33     public void out(){
34         lock.lock();
35         try{
36             while(!flag)
37                 try
38                 {
39                     con_condition.await();
40                 }
41                 catch (Exception e)
42                 {
43                     System.out.println(e);
44                 }
45                 System.out.println(Thread.currentThread().getName()+"+++++++++++消费者+++"+this.name);
46                 flag=false;
47                 pro_condition.signal();
48         }
49         finally{
50             lock.unlock();
51         }
52     }
53 }
54 class Producer implements Runnable
55 {
56     private Resource r;
57     Producer(Resource r){
58         this.r=r;
59     }
60     public void run(){
61         while (true)
62         {
63             r.set("商品");
64         }        
65     }
66 }
67 class Consumer implements Runnable
68 {
69     private Resource r;
70     Consumer(Resource r){
71         this.r=r;
72     }
73     public void run(){
74         while (true)
75         {
76             r.out();
77         }
78     }
79 }
80 class ProducerConsumerDemo 
81 {
82     public static void main(String[] args) 
83     {
84         Resource r=new Resource();
85         new Thread(new Producer(r)).start();
86         new Thread(new Producer(r)).start();
87         new Thread(new Consumer(r)).start();
88         new Thread(new Consumer(r)).start();
89     }
90 }

 二、其他对象API

1、System类

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

out:标准输出,默认是控制台

in:标准输入,默认是键盘。

Windows系统中换行为\r\n两个转义字符,Linux只有一个\n。

(2)、常见方法

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

1  long    System.currentTimeMillis(); 

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

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

 2.退出java虚拟机

1 System.exit(0);

 3.运行垃圾回收机

1 System.gc()

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

1 Properties    getProperties();

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

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

 

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

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

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

 2、Runtime类

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

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

 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秒”);

1      //日期对象转成毫秒值
2         Date d = new Date();
3         long time1 = d.getTime();
4         long time2 = System.currentTimeMillis(); / /毫秒值。
5         
6         //毫秒值转成具体的日期
7         long time = 1439889065620;
8         Date d = new Date();
9         d.setTime(time);

 

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

 

 1 import java.text.*;
 2 import java.util.*;
 3 class Demo{
 4     public static void main(String[] args){
 5         Date d=new Date();
 6         DateFormat df=DateFormat.getDateInstance(DateFormat.FULL);
 7         String date=df.format(d);
 8         System.out.println(date);
 9 
10      df = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.LONG);
11          String str_date2 = df.format(date);
12          System.out.println(str_date2);
13 
14     }
15 }

 4、Calendar类

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

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

 

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

 5 、Math类

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

常用方法:

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

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

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

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

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

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

 (4)、a的b次方

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

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

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

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

Random类中的方法

1 new Random();
2 int  nextInt( int n);// 随机生成0(包括)和指定值(不包括)之间的 int 值
3 double  nextDouble();//随机生成在 0.0 和 1.0 之间的 double 值
4 
5 
6 Random r=new Random();
7 int i = (int)(r.nextDouble() * 6 + 1);//1到6之间的整数
8 int x=r.nextInt(6)+1;//1到6之间的整数 

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

标签:

原文地址:http://www.cnblogs.com/521Android/p/4732982.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!