容器总结
1：
/**
*
* @author zhuty
* @version 1.0.0
* @2010-11-25 下午02:26:07
*/
public class BasicContainer {
public static void main (String args[])
{
List list = new ArrayList();
list.add(1);
list.add("wawa129");
list.add(2);
list.add(new Name("zhu","tongyu"));
list.remove(2);
list.remove(new Name("zhu","tongyu"));
System.out.println("list---"+list);
}
static class Name
{
private String firstName;
private String lastName;
public Name(String firstName,String lastName)
{
this.firstName = firstName;
this.lastName = lastName;
}
public String toString()
{
return firstName + ""+lastName;
}
}
打印结果：list---[1, wawa129, zhutongyu]
分析：因为remove方法是这样实现的，它实现了equals方法，所以在它remove时，会去判断它们是否相等，所以2被remove掉了，但是Name对象没有被remove,因为Name对象是不同的对象(不同的地址)，虽说同名。
?总结：容器类对象在调用remove,contains等方法时需要比较对象是否相等，这会涉及到对象类型的 equals 方法和 hashCode方法；对于自定的类型，需要重写equals 和 hashCode方法以实现自定义的对象相等规则。
注意：相等的对象应该具有相等的hash codes。
所以以上程序如果想remove掉Name对象，需在Name类中增加equals 和hashCode方法。
程序更改为：
*/
public class BasicContainer {
public static void main (String args[])
{
List list = new ArrayList();
list.add(1);
list.add("wawa129");
list.add(2);
list.add(new Name("zhu","tongyu"));
list.remove(2);
list.remove(new Name("zhu","tongyu"));
System.out.println("list---"+list);
}
static class Name
{
private String firstName;
private String lastName;
public Name(String firstName,String lastName)
{
this.firstName = firstName;
this.lastName = lastName;
}
public String toString()
{
return firstName + ""+lastName;
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
if(obj instanceof Name)
{
Name name2 =(Name)obj;
return (firstName.equals(name2.firstName)&&(lastName.equals(name2.lastName)));
}
return super.equals(obj);
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
return firstName.hashCode();
}
打印结果为：list---[1, wawa129]
分析：Name的对象已经移除。
Iterator接口。
?所有实现了Collection接口的容器类都有一个Iterator iterator()方法用以返回一个实出Iterator接口的对象。
?Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。
?Iterator接口定义了如下方法:Boolean hastNext();//判断游标右边是否有元素。Object next();//返回游标右边的元素并将游标移动到下一个位置。Void remove();//删除游标左面的元素，在执行完next之后该操作只能执行一次。
注意：ArrayList就是数组的存储方式，for就可以遍历出所有的数。
而LinkedList是链表的存储方式，所以通过iterator方法遍历出来。
例：public static void main (String args[])
{
Collection list = new LinkedList();
//list.add(1);
//list.add("wawa129");
//list.add(2);
list.add(new Name("zhu","tongyu"));
//list.remove(2);
list.add(new Name("cao","qiaolin"));
//list.remove(new Name("zhu","tongyu"));
Iterator i = list.iterator();
while(i.hasNext())
{
System.out.println("value--"+i.next());
}
//remove()方法,注意它是Iterator的方法，不是容器自身的remove(obj)方法
for(Iterator I = i.iterator();i.hastNext();)
{
Name name =(Name)i.next();
If(name.getFirstName().length<3)
{i.remove();}
}
}
JDK1.5以后出现的新的增强for循环方式，适合于数组和容器：
例：
public class Test3 {
public static void main(String args[])
{
int []t = {3,4,3,2,33};
System.out.print("i对象---");
for(int i:t)
{
System.out.print(i+" ");
}
System.out.println("");
Collection cs = new ArrayList();
cs.add("abc");
cs.add(1);
cs.add(3);
System.out.print("o对象---");
for(Object o:cs)
{
System.out.print(o+" ");
}
}
}
输入结果：i对象---3 4 3 2 33
o对象---abc 1 3
?总结：缺点：*：在数组中不能方便的访问下标值。
*：在集合中，与使用Iterator相比，不能方例的删除集合中的内容。
所以除了简单遍历外，不建议使用它。
Collections类提供的一些方法：
以上问题是：sort等方法可以为对象，数字排序，它们是怎样确定大小的呢？
这就涉及到了Comparable接口
String是按照字符比较排序的，如：abc,abd 就是abc<abd
如：
package tt.com;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
/**
*
* @author zhuty
* @version 1.0.0
* @2010-11-25 下午02:26:07
*/
public class BasicContainer {
public static void main (String args[])
{
List list = new LinkedList();
//list.add(1);
//list.add("wawa129");
//list.add(2);
list.add(new Name("zhu","tongyu"));
//list.remove(2);
list.add(new Name("cao","qiaolin"));
list.add(new Name("tt","zz"));
//list.remove(new Name("zhu","tongyu"));
Iterator i = list.iterator();
while(i.hasNext())
{
System.out.println("value--"+i.next());
}
for(Iterator t = list.iterator();t.hasNext();)
{
}
Collections.sort(list);
}
static class Name implements Comparable
{
private String firstName;
private String lastName;
public Name(String firstName,String lastName)
{
this.firstName = firstName;
this.lastName = lastName;
}
//比较对象的大小，只要firstName一样，就判断他们相等。否则就继续比较lastName;
public int compareTo(Object o) {
// TODO Auto-generated method stub
Name name3 = (Name)o;
int first = firstName.compareTo(name3.firstName);
return first!=0?first:lastName.compareTo(name3.lastName);
}
public String toString()
{
return firstName + ""+lastName;
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
if(obj instanceof Name)
{
Name name2 =(Name)obj;
return (firstName.equals(name2.firstName)&&(lastName.equals(name2.lastName)));
}
return super.equals(obj);
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
return firstName.hashCode();
}
}
如何选择数据结构：
衡量标准：读的效率和改的效率
Array读快改慢
Linked改快读慢
Hash两者之间
?Map的接口：
注意：容器不像数组那些，容器不能装基本数据类型，容器装的必须是对象，但是jdk1.5以后，提供了对基本数据类型的打包（即打包成对象）和解包成基本类型。
如List list = new ArrayList();
list.add(1); 会自动打包成new Integer(1)对象
list.add(new Integer(1));
(一)泛型(使可以在集合中装入特定的类型)
例：
public static void main (String args[])
{
//加了泛型后，List只能装指定的类型，注意：在没加泛型之前，List可以加入任何object类型。
List<String> list = new LinkedList<String>();
//list.add(1);
//list.add("wawa129");
//list.add(2);
//list.remove(new Name("zhu","tongyu"));
list.add("zhutongyu");
list.add("caoqiaolin");
//加了泛型后，以后就取值就不用强制转换了。
Iterator<String> i = list.iterator();
while(i.hasNext())
{
//直接取值，不用转换为String
String value=i.next();
System.out.println("value--"+i.next());
}
//用泛型，表明只跟MyName类的对象比较。
Class MyName implements Comparable<MyName>
{
int age;
public int compareTo(MyName mm)
{
If(this.age>mn.aget)return 1;
}
}
//key只充许为String,value只充许为Integer
Map<String,Integer> map = new HashMap<String,Integer>();
