java API中Util包

上章回顾：
包装类(Boolean、Byte、Character、Short、Integer、Long、Float、Double)
String与StringBuffer
Math
1. Object类
  toString();
  equals();
  hashCode();
2. Class类: 反射
  (1)Class c=Class.forName("类的全路径");
 Method[] ms=c.getMethods();
  (2)对象名.getClass();

本章重点
了解java.util包
运用如下类进行Java编程：
Date类
Calendar类
Random类
使用Collection接口及其实现类：
ArrayList类
LinkedList类
Vector类
掌握HashMap类


本章相关词汇
utility(有用的)  date  calendar(日历)  random(随意)   list(列表)
link(链条)     hash(散乱的,一般指散列码)   map(地图)  vector(向量) 

java.util包简介
java.util包是Java内置的一个工具包，其中包含一系列常用的工具类；
如处理日期和日历的类以及一些集合类；
java.util包不会默认导入，如果要使用到该包中的类，则必须在程序的开始部分显式地声明如下语句：
import java.util.*;

Date类
Date类对象用来表示时间和日期；
该类提供一系列操纵日期和时间各组成部分的方法；
Date类最多的用途是获取系统当前的日期和时间。


Date类的常用方法
boolean after(Date when)  如果当前日期对象在when指定的日期对象之后，返回true，否则返回false
boolean before(Date when) 如果当前日期对象在when指定的日期对象之前，返回true，否则返回false
void setTime(long time)  设置日期对象，以表示自1970年1月1日起的指定毫秒数
boolean equals(Object obj)如果两个日期对象完全相同，返回true，否则返回false
String toString()返回日期的格式化字符串，包括星期几


Date类的示例
public class DateDemo{
public static void main(String[] args){
Date date = new Date();  //获得当前的系统日期和时间
System.out.println("今天的日期是：" + date);


long time = date.getTime();  //获得毫秒数
System.out.println("自1970年1月1日起以毫秒为单位的时间(GMT):" + time);


//截取字符串中表示时间的部分
String strDate = date.toString();
String strTime = strDate.substring(11, (strDate.length() - 4));
System.out.println(strTime);
strTime = strTime.substring(0, 8);
System.out.println(strTime);
}
}


Calendar类
Calendar类也是用来操作日期和时间的类，但它可以以整数形式检索类似于年、月、日之类的信息；
Calendar类是抽象类，无法实例化，要得到该类对象只能通过调用getInstance方法来获得；
Calendar对象提供为特定语言或日历样式实现日期格式化所需的所有时间字段


Calendar类的常用方法
Calendar getInstance()  返回默认地区和时区的Calendar对象 
int get(int fields) 返回调用对象中fields指定部分的值
void set(int fields, int value) 将value中指定的值设置到fields指定的部分
void add(int fields, int amount)将amount值添加到fields指定的时间或日期部分
Date getTime() 返回与调用对象具有相同时间的Date对象
Object clone() 返回调用对象的副本
void clear() 清除当前对象中所有的时间组成部分
boolean after(Object obj)  如果调用对象时间在obj之后，返回true
boolean before(Object obj) 如果调用对象时间在obj之前，返回true
boolean equals(Object obj) 判断调用对象与obj是否相等


Calendar示例
public class CalendarDemo{
public static void main(String[] args){
//创建包含有当前系统时间的Calendar对象
Calendar cal = Calendar.getInstance();

//打印Calendar对象的各个组成部分的值
System.out.print("当前系统时间：");
System.out.print(cal.get(Calendar.YEAR) + "年");
System.out.print((cal.get(Calendar.MONTH) + 1) + "月");
System.out.print(cal.get(Calendar.DATE) + "日 ");
System.out.print(cal.get(Calendar.HOUR) + ":");
System.out.print(cal.get(Calendar.MINUTE) + ":");
System.out.println(cal.get(Calendar.SECOND));

//将当前时间添加30分钟，然后显示日期和时间
cal.add(Calendar.MINUTE, 30);
Date date = cal.getTime();
System.out.println("将当前时间添加30分钟后的时间：" + date);
}
}

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;


public class Test{
public static void main(String[] args) throws ParseException {
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//求30天的日期
Calendar cd=Calendar.getInstance();
cd.add(Calendar.DATE,30);
System.out.println("当前日期为："+sdf.format(new Date()));
System.out.println("30天后是："+sdf.format( cd.getTime() ));

//求给定的两个日期之间的小时数
String start="2014-11-07 12:00:00";
String end="2014-11-08 16:00:00";

Date d1=sdf.parse(start);
Date d2=sdf.parse(end);
//求绝对值       两个时间之间相差的毫秒数               将毫秒转为小时
System.out.println(  Math.abs( (d1.getTime()-d2.getTime())/ ( 1000*60*60 ) )  );

}
}


