标签：
------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之间的整数
标签：
原文地址：http://www.cnblogs.com/521Android/p/4732982.html
