黑马程序员技术交流社区

标题: 这是我对ListIterator的理解 [打印本页]

作者: 草上飞 时间: 2012-10-27 21:29
标题: 这是我对ListIterator的理解
/*
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);*/
}
}

作者: 王龙 时间: 2012-10-27 21:38
非常好,学习了,

作者: 奋斗的青春 时间: 2012-10-27 21:45
本帖最后由吴愿涛于 2012-10-27 21:50 编辑

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()方法在执行时不会一次初始化所有的对象，而是根据对结果集的访问情况来初始化对象。一次在访问中可以控制缓存中对象的数量，以避免占用过多的缓存，导致内存溢出情况的发生。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2