Random类
Random类专门用来生成随机数；
该类的构造方法有2种重载方式。

Random类的常用方法
int nextInt() 从随机数生成器返回下一个整型值
long nextLong()从随机数生成器返回下一个长整型值
float nextFloat() 从随机数生成器返回0.0到1.0之间的下一个浮点值
double nextDouble() 从随机数生成器返回0.0到1.0之间的下一个双精度值
double nextGaussian()从随机数生成器返回下一个高斯分布的双精度值。中间值为0.0，而标准差为1.0


Random类示例
public class RandomDem{
public static void main(String[] args) {
//创建一个Random类对象
Random rand = new Random();
//随机生成20个随机整数，并将其显示出来
for (int i = 0; i < 20; i++){
int num = rand.nextInt();
System.out.println("第" + (i + 1) + "个随机数是：" + num);
}
}
}
注意：当两个Random对象的随机种子一样时，生成的值也一样


import java.util.Random;


public class RandomTest {
public static void main(String[] args) {
//随机生成六位的验证码
Random rd=new Random();
StringBuffer sbf=new StringBuffer();

//String[] str={"0","1","2","3"...};  //97-122
int count=0;
int flag=0;

while(count<=5){
flag=rd.nextInt(2);
if(flag==0){ //数字
sbf.append(rd.nextInt(10));
}else{ //字母
sbf.append( (char)(rd.nextInt(26)+97) );
}
count++;
}

System.out.println(sbf.toString());
}
}

Arrays类
对数组进行操作，包括排序，查找等.
Arrays.asList(T... a)            将一个数组转换成一个list
Arrays.sort(str)
Arrays.binarySearch(str,"e")   使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。
Arrays.fill(str1,"苏苏")          //将指定的 值分配给指定  型数组的每个元素。
Arrays.copyOf("","");          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。




集合
集合是将多个元素组成一个单元的对象；
类似于数组，但数组最大的缺点是：长度受到限制（一经创建，就不可再改变），并且只能存放相同数据类型的元素；
集合的长度没有限制，可以存放任意多的元素，而且元素的数据类型也可以不同；
集合还提供一系列操纵数据的方法，如存储、检索等等。


集合框架的优点
提供有用的数据结构和算法，从而减少编程工作；
提高了程序速度和质量,因为它提供了高性能的数据结构和算法；
允许不同 API 之间的相互操作，API之间可以来回传递集合；
可以方便地扩展或改写集合。

java.util包中的集合类
为了满足不同场合的需要，java.util包中包含有一系列集合类；
如：ArrayList类、LinkedList类、Vector类、HashMap类等等，接下来将逐一进行介绍；
集合类中只能存放对象，而不能存放原始数据类型的元素，所以当有原始数据类型需要存放时，只能将其转换成相应的包装类对象。


ArrayList类
ArrayList是长度可变的对象引用数组，称为动态数组；  (Collection:采集)
随着元素的添加，元素数目的增大，数组容量也会随之自动扩展；
访问和遍历数组元素时，ArrayList的性能优越；
ArrayList类继承了AbstractList类并实现了List接口


ArrayList类的常用方法
int size() 返回ArrayList对象的大小，即元素的数量
boolean isEmpty() 判断ArrayList对象是否为空，为空返回true，否则返回false
void clear() 清空ArrayList对象中的所有元素
boolean add(Object element) 向ArrayList对象中添加一个元素，该元素可以是任何类的对象
Object remove(int index) 从ArrayList对象中删除指定索引位置的元素
Object get(int index) Object get(int index) 返回指定索引位置的元素
Object set(int index, Object elem) 将元素elem存放到由index指定的索引位置上
int indexOf(Object element) 判断element在ArrayList对象中是否存在，存在返回对应的索引，否则返回-1
<T> T[]  toArray(T[] a)    按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
void trimToSize()    将此 ArrayList 实例的容量调整为列表的当前大小。 
boolean addAll(Collection<? extends E> c) 将一个list中的元素全部添加到另外一个list中 


ArrayList类示例1
public class ArrayListDemo1 {
public static void main(String[] args) {
ArrayList al = new ArrayList();    //创建一个空ArrayList对象
for (int i = 0; i < 10; i++) {
Integer num = new Integer(i);    //创建整型包装类对象
al.add(num);                     //将该对象存放到ArrayList中
}
System.out.println("数组中的元素：");
for (int i = 0; i < al.size(); i++) {
Integer temp = (Integer)(al.get(i));  //获得ArrayList中索引为i的元素
System.out.println(temp);
}
System.out.println("*********************************");
al.clear();  //清空
System.out.println("数组被清空后的情况：");
System.out.println("数组长度为：" + al.size());
if (al.isEmpty()) {    //判断是否为空
System.out.println("数组现在为空。");
}else{
System.out.println("数组现在不为空。");
}
}
}


