for(int x=0; x<list.size(); x++)="" {="" sop("get:"+list.get(x));="" }="" <="" pre="">
<br>
ListIterator新增功能：
<br>
一般的迭代器Iterator只能判断，取出元素，不能操作元素（最多删除元素），但是List的特有迭代器可以操作元素。
此迭代器特有的方法：
<code><code><strong>add</strong>(E e)</code><br>
</code>
<code><strong>set</strong>(E e)</code><br>
<code><code><strong>hasPrevious</strong>()</code><br>
</code>
<code><code><code><strong>previous</strong>() //返回前面一个元素，配合上面一个方法可以反向遍历集合</code><br>
</code></code>
<br>
<br>
<h3>|-----ArrayList</h3>
<h3>|-----Vector</h3>
ArrayList与Vector是List接口的典型实现,底层是数组结构。特点：查询速度很快。但是增删稍慢。
<br>
ArrayList与Vector区别：
他们几乎一样，Vector比较古老（JDK 1.0)
1、ArrayList线程不安全（线程不同步的），性能高。Vector线程安全（线程同步），性能低
总之：Vector已被淘汰。用ArrayList。
<br>
他们与数组用法上的区别：<br>
1、数组的容量是固定的（虽然也可以扩充的方法，但不主张），而ArrayList的容量是动态的。<br>
2、一个数组只能保存一种类型，而Arraylist可以保存不同类型。<br>
3、数组可以保存基本数据类型，但ArrayList不可以，它保存的是Object类的引用，因此在取出元素时，要做类型转换，或利用泛型。<br>
4、数组的效率高，但ArrayList的效率低。当增加一个新元素时，ArrayList首先要检查其内部数组是否越界，如没有越界，则可增加；如越界，则新建一个两倍于当前内部数组容量的新数组，将旧内部数组的元素拷贝至新内部数组，并废弃旧数组，因此其效率相比数组要低。<br>
<br>
<br>
<h3>|-----LinkedList</h3>
底层是链表结构。特点：增删速度很快，查询稍慢。线程不同步。
LinkedList:特有方法：<br>
addFirst();<br>
addLast();<br>
<br>
getFirst();<br>
getLast();<br>
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException<br>
removeFirst();<br>
removeLast();<br>
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException<br>
<br>
在JDK1.6出现了替代方法。<br>
offerFirst();<br>
offerLast();<br>
<br>
peekFirst();<br>
peekLast();<br>
获取元素，但不删除元素。如果集合中没有元素，会返回null。<br>
pollFirst();<br>
pollLast();<br>
获取元素，但是元素被删除。如果集合中没有元素，会返回null。<br>
<br>
<h2>|-----Set接口</h2>
特点：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。
<br>
<h3>|-----HashSet</h3>
底层是哈希表，是线程不安全的，元素不可重复。
<br>
HashSet是如何保证元素唯一性的呢？<br>
是通过元素的两个方法，hashCode和equals来完成。<br>
如果元素的HashCode值相同，才会判断equals是否为true。<br>
如果元素的hashcode值不同，不会调用equals。<br>
<br>
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
<br>
例子：
<pre class="brush:java;">/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。
需要重写：hashCode函数和equals函数
*/
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int hashCode()
{
System.out.println("调用了hashCode方法");
return name.hashCode()+age*7;
}
public boolean equals(Object obj)
{
System.out.println("调用了equals方法");
if(!(obj instanceof Person))
throw new ClassCastException();
Person p=(Person)obj;
return name.equals(p.name)&&age==p.age;
}
}
class HashSetDemo
{
public static void main(String[] args)
{
HashSet<person> hs=new HashSet<person>();
hs.add(new Person("lisi01",10)); //调用了hashCode方法
hs.add(new Person("lisi01",10)); //调用了hashCode方法,调用了equals方法,发现重复，不存储
hs.add(new Person("lisi03",12)); //调用了hashCode方法
hs.add(new Person("lisi04",13)); //调用了hashCode方法
Iterator<person> it=hs.iterator();
while(it.hasNext())
{
Person p=it.next();
System.out.println(p.getName()+"......"+p.getAge());
}
}
}</person></person></person></pre><br>
<h3>|-----TreeSet</h3>
确切的说TreeSet是SortSet接口的实现。顾名思义可以对Set集合的元素排序。
TreeSet的底层数据结构是二叉树。
TreeSet是如何保证元素唯一性的呢？
int compareTo()方法return 0，即表明两个元素相等，不存储。<br>
<br>
<br>
TreeSet排序有两种方式：
TreeSet排序的第一种方式：让元素自身具备比较性。<br>
元素需要实现Comparable接口，覆盖compareTo方法。<br>
这种方式也称为元素的自然顺序，或者叫做默认顺序。<br>
<br>
TreeSet的第二种排序方式：<br>
当元素自身不具备比较性时，或者具备的比较性不是所需要的。<br>
这时就需要让集合自身具备比较性。<br>
通过定义新的类实现Comparator接口的比较器，然后覆盖public int compare(Object o1,Object o2)方法，并将该类（比较器）的对象作为参数传给TreeSet的构造函数中。
<p><br>
</p>
<p>注意：自定义类型如果想要创建对象放入TreeSet集合，必须实现Comparable接口，也就是第一种排序方式（元素自身具备比较性），否则TreeSer根本不知道如何排序存储。</p>
<p>存储第一个可能不会报错（还没有调用对象的compareTo方法），但存储第二个就会引发ClassCastException异常。</p>
<p><br>
</p>
<p>例子：</p>
<p></p>
<pre class="brush:java;">/*
将自定义类Person的对象存入TreeSet集合
并用两种方法实现排序:
第一种方法（必须的，否则ClassCastException异常）：
以年龄进行排序，如果年龄相等，则以名字字符串的compareTo方法排序（按字典顺序比较两个字符串)，如果名字也相同，视为同一个人。
第二种方法（看需求）：
以名字字符串的compareTo方法排序（按字典顺序比较两个字符串)，如果字符串相同，再以年龄进行排序，如果相同视为同一个人。
*/
import java.util.*;
class Person implements Comparable //第一种方法
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int compareTo(Object obj) //第一种方法
{
Person p=(Person)obj;
if(this.age>p.age)
return 1;
else if(this.age<p.age) return="" -1;="" else="" this.name.compareto(p.name);="" string类中提供类自己的compareto方法。="" }="" class="" treesetdemo="" {="" public="" static="" void="" sop(object="" obj)="" system.out.println(obj);="" main(string[]="" args)="" treeset<person=""> ts=new TreeSet<person>(new MyCompare());//第二种方法需要传参数new MyCompare();
ts.add(new Person("lisi01",10));
ts.add(new Person("lisi03",12));
ts.add(new Person("lisi02",11));
ts.add(new Person("lisi04",11));
Iterator<person> it=ts.iterator();
while(it.hasNext())
{
Person p=(Person)it.next();
sop(p.getName()+"....."+p.getAge());
}
}
}
class MyCompare implements Comparator<person> //第二种方法 PS:这里用了泛型，所以下面compare方法的参数可以不是Object，而且免去强转的麻烦
{
public int compare(Person p1,Person p2)
{
int num=p1.getName().compareTo(p2.getName());
if(num==0)
{
if(p1.getAge()>p2.getAge())
return 1;
else if(p1.getAge()<p2.getage()) return="" -1;="" else="" 0;=
