/*
collection
    |--list 元素是有序的，可以重复
   |--ArrayList:底层的数据结构是用的 数组结构  特点：是查询数据很快；但是增加和删除稍慢 线程不同步
   |--LinkList：底层是用的链表数据结构  特点，查询数据很慢，但是增加和删除很快
   |--vector：底层是数组数据结构 线程同步 被arraylist替代
|--set 元素无序，不可以重复
List
特哟方法，凡是可以操作角标的方法都是该体系的特有的方法
增
   add(index,elemet);
   addAll(index.collection);
   删
   remove(index)'
   改
   set(index.element);
   查
   get(index );
   List集合特有的迭代器，ListIterator是Iterator的子接口
   在迭代式不可以通过集合对象的方法操作集合中的 元素，因为会发生
   所以在迭代时，只能用迭代器放过操作元素，可是Iterator的方法是有局限的
   如果要操作添加修改，就需要子接口Listiterator来操作
*/
import java.util.*;
class Listdemo
{
public static void sop(Object obj)
{
  System.out.println(obj);
}
public static void method()
{

  ArrayList al=new ArrayList();
  al.add("java1");
  al.add("java2");
  al.add("java3");
  al.add("java4");
  //sop(al);
  //al.add(1,"java5");//添加
  
  //al.remove(2);//删除
  //al.set(2,"dfdf");//修改
  //或去角标元素
  //sop(al.get(3));
//获取所有的元素
for (int x=0;x<al.size();x++ )
{
          System.out.println("al("+x+")="+al.get(x));
}
        for (Iterator it=al.iterator(); it.hasNext(); )
        {
   sop(it.next());
        }
  //通过indexof获取对象
  sop(al.indexOf("java2"));
  List li=al.subList(1,4);
  sop(li);
}
public static void main(String[] args)
{
  ArrayList al=new ArrayList();
  al.add("java1");
  al.add("java2");
  al.add("java3");
  al.add("java4");
// sop(al);
ListIterator li=al.listIterator();
  //列表迭代器，只有list集合具有这个功能 （增删改查）
  while (li.hasNext())
  {
   Object obj=li.next();
   if(obj.equals("java2"))
   // li.add("java2.2");
   li.set("java090");
  }
  
  while(li.hasPrevious())
  {
  
  sop(li.previous());
  }
  
  //sop(li);
  /*
  Iterator it=al.iterator();
  while(it.hasNext())
  {
  Object obj=it.next();
  if(obj.equals("java1"))
    it.remove();
    sop("obj="+obj);  
  }
  sop(al);*/
}
}

非常好,学习了,

非常好,学习了,

List和Iterator的区别

让我们先运行一下代码

实例：public void fillAll(){

       Session session=HibernateUtil.getSession();

       Query query=session.createQuery("from Customers");

       List<Customers> list=query.list();

       for(Customers l:list){

           System.out.println(l.getEmail());

       }
执行结果：Hibernate: selectcustomers0_.id as id0_, customers0_.realName as realName0_, customers0_.pass aspass0_, customers0_.sex as sex0_, customers0_.petName as petName0_,customers0_.email as email0_, customers0_.rdate as rdate0_ from Customers customers0_

null

asd

null
    }

    @Test

    public void fillA(){

       Session session=HibernateUtil.getSession();

       Query query=session.createQuery("from Customers");

       Iterator<Customers> it=query.iterate();

       while(it.hasNext()){

           Customers c=(Customers) it.next();

           System.out.println(c.getEmail());

       }
     }
执行结果：Hibernate: select customers0_.id as col_0_0_ from Customers customers0_
Hibernate: selectcustomers0_.id as id0_0_, customers0_.realName as realName0_0_,customers0_.pass as pass0_0_, customers0_.sex as sex0_0_, customers0_.petNameas petName0_0_, customers0_.email as email0_0_, customers0_.rdate as rdate0_0_from Customers customers0_ where customers0_.id=?
null
Hibernate: selectcustomers0_.id as id0_0_, customers0_.realName as realName0_0_,customers0_.pass as pass0_0_, customers0_.sex as sex0_0_, customers0_.petNameas petName0_0_, customers0_.email as email0_0_, customers0_.rdate as rdate0_0_from Customers customers0_ where customers0_.id=?
asd
Hibernate: selectcustomers0_.id as id0_0_, customers0_.realName as realName0_0_,customers0_.pass as pass0_0_, customers0_.sex as sex0_0_, customers0_.petNameas petName0_0_, customers0_.email as email0_0_, customers0_.rdate as rdate0_0_from Customers customers0_ where customers0_.id=?
Null
很明显的看出：Iterator输入的sql语句多：N+1条语句
总结:
Query的两个方法，list()和 iterate() ， 两个方法都是把结果集列出来， 他们有3点不一样，
1：返回的类型不一样，list()返回List,iterate()返回Iterator,
2: 获取数据的方式不一样，list()会直接查数据库,iterate()会先到数据库中把id都取出来，然后真正要遍历某个对象的时候先到缓存中找,如果找不到,以id为条件再发一条sql到数据库,这样如果缓存中没有数据,则查询数据库的次数为n+1。
3：iterate会查询2级缓存，　list只会查询一级缓存。
4: list()中返回的List中每个对象都是原本的对象,iterate()中返回的对象是代理对象.(debug可以发现)
list()方法在执行时，直接运行查询结果所需要的查询语句。
iteraor()方法则是先执行得到对象ID的查询，然后在根据每个ID值去取得所要查询的对象。
因此：对于list()方式的查询通常只会执行一个SQL语句，而对于iterator()方法的查询则可能需要执行N+1条SQL语句(N为结果集中的记录数).
结果集的处理方法不同:
list()方法会一次取出所有的结果集对象，而且他会依据查询的结果初始化所有的结果集对象。如果在结果集非常庞大的时候会占据非常多的内存，甚至会造成内存溢出的情况发生。
iterator()方法在执行时不会一次初始化所有的对象，而是根据对结果集的访问情况来初始化对象。一次在访问中可以控制缓存中对象的数量，以避免占用过多的缓存，导致内存溢出情况的发生。