ArrayList类示例2
public class ArrayListDemo2 {
public static void main(String[] args) {
ArrayList al = new ArrayList();     //创建一个空的ArrayList对象
//往动态数组中添加元素
al.add("苹果"); al.add("梨子"); al.add("香蕉");
al.add("西瓜"); al.add("榴莲");
System.out.println("目前数组的长度：" + al.size());
for (int i = 0; i < al.size(); i++) {
System.out.println((String)(al.get(i)));
}
String str = new String("西瓜");
int index = al.indexOf(str);      //判断某个元素是否存在
if (index < 0) {
System.out.println(str + "在数组中不存在。");
} else {
System.out.println(str + "存在，索引为：" + index);
}
al.remove(3);                     //删除某个索引位置的元素
System.out.println("删除索引为3的元素后的情况：");
for (int i = 0; i < al.size(); i++) {
 System.out.println((String)(al.get(i)));
}
}
}


泛型


LinkedList类
LinkedList类用于创建链表数据结构；
链表中元素的数量不受任何限制，可以随意地添加和删除；
与ArrayList相比，如果需要频繁地添加和删除元素，LinkedList的性能更加优越；
LinkedList类继承了AbstractSequentialList类，并实现了List接口；


LinkedList类的构造方法和常用方法


LinkedList类示例
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList ll = new LinkedList();  //创建空的链表
for (int i = 1; i <= 10; i++) {
Double temp = new Double(Math.sqrt(i));  //创建包装类对象
ll.add(temp);   //将包装类对象添加到链表中
}
System.out.println("链表中的元素：");
//循环打印链表中的元素
for (int i = 0; i < ll.size(); i++) {
System.out.println(ll.get(i));
}
System.out.println("*********************************");
ll.removeFirst();  //删除第一个元素
ll.removeLast();   //删除最后一个元素
System.out.println("删除第一个元素和最后一个元素后的链表：");
for (int i = 0; i < ll.size(); i++) {
System.out.println(ll.get(i));
}
}
}


补充Collection与Collections
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作.
Collections类
List<String> list=new ArrayList<String>();   
Collections.addAll(list,"a","c","e","b","d");  //将多个元素同时添加到list中
Collections.binarySearch(list,"e")   使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。
Collections.max(list)                     根据元素的自然顺序，返回给定 collection 的最大元素。
Collections.min(list)                     根据元素的自然顺序，返回给定 collection 的最小元素。
Collections.replaceAll(List<T> list, T oldVal, T newVal)    使用另一个值替换列表中出现的所有某一指定值。
Collections.reverse(List<?> list)             反转指定列表中元素的顺序。
Collections.shuffle(List<?> list)       使用默认随机源对指定列表进行置换。
Collections.sort(List<?> list)        根据元素的自然顺序 对指定列表按升序进行排序。
Collections.swap(List<?> list, int i, int j)   在指定列表的指定位置处交换元素。
Collections.unmodifiableList(List<? extends T> list)    返回指定列表的不可修改视图。



Iterator类
Iterator<T> itr=list.iterator();

boolean hasNext()   如果仍有元素可以迭代，则返回 true。 
E next()  返回迭代的下一个元素。 
void remove()  从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。 



Vector类
Vector类与ArrayList类和LinkedList类很相似，最大的区别在于Vector是线程同步的；
如果在多线程的程序中要使用到集合框架，并且不希望线程与线程之间相互干扰，那么Vector是不错的选择；
Vector类继承于AbstractList类，并实现了List接口。




Vector类的构造方法和常用方法


Vector类示例
public class VectorDemo{
public static void main(String[] args){
Vector vec = new Vector();  //创建空的Vector


//往Vector中添加元素
vec.addElement("Java");
vec.addElement("C#");
vec.addElement("Oracle");
vec.addElement("C++");
vec.addElement("HTML");


System.out.println(vec.toString()); //打印Vector中的元素


vec.removeElement("C++");  //删除其中的元素
System.out.println(vec.toString());

//List<E> subList(int fromIndex, int toIndex) 
//返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。 

// Object[] toArray() 
//返回一个数组，包含此向量中以恰当顺序存放的所有元素。 
}
}


Set接口, TreeSet, HashSet
Set接口: 无序，不可重复
HashSet: 不同步, 与Hash有关,可使用null. 比较contains时要重写类的hashCode与equals方法. HashSet无法保证元素存入的顺序与取出的顺序一样.
TreeSet: 排序Set,实体类必须实现Comparable接口,定义排序规的则
public int compareTo(Object o){
 return o==null?1: (this.id-((Student)o).id);
  }
  
