一、collection框架
（1）LIST
list是一种collection，作用是收集对象，并以索引的方式保留收集的对象的顺序。其操作类之一就是Java.utl.ArrayList.ArrayList特性：随机查找（list.get[i]），ArrayList内部就是用Object来保存收集的对象。此时就考虑到了数组的特性。根据数据结构内容我们只数组的好处就是随机存储速度快，排序等就可以考虑使用ArrayList
package Learn; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Scanner; public class ListDemo { public static void main(String[] args) { List name=new ArrayList();//收集信息的list collectNameTo(name);//收集函数 System.out.println("输出访客名单："); printUpperCase(name);//输出收集到的信息 } /** *@author wbm *@param List *@deprecated通过控制台输入访客的名称，如果遇到quit则退出输入访客名称的循环，每次循环都把收集到的信息通过List.add(信息对象)收集到list中去 */ static void collectNameTo(List names){ Scanner console=new Scanner(System.in);//控制台输入信息 while(true){ System.out.println("访客名称："); String name=console.nextLine(); if(name.equals("quit")){ break; } names.add(name);//把控制台输入的信息放入到list中去 } } /** *通过for循环把传进来的List通过索引获取list元素并转换为string性，然后通过string的toUpperCase()转为大写 */ static void printUpperCase(List names){ for (int i = 0; i < names.size(); i++) { String name=(String) names.get(i);//通过索引获得收集的信息 System.out.println(name.toUpperCase()); } } }
LinkedList特性:采用链接结构。链接结构简单代码如下。
package Learn; public class LinkListDemo { private class Node{ Object o; Node next; Node(Object o){ this.o=o; } } private Node first; public void add(Object elem){ Node node=new Node(elem); if(first==null){ first=node; } else{ append(node); } } private void append(Node node){ Node last=first; while(first.next!=null){ last=last.next; } last.next=node; } public int size(){ int count=0; Node last=first; while(last.next!=null){ last=last.next; count++; } return count; } public Object get(int index){ checkSize(index); return findElemof(index); } private void checkSize(int index)throws IndexOutOfBoundsException{ int size=size(); if(index>=size){ throw new IndexOutOfBoundsException( String.format("index:%d size:%d", index,size)); } } private Object findElemof(int index){ int count=0; Node last=first; while(count<index){ last=last.next; count++; } return last.next; } }
（2）set
也是收集对象，但是对象相同则不重复收集。知道不重复单词个数有几个代码如下。
public static void mian(String[] args) { // TODO Auto-generated method stub Scanner scanner=new Scanner(System.in); System.out.println("请输入英文"); Set words=tokenSet(scanner.nextLine());//scanner.nextLine()String类型 System.out.printf("不重复的字有%d个：%s%n",words.size(),words); } static Set tokenSet(String line){ String[] tokens=line.split(" ");//根据空白切割字符串 return new HashSet(Arrays.asList(tokens));//使用HashSet收集字符串 }
使用set时得告诉怎样的对象是相同，这时要用对象的hashCode()和equals()来判断对象是够相同。HashSet的操作哦该娘是，在内存中开设空间，每个空间都会有哈希编码，这些空间称为哈希桶，如果对象要加入哈希桶，则要调用对象的hashcode()，并尝试放入对应的哈希桶中，如果哈希桶中没有对象就放入，如果有对象就调用equals()进行比较。有无equals和hashcode的对比代码如下
package Learn; import java.util.HashSet; import java.util.Set; class Student { private String name; private String number; Student(String name,String number){ this.name=name; this.number=number; } @Override public String toString() { return "Student [name=" + name + ", number=" + number + "]"; } } package Learn; import java.util.HashSet; import java.util.Set; public class Students { public static void main(String[] args) { Set students=new HashSet(); students.add(new Student("b","c")); students.add(new Student("b","c")); students.add(new Student("q","c")); System.out.println(students); } } 结果： [Student [name=q, number=c], Student [name=b, number=c], Student [name=b, number=c]] package Learn; import java.util.HashSet; import java.util.Set; class Student { private String name; private String number; Student(String name,String number){ this.name=name; this.number=number; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); result = prime * result + ((number == null) ? 0 : number.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (number == null) { if (other.number != null) return false; } else if (!number.equals(other.number)) return false; return true; } @Override public String toString() { return "Student [name=" + name + ", number=" + number + "]"; } } 结果： [Student [name=b, number=c], Student [name=q, number=c]]
java.util.TreeSet不仅有收集不重复对象的能力，还可以用红黑树的方式排序收集到的对象，条件就是收集到的对象必须是Comparable(否则会抛出ClassCastException)，或者是在创建的是后指定comparator对象
（3）quene
支持队列操作，收集的对象加入至尾部，取得的对象时从前部，quene继承自collection所以有add、remove、element等方法然而quene定义了自己的offer、poll、peak等方法主要区别在于，add、remove、element等方法操作失败时会抛出异常，而offer、poll、peak会返回特定的值。对象需要使用队列且长度受限是用通常使用poll、offer、peak方法。从架构图可知linkedList不仅操作了queue的行为也操作了list的行为。所以可以将linkedlist当做队列来使用。
简单的代码实例如下：
package Learn; public interface Request { void execute(); } package Learn; import java.util.*; /** * offer是在队列前端加入对象成功会返回trues失败会返回false。 * poll是去除队列的前端对象，若队列为空则返回null。 * peak是取得前端对象但是不取出若为空则返回null。 * */ public class RequestQuene{ public static void main(String[] args) { Queue requests=new LinkedList(); offerRequestTo(requests); process(requests); } static void offerRequestTo(Queue requests){ //请求加入队列 for(int i=1;i<6;i++){ Request request=new Request(){ @Override public void execute() { // TODO Auto-generated method stub System.out.printf("处理数据%f%n",Math.random()); } }; requests.offer(request); System.out.println(requests.offer(request)); } } static void process(Queue requests){ //处理队列中的请求 while(requests.peek()!=null){ Request request=(Request)requests.poll(); request.execute(); } } }
如果想要对队列的前端和尾端进行操作，在前端加入对象和取出对象，在尾端加入对象和取出对象，queue的子接口Deque就定义了该行为。deque中定义addFirst()、removeFirst()、getFirst()、addLast()、
removeLast()、getLast()等方法，操作失败时会抛出异常。而offerFirst()、pollFirst()、peekFirst()、offerLast()、pollLast()、peekLast()操作失败会返回特定的值。java.util.ArrayDeque操作了Deque接口，操作使用容量有限的堆栈的简单实例如下
package Learn; import java.util.*; public class Stack { private Deque elems=new ArrayDeque(); private int capacity; Stack(int capacity){ this.capacity=capacity; } public boolean push(Object elem){ if(isFull()){ return false; } else{ return elems.offerLast(elem); } } private boolean isFull(){ return elems.size()+1>capacity; } public Object pop(){ return elems.pollLast(); } public Object peek(){ return elems.peekLast(); } public int size(){ return elems.size(); } public static void main(String[] args) { Stack stack=new Stack(5); stack.push("justin"); stack.push("wbm"); stack.push("wcy"); System.out.println(stack.pop()); System.out.println(stack.pop()); System.out.println(stack.pop()); } } 结果： wcy wbm justin 堆栈是先进后出
queue的操作类之一java.util.PriorityQueue也是，收集至PriorityQueue的对象，会根据你指定的优先权来决定对象在队列中的顺序，优先的告知，要不是对象必须是comparable,或者是在创建PriorityQueue时指定comparator对象。
（3）Interable与Iterator
iterator方法JDK5之前是定义在collection中在JDK5之后定义在iterable;具体的一些好处和细节如下代码。
//收集LIst对象 static void forEachList(List list){ int size=list.size(); for(int i=0;i<size;i++){ System.out.println(list.get(i)); } } //收集set对象 static void forEachSet(Set set){ for(Object o:set.toArray()){ System.out.println(o); } } //收集queue对象 static void forEachQueue(Queue queue){ while(queue.peek()!=null){ System.out.println(queue.poll()); } } //含有这个方法的类是util，那么你就可以指定使用util.<String> elemOf()的方式指定E的实际类型 public static<E> E elemOf(E[] objs,int index){ return objs[index]; } //无论是Queue、List、Set都会有iterator方法JDK5之前是定义在collection中在JDK5之后定义在iterable static void forEachCollection(Collection collection){ Iterator iterator=collection.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } } static void forEachIterable(Iterable iterable){ Iterator iterator=iterable.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } }
package Learn; import java.util.ArrayDeque; import java.util.Arrays; import java.util.HashSet; import java.util.List; public class forEach { public static void main(String[] args) { List names=Arrays.asList("ww","bb","mm");//静态方法aslist接收不定长自变量将其指定为List forEach(names);//list是一种Iterable. forEach(new HashSet(names));//List是一种collection，hashSet是一种collection接收collection的构造函数所以list可以用来创建hashset forEach(new ArrayDeque(names));//同理 } static void forEach(Iterable iterable){ for (Object object : iterable) { System.out.println(object); } } }
（4）comparable与comparator
1. comparable（comparaTo()）
在收集对象之后，对对象排序是常用的动作，我们不用亲自操作排序算法，java.util.collections
List numbers=Arrays.asList(10,5,1,9,8,9,7);
Collections.sort(numbers);
System.out.println(numbers);
结果为：[1, 5, 7, 8, 9, 9, 10]
如果没有说明list元素的比较会出现错误
package Learn; import java.util.HashSet; import java.util.Set; class Student { private String name; private String number; Student(String name,String number){ this.name=name; this.number=number; } @Override public String toString() { return "Student [name=" + name + ", number=" + number + "]"; } } package Learn; import java.util.Arrays; import java.util.Collections; import java.util.List; public class Students { public static void main(String[] args) { List students=Arrays.asList(new Student("b","c"),new Student("b","c"),new Student("q","c")); Collections.sort(students); System.out.println(students); } } 出现： java.lang.ClassCastException:
collections.sort()的操作对象必须操作java.lang.comparable接口，这个接口有compareTo()方法的返回值必须大于0，等于0或小于0的整数。
package Learn; import java.util.HashSet; import java.util.Set; public class Student implements Comparable<Student> { private String name; private String number; Student(String name,String number){ this.name=name; this.number=number; } @Override public String toString() { return "Student [name=" + name + ", number=" + number + "]"; } @Override public int compareTo(Student o) { // TODO Auto-generated method stub return Integer.parseInt(this.number)-Integer.parseInt(o.number); } } package Learn; import java.util.Arrays; import java.util.Collections; import java.util.List; public class Students { public static void main(String[] args) { List students=Arrays.asList(new Student("b","1"),new Student("b","3"),new Student("q","2")); Collections.sort(students); System.out.println(students); } } 结果为 [Student [name=b, number=1], Student [name=q, number=2], Student [name=b, number=3]]
2.compatator（compare()）
如果对象无法操作comparable的话呢？比如String本身有操作Comparable，所以可以按字母的排序如果我想要把字母排序的顺序反过来呢？String是final的类型不能被继承所以无法重新定义compareTo()方法。Collection有另一个重载版本，可以接受java.lang.Comparator接口的操作对象。流程：1.定义一个comparator:class StringComparator implements<String>{ public int compare(String s1,String s2){ return s1.compareTo(s2);}} 2.调用：Collections.sort(List,new StringComparator());
package Learn; import java.util.Comparator; public class StringComparator implements Comparator <String> { @Override public int compare(String o1, String o2) { // TODO Auto-generated method stub return -o1.compareTo(o2); } } package Learn; import java.util.Arrays; import java.util.Collections; import java.util.List; public class sort { public static void main(String[] args) { List<String> words=Arrays.asList("B","A","C"); Collections.sort(words,new StringComparator()); System.out.println(words); } } 结果 [C, B, A]
二、Map框架
1.hashMap
1）概述
基于哈希表的Map接口的非同步实现。实现所有的可选映射操作，允许使用null键和null值。此类不保证映射的顺序。
2）数据结构
3）简单使用HashMap
对于Map而言键值是不会重复，判断键是否重复式根据hashcode和equals()，所以作为键的对象必须操作hashcode()与equals()
public static void main(String[] args) { Map<String,String> messages=new HashMap<String,String>(); messages.put("1", "one"); messages.put("2", "two"); messages.put("3", "three"); Scanner scanner=new Scanner(System.in); String message=messages.get(scanner.nextLine()); System.out.println(message); System.out.println(messages); } 结果为： 1 one {1=one, 2=two, 3=three}
2.TreeMap
键的部分会排序，条件式作为键的对象必须操作Comparable接口，或者是在创建TreeMap时指定Comparator接口的对象。
public static void main(String[] args) { Map<String,String> messages=new TreeMap<String,String>(); messages.put("1", "one"); messages.put("2", "two"); messages.put("3", "three"); System.out.println(messages); } } 结果为： {1=one, 2=two, 3=three}
3.使用Properties
Properties props=new Properties(); props.setProperty("username", "justin"); props.setProperty("password", "123456"); System.out.println(props.getProperty("username")); System.out.println(props.getProperty("password")); //从文档中读取属性 //文档内容a.properties /* cc.openhome.username=justin cc.openhome.password=123456 */ Properties props=new Properties(); props.load(new FileInputStream("args[0]")); System.out.println(props.getProperty("cc.openhome.username")); System.out.println(props.getProperty("cc.openhome.password"));
三、简单泛型的使用
在使用Collection收集对象时，由于事先不知道对象的形态使用的是Object来收集，取回对象也是Object，所以执行期间失去了形态的信息。所以取回对象之后要记得对象的真正的类型，然后让对象重新扮演
自己的类型。
List names=Array.asList("ww","bb","mm");
String name=(String)name.get(0);
ArrayList<String> names= new ArrayList<String>();
names.add("justin");
names.add("wbm");
names.add(new Long(10));//编译会出错没法通过。
String name1=names.get(0);
string nmae2=names.get(1);
静态方法上定义类型
//含有这个方法的类是util，那么你就可以指定使用util.<String> elemOf()的方式指定E的实际类型 public static<E> E elemOf(E[] objs,int index){ return objs[index]; }
补充：
Utilizes
Collections:是针对集合类的一个帮助类，提供了操作集合的工具方法：一系列静态方法实现对各种集合的搜索、排序、线程
安全化等操作。
Arrays:针对数组的一个帮助类，提供了操作arrays的工具方法：一系列静态方法对各种数组的搜索、排序等操作