Collection接口定义了一个存取一组对象的方法，其子接口Set和List分别定义了存储方式。
Set中的数据对象没有顺序切不可以重复。
List中的数据对象有顺序且可以重复。
Map接口定义了存储“键(key)-值(value)映射对” 的方法。
Collection接口中的方法：
int seize();
boolean isEmpty();
void clear();
boolean contains(Object element);
boolean add(Object element);
boolean remove(Object element);//删除的时候，会对Collection中的各个元素与element进行equals操作，返回true，则删除。
Iterator iterator();
boolean containsAll(Collection c);
boolean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c);
Object[] toArray();容器类在调用remove、contains等方法时，需要比较对象是否相等，这会涉及到对象类型的equals方法和hashCode方法；对于自定义的类型，需要重写equals和hashCode方法一实现自定义的对象相等的规则。
注意：相等的对象应该具有相等的hash、codes。
增加Name类的equals和hashCode方法如下：
class Name{
private String firstName,lastName;
public Name(String firstName,String lastName){
this.firstName = firstName;
this.lastName = lastName;
}
//重写equals方法
public boolean equals(Object obj){
if(obj instanceof Name){
Name name = (Name) obj;
return (firstName.equals(name.firstName))
&& (lastName.equals(name.lastName));
}
return super.equals(obj);
}
//重写hashCode方法
public int hashCode(){
return firstName.hashCode();
}
}Iterator接口：
1、所有实现了Collection接口的容器类都有一个iterator方法，用以返回一个实现了Iterator接口的对象。
2、Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。
3、Iterator接口定义了如下方法：
boolean hasNest(); // 判断游标右边是否有元素
Object next(); //返回游标右边的元素并将其游标移动到下一个位置
void remove(); //删除游标左边的元素，在执行完next之后，该操作只能执行一次import java.util.*;
public class IteratorTest {
public static void main(String[] args) {
Collection c = new HashSet();
c.add(new Name("f1","l1"));
c.add(new Name("f2","l2"));
c.add(new Name("f3","l3"));
Iterator i = c.iterator(); // 注意该语句
while(i.hasNext()){
Name n = (Name)i.next();
System.out.println(n.getFirstName() + " ");
}
}
}Set接口是Collection的子接口，Set接口没有提供额外的方法，但实现Set接口的容器类中的元素是没有顺序的，而且不可以重复。
Set容器对应数据中的“集合”的概念。
Set容器类有HashSet、TreeSet等。
List接口：
List接口是Collection的子接口，实现List接口的容器类中的元素是顺序的，而且可以重复。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
List容器类有ArrayList、LinkedList等。
List接口的方法：
Object get(int index);
Object set(int index,Object element);
void add(int index,Object element);
Object remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);void sort(LIst); //对List容器内元素排序
void shuffle(List); //对List容器内的对象进行随机排列
void reverse(List); //对List容器内的对象进行逆序排列
void fill(List,Object); //用一个特定的对象重写整个List容器
void copy(List dest,List src); //将src List容器内容拷贝到dest List容器中
int binarySearch(List,object); //对于顺序的List容器，采用折半查找的方法查找特定的对象。Collections是直接对对象进行操作，即并将改变后的内容直接传给该对象。
Collections例子：
import java.util.*;
public class IteratorTest {
public static void main(String[] args) {
List l1 = new LinkedList();
for (int i = 0; i < 10;i++){
l1.add(i);
}
Collections.shuffle(l1);
System.out.println(l1);
System.out.println(Collections.binarySearch(l1, 5)); //由于不是排好序列的l1，所有返回的值没有实际意义。
Collections.sort(l1);
System.out.println(l1);
System.out.println(Collections.binarySearch(l1, 5));
}
}Compareable接口：
所有可以“排序”的类都实现了 java.lang.Comparable接口，Comparable接口中只有一个方法：
public int compareTo(Object obj); 该方法：
返回 0 表示 this == obj;
返回正数表示 this > obj;
返回负数表示 this < obj;对于特定的实现Collection的子类要比较大小，可以重写compareTo方法，例如：
public int compareTo(Object o){
Name n = (Name)o;
int lastCmp = lastName.compareTo(n.lastName);
return (lastCmp != 0 ? lastCmp : firstName.compareTo(n.firstName));
}如何选择数据结构：
衡量标准：读取的效率和改的效率
Array读快改慢
Linked改快读慢
Hash两者之间
Map接口（类似Python的字典）：
1、实现Map接口的类用来存储键-值对
2、Map接口的实现类有HashMap和TreeMap等
3、Map类中存储的键-值对通过键来标识，所以键值不能重复（这里是指的equals方法）
Object put(Object key,Object value); //注意返回的是对象
Object get(Object key); //取key对应的value值，注意返回的是对象，需要进行类型的转化
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
void putAll(Map t);
void clear();另：
Map m1 = new HashMap();
Map m2 = new TreeMap();
Map m3 = new HashMap(m1); //注意HashMap的构造方法
m3.putAll(m2);在合适的时机，自动打包、解包：
打包：自动将基础类型转换为对象
解包：自动将对象转换为基础类型
例如：
Map m1 = new HashMap();
m1.put("one“，new Integer(1)); 可以直接写成 m1.put("one",1);
System.out.println(m1.get("one")); //自动解包
import java.uti.*;
public class CalFreq{
private static final int ONE = 1;
public static void main(String args[]){
Map<String,Integer> m = new HashMap<String,Integer>();
for(int i=0;i<args.length;i++){
//int freq = (Integer)m.get(args[i]) == null ? 0 : (Integer)m.get(args[i]);
//m.put(args[i],freq ==0 ? ONE : freq + 1);
if(!m.containsKey(args[i])){
m.put(args[i], ONE);
}else{
int freq = m.get(args[i]);
m.put(args[i], freq + 1);
}
}
System.out.println(m.size() + " distinct words detected:");
System.out.println(m);
}
}起因：1、装入集合的类型都被当作Object对待，从而失去自己的实际类型；2、从集合中取出时往往需要转型，效率低，且容易产生错误。
解决办法：在定义集合的时候同时定义集合中对象的类型。从而增强程序的可读性和稳定性。
打印map键值对：
import java.util.*;
public class findMaxList {
public static void main(String args[]){
findMaxList fml = new findMaxList();
Map<Integer,String> map = fml.getList("abcsdfsfdefghlnnse");
Set set = map.keySet();
// for(Iterator iter =set.iterator();iter.hasNext();){
// int key = (int)iter.next();
// System.out.println("最大长度为：" + key);
// System.out.println("最大字符串为：" + (String)map.get(key));
// }
for(Integer s: map.keySet()){
System.out.println(最大长度为：" + s);
System.out.println("最大字符串为：" + map.get(s));
}
}
public Map<Integer,String> getList(String str){
Map<Integer,String> map = new HashMap<Integer,String>();
int maxLen = 1;
int maxIndex = 0;
int strLen = str.length();
for(int i=0;i<strLen-1;i++){
int index = i;
int len = 1;
while(((int)(str.charAt(index)) + 1) == (int)(str.charAt(index + 1))){
len++;
index++;
if(len > maxLen){
maxLen = len;
maxIndex = index;
}
}
}
map.put(maxLen, str.substring(maxIndex-maxLen, maxIndex));
return map;
}
}
结果：
最大长度为：5
最大字符串为：fdefg
2009
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