HashSet、TreeSet、LinkedHashSet都是set类型，它们的区别？
HashSet提供了最快的查找技术，TreeSet按照比较结果的升序保存对象，LinkedHashSet按照添加顺序保存对象。
HashMap、TreeMap和LinkedHashMap跟上面一样。


HashMap类
HashMap以键值对的形式存储元素；
对于HashMap来说，不存在索引，也就是说不可以通过索引来访问元素，只能通过键去访问值，如要快速检索元素的话，HashMap性能优越；
由于没有索引，所以HashMap中元素的存放是没有顺序的；
HashMap类继承了AbstractMap类，并实现了Map接口。


HashMap类的构造方法和常用方法
contains:包含


HashMap示例
public class HashDemo {
public static void main(String[] args) {
HashMap hm = new HashMap();  //创建空的HashMap
//往HashMap中添加元素
hm.put("93-07", "张三");
hm.put("84-12", "李四");
hm.put("102-20", "王五");
hm.put("91-04", "郑六");
hm.put("111-17", "田七");


//打印出HashMap中的元素
System.out.println(hm.toString());
//通过键对象查找值对象
System.out.println("学号91-04的学生是" + hm.get("91-04"));
System.out.println("学号84-12的学生是" + hm.get("84-12"));
hm.remove("93-07");  //通过键对象删除元素
System.out.println(hm.toString());
}
}

HashTable类
此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。
HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
(除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。)此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 


ArrayList:
1.存放的对象可以重复
2.可以存放null对象
3.不是线程同步的，即不是安全的存储
4.输出顺序跟添加顺序一样

HashSet:
1.存放的对象不能重复
2.可以存放null对象
3.不是线程同步的，即不是安全的存储
4.输出顺序跟添加顺序不一定相同


TreeSet:
1.存放的对象不能重复
2.不可以存放null对象
3.不是线程同步的，即不是安全的存储
4.按照比较结果升序保存对象

LinkedHashSet:
1.存放的对象不能重复
2.可以存放null对象
3.不是线程同步的，即不是安全的存储
4.按照添加顺序保存对象

HashSet、TreeSet、LinkedHashSet都是Set类型，它们的区别主要在于：
HashSet提供最快的查找技术
TreeSet按照比较结果升序保存对象
LinkedHashSet按照添加顺序保存对象



Map<key,value>
HashMap：
1.一个映射不能包含重复的键；每个键最多只能映射到一个值。 
2.允许使用 null 值和 null 键
3.不是线程同步的，即不是安全的存储
4.输出顺序跟添加顺序不一定相同，根据hash函数存储

TreeMap：
1.一个映射不能包含重复的键；每个键最多只能映射到一个值。 
2.不允许使用null键，但可以使用null值
3.不是线程同步的，即不是安全的存储
4.映射根据其键的自然顺序进行排序

LinkedHashMap：
1.一个映射不能包含重复的键；每个键最多只能映射到一个值。 
2.允许使用 null 值和 null 键
3.不是线程同步的，即不是安全的存储
4.按照添加顺序保存对象

Hashtable:
1.一个映射不能包含重复的键；每个键最多只能映射到一个值。 
2.不允许使用 null 值和 null 键
3.是线程同步的
4.输出顺序跟添加顺序不一定相同，根据hash函数存储




Queue(队列，典型的先进先出)
Queue<String> queue=new LinkedList<String>();
boolean add(E e)  将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，如果当前没有可用的空间，则抛出 IllegalStateException。 
E element()   获取，但是不移除此队列的头。 
boolean offer(E e)   将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。 
E peek()   获取但不移除此队列的头；如果此队列为空，则返回 null。 
E poll()   获取并移除此队列的头，如果此队列为空，则返回 null。 
E remove()  获取并移除此队列的头，如果没有则抛异常 


如何选择集合类
1. 无顺序要求，选HashSet
2. 对顺序有求，选ArrayList
3. 要顺序，经常修改，选LinkedList
4. 键-值  HashMap


总结
java.util包中包含一系列常用的工具类和集合框架类；
Date类和Calendar类用来操作日期和时间；
可以使用Random类的对象来生成随机数；
集合框架提供了一系列复杂的数据结构和优越的算法；
ArrayList类可以创建动态数组；
LinkedList类可以创建链表结构；
Vector类可以创建线程同步的动态数组；
HashMap类可以创建键值对集合。






同步：就是一个东西一次只允许一个进程操作，做多线程是安全的
异步：各做各的，同时操作，即不安全




hash的一般队列，链表的等等都是无序的