精华内容
下载资源
问答
  • 迭代Iterator的用法

    2016-11-22 17:14:00
    把访问逻辑从不同类型集合类中抽象出来,从而避免向客户端暴露集合内部结构 迭代(Iterator)与枚举(Enumeration)区别: Iterator为一个接口,java.util.Iterator提供迭代基本规则。Enumeration属于...

    迭代遍历:

    • 一个标准化遍历各类容器里面的所有对象的方法类(典型的设计模式)
    • 把访问逻辑从不同类型的集合类中抽象出来,从而避免向客户端暴露集合的内部结构 

    迭代(Iterator)与枚举(Enumeration)的区别:

    1.  Iterator为一个接口,java.util.Iterator提供迭代的基本规则。Enumeration属于Java Collections Framework  ;
    2.  迭代器允许调用者在迭代期间从迭代器所指向的 collection 移除元素;
    3.  方法名称得到了改进。

    一、未使用Iterator

    •  数组遍历:
    int[] arrays = new int[10];  
    for(int i = 0 ; i < arrays.length ; i++){  
           int a = arrays[i];  
           //do something  
       } 

        上述实例缺点:

    1. 事先知道集合的内部结构,访问代码和集合本身是紧密耦合的,无法将访问逻辑从集合类和客户端代码中分离出来。
    2. 每一种集合对应一种遍历方法,客户端代码无法复用

    二、使用Iterator

    • Iterator模式用同一种逻辑来遍历集合,使得客户端自身不需要来维护集合的内部结构,所有的内部状态都由Iterator来维护。
    • 客户端从不直接和集合类打交道,它总是控制Iterator,向它发送"向前","向后","取当前元素"的命令,就可以间接遍历整个集合。

    1.使一个类可迭代的步骤:

    Step1:在类声明中加入implements Iterable<Item>,对应的接口为(即java.lang.Iterator)

    public interface Iterable<Item>{
    Iterator
    <Item> iterator(); }

    Step2:在类中实现iterator()方法,返回一个自己定义的迭代器Iterator<Item>

    public Iterator<Item> iterator(){
    
        //如果需要逆序遍历数组,自定义一个逆序迭代数组的迭代器
         return new ReverseArrayIterator();
    }

    Step3:在类中设置内部类(如private class ReverseArrayIterator() ),内部类声明中加入implements Iterator<Item>,对应的接口为(即java.util.Iterator)

    public interface Iterator {  
      boolean hasNext();  
      Object next();  
      void remove();  
    } 

     

    2.使用Iterator实例(摘自算法(第四版)):

    下压(LIFO)栈--能动态调整数组大小(学习迭代器只需要重点看后面两大段):

    import java.util.Iterator;
    import java.util.NoSuchElementException;
    
    public class ResizingArrayStack<Item> implements Iterable<Item> {
        private Item[] a;         // array of items
        private int n;            // number of elements on stack
    
    
        /**
         * Initializes an empty stack.
         */
        public ResizingArrayStack() {
            a = (Item[]) new Object[2];
            n = 0;
        }
    
        /**
         * Is this stack empty?
         * @return true if this stack is empty; false otherwise
         */
        public boolean isEmpty() {
            return n == 0;
        }
    
        /**
         * Returns the number of items in the stack.
         * @return the number of items in the stack
         */
        public int size() {
            return n;
        }
    
    
        // resize the underlying array holding the elements
        private void resize(int capacity) {
            assert capacity >= n;
    
            // textbook implementation
            Item[] temp = (Item[]) new Object[capacity];
            for (int i = 0; i < n; i++) {
                temp[i] = a[i];
            }
            a = temp;
    
           // alternative implementation
           // a = java.util.Arrays.copyOf(a, capacity);
        }
    
    
    
        /**
         * Adds the item to this stack.
         * @param item the item to add
         */
        public void push(Item item) {
            if (n == a.length) resize(2*a.length);    // double size of array if necessary
            a[n++] = item;                            // add item
        }
    
        /**
         * Removes and returns the item most recently added to this stack.
         * @return the item most recently added
         * @throws java.util.NoSuchElementException if this stack is empty
         */
        public Item pop() {
            if (isEmpty()) throw new NoSuchElementException("Stack underflow");
            Item item = a[n-1];
            a[n-1] = null;                              // to avoid loitering
            n--;
            // shrink size of array if necessary
            if (n > 0 && n == a.length/4) resize(a.length/2);
            return item;
        }
    
    
        /**
         * Returns (but does not remove) the item most recently added to this stack.
         * @return the item most recently added to this stack
         * @throws java.util.NoSuchElementException if this stack is empty
         */
        public Item peek() {
            if (isEmpty()) throw new NoSuchElementException("Stack underflow");
            return a[n-1];
        }
    
        /**
         * Returns an iterator to this stack that iterates through the items in LIFO order.
         * @return an iterator to this stack that iterates through the items in LIFO order.
         */
        public Iterator<Item> iterator() {
            return new ReverseArrayIterator();
        }
    
        // an iterator, doesn't implement remove() since it's optional
        private class ReverseArrayIterator implements Iterator<Item> {
            private int i;
    
            public ReverseArrayIterator() {
                i = n-1;
            }
    
            public boolean hasNext() {
                return i >= 0;
            }
    
            public void remove() {
                throw new UnsupportedOperationException();
            }
    
            public Item next() {
                if (!hasNext()) throw new NoSuchElementException();
                return a[i--];
            }
        }
    }

    遍历时用foreach语句:

    ResizingArrayStack<String> stack = new ResizingArrayStack<String>();
     for (String str:stack ) {
        System.out.println(str);
     }

     

     

    作者: 邹珍珍(Pearl_zhen)

    出处: http://www.cnblogs.com/zouzz/

    声明:本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出 原文链接 如有问题, 可邮件(zouzhenzhen@seu.edu.cn)咨询.

    转载于:https://www.cnblogs.com/zouzz/p/6090105.html

    展开全文
  • List中的数据保存顺序就是数据的添加顺序; List集合中可以保存有重复的元素; List子接口比Collection接口扩充了一个get()方法; List选择子类就使用ArrayList(Vetor图片界面在用); Set 在开发之中,Set接口绝对...

    1.Collection(单值保存最大父接口)
    List
    List中的数据保存顺序就是数据的添加顺序;
    List集合中可以保存有重复的元素;
    List子接口比Collection接口扩充了一个get()方法;
    List选择子类就使用ArrayList(Vetor图片界面在用);
    Set
    在开发之中,Set接口绝对不是首选,如果真要使用也建议使用HashSet子类;
    Comparable这种比较器大部分情况下只会存在于Java理论范畴内;
    Set不管如何操作,必须始终保持一个前提,数据不能够重复;
    集合输出
    常用:Iterator(public hasNext(); public E next();),Enumeration(public boolean hasMoreElements(); public E nextElement();)
    很少用:listIterator(专为List集合使用),foreach
    2.Map
    (1)HashMap和Hashtable的区别?
    HashMap Hashtable
    推出时间:jdk 1.2属于新的类 jdk1.0
    性能: 采用异步处理 采用同步处理
    数据安全:非线程安全 线程安全
    设置null: 允许key或value内容为空 不允许为空
    综上理解:Map是为了查找数据信息使用,Collection是为了输出数据使用。
    (2)Map集合利用Iterator接口输出的步骤:
    entrySet()方法将Map集合转化为Set集合,里面的泛型是Map.Entry对象;
    再利用Iterator输出Set集合数据;
    3.Stack类是Vector子类,是一种先进后出的数据结构。

    展开全文
  • Iterable与Iterator的区别

    2018-01-19 14:44:00
     Iterable:python中的列表,元组,字符串,迭代器等都属于,都可以用for来迭代  IteratorIterator类型的数据不仅可以用for来迭代,而且还可以使用next(object)方法来获取下一个值(python有的版本也会...

      新手学习python,总会看到Iterable与Iterator,但是不能正确区分这两个,本菜鸟也是,今天就来聊聊二者的区别:

      Iterable:python中的列表,元组,字符串,迭代器等都属于这类,都可以用for来迭代

      Iterator:Iterator类型的数据不仅可以用for来迭代,而且还可以使用next(object)方法来获取下一个值(python有的版本也会用object.next())

    总结就是可以用for来迭代读取的就是Iterable,可以用next()来获取下一个的就是Iterator,如上所示,Iterable包括了Iterator,二者可以通过函数iter()和list()来互相转换

     

    转载于:https://www.cnblogs.com/diwangguilai/p/8316882.html

    展开全文
  • 属于java.lang包,实现该接口的类的对象可以变成foreach语句遍历目标。 方法Iterator<T> iterator()泛型方法。 返回一个在T类型元素上迭代迭代器。 一般是实现该接口然后匿名实现Iterator接口。...

    今天学习了的主要内容:

    1.Iterable接口
    2.Iterator接口
    

    Iterable接口:

    属于java.lang包,实现该接口的类的对象可以变成foreach语句的遍历目标。
     
     方法:
      	Iterator<T> iterator()泛型方法。
      	返回一个在T类型元素上迭代的迭代器。
    	一般是实现该接口然后匿名实现Iterator接口。
    

    Iterator接口:

    Iterator<E>称他为迭代器。
      	属于java.util包,他被大量的运用于集合框架之中,它为遍历集合对象元素
      	提供了便利。
     		
    方法:
      	boolean hasNext()判断后续元素是否存在。
      	E next()获得后续E类型元素。
      	void remove()删除迭代器返回的最后的一个元素。
    

    IterableAndIteratorTest01类(运用这两个接口来实现对象的迭代):

    package LessonForIterableAndIterator;
    
    import java.util.Iterator;
    
    class Game
    {
    	private String name;
    	
    	public Game(String name)
    	{
    		this.name = name;
    	}
    
    	public String getName() 
    	{
    		return name;
    	}
    }
    
    class GameShop implements Iterable<Game>
    {
    	private Game[] g ;
    	private int index = 0;
    	private int count = 0;
    	
    	public GameShop(int i)
    	{
    		g = new Game[i];
    	}
    	
    	public void setArray(Game g2)
    	{
    		g[count++] = g2;
    	}
    
    	@Override
    	public Iterator<Game> iterator() 
    	{
    		return new Iterator<Game>() 
    		{
    
    			@Override
    			public boolean hasNext() 
    			{
    				return (index != g.length);//没东西length = 0就返回false
    			}
    
    			@Override
    			public Game next() 
    			{
    				return g[index++];
    			}
    		};
    	}
    }
    
    class GameMarket 
    {
    	private Game[] g ;
    	private int count = 0;
    	
    	public GameMarket(int i)
    	{
    		g = new Game[i];
    	}
    	
    	public void setArray(Game g2)
    	{
    		g[count++] = g2;
    	}
    
    	public Game[] getG() 
    	{
    		return g;
    	}
    }
    
    public class IterableAndIteratorTest01 
    {
    	public static void main(String[] args) 
    	{
    		Game ge1 = new Game("Mario");//创建Game对象
    		Game ge2 = new Game("MHW");
    		
    		GameMarket gm1 = new GameMarket(2);
    		gm1.setArray(ge1);
    		gm1.setArray(ge2);
    		
    		for (Game g:gm1.getG())//得调用get方法才能遍历
    		{
    			System.out.println(g.getName());
    		}
    		
    		System.out.println("-------after used iterator-------");
    		
    		GameShop g1 = new GameShop(2);
    		g1.setArray(ge1);
    		g1.setArray(ge2);
    		
    		for (Game g:g1)//不用get方法也能遍历
    		{
    			System.out.println(g.getName());
    		}
    	}
    }
    
    
    本篇部分文字来源于:
    	咕嘟咖啡杨海滨老师 — 《java编程语言高级特性》
    	在这里十分感谢老师能够给我带来学习的激情。
    
    2020.10.28
    可以转载我的学习日记但请注明出处,谢谢。
    本文章是本人学习笔记,不进行任何商用!也请别拿去商用!只为记录本人学习历程。
    毕
    
    展开全文
  • 属于设计模式,提供了一个方法,对集合/容器内元素进行遍历,而不用关注底层实现细节,达到数据与上层遍历解耦目的.(解耦: 访问逻辑从不同类型集合类中抽取出来,接触两者间联合关系。) Iterator迭代器提供...
  • Gof说:提供一种方法顺序访问一个聚合对象中的各元素,而又不暴露该对象的内部表示。 关键思想是将对列表的访问和遍历从列表对象中分离出来,并放入一个迭代器(iterator)对象中。   示例:班级(Classes)是一个...
  • 迭代器模式(Iterator Pattern): 提供一种方法顺序访问一个聚合对象各个元素 , 而又不需暴露该对象内部表示。迭代器模式(Iterator Pattern)属于行为型模式。行为型模式涉及到算法和对象间职责分配;行为型模式...
  • 装饰模式,动态地给一个对象...概念:提供一种方法顺序访问一个聚合对象各个元素,而又不需暴露该对象内部表示。 main(),客户 IProject,产品接口 CProject,产品 IIterator,迭代器接口 IProjectIterator
  • 可迭代对象和迭代器解惑:可迭代对象:常见...且该方法可以返回一个迭代器对象,当用iter(可迭代对象)调用这个对象时,会返回一个迭代器对象(属于Iterator类)for语句原理就是先用iter函数获取可迭代对象迭代...
  • 在前面的例子,我们可以看到对String的to_alphanumeric的方法扩展。 那么对于一个对象而言,例如ArrayList,只要具有了add/remove/get/update/iterator等,具有添加/删除/修改/读取/遍历等等,我们就认为该对象...
  • 属于Java.util包。Collection是最基本的集合接口。由Collection接口派生的两个接口是List和Set。一、Listlist是有序的Collection,使用此接口能够精确地控制每个元素插入的位置,用户可使用索引来访问List中的元素...
  • 可迭代对象和迭代器解惑:可迭代对象:常见...且该方法可以返回一个迭代器对象,当用iter(可迭代对象)调用这个对象时,会返回一个迭代器对象(属于Iterator类)for语句原理就是先用iter函数获取可迭代对象迭代...
  • 可迭代对象和迭代器解惑:可迭代对象:常见能够...且该方法能够返回一个迭代器对象,当用iter(可迭代对象)调用这个对象时,会返回一个迭代器对象(属于Iterator类)pythonfor语句原理就是先用iter函数获取可迭...
  • 定义:定义一个用于创建对象的接口,让子类决定实例...Java Collection中的iterator() 方法属于这种情况。 第二种情况,创建对象的任务由多个具体子工厂中的某一个完成,而抽象工厂只提供创建产品的接口。 第三...
  • Collection是一个顶层接口,在集合类中还有Map也属于顶层接口(参考Java集合类之Map探究),本文通过一张类图描述List和Set基本结构。 类图解析: Collection是一个顶层接口,定义了一系列方法,...
  • 1.Java集实际上就属于动态对象数组 Collection接口:public boolean add(E e); 向集合添加数据 public Iterator iterator(); 取得iterator对象,用于集合输出 一般情况下会使用其子接口:List(允许数据重复) ...
  • 好了,这期开始介绍迭代器模式,组合模式和剩下的结构模式, 首先介绍迭代器+组合模式,虽然前者属于行为模式,后者属于...迭代器模式Iterator:提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露其内
  • 很多人对概念不清楚?...Collection接口有两个重要方法:add()、iterator()。子接口都有这两个方法。 2.List接口(Collection子接口) 在实际开发之,List接口使用频率可以达到Co...
  • JAVAScanner

    2011-04-10 20:41:03
    Scanner 接受任意类型的可输入对象 包括... Scanner属于Iterator接口类型 所以可以调用hasNext()与next()方法 当然Scanner 在其基础上又添加了几组其他的方法hasNextInt等等 其实质是先调用hasNext()方法 如果有...
  • 在java程序对foreach使用多见于集合类的遍历,foreach能够遍历集合是因为实现了iterable接口,其中定义了Iterator迭代器产生方法原代码大部分源自https://www.cnblogs.com/vinozly/p/5465454.html复制代码...
  • 关于List集合简介

    2019-05-19 23:26:56
    List属于Collection的一个子接口,list集合拥有collection集合所有的方法,List主要几个实现有ArrayList、Vector、LlinkedList,今天主要介绍这几个实现 List特点: 1、List是有序的collection,因此用户可以根据...
  • C++自动数据类型auto

    2020-08-28 15:40:41
    C++ STL 一些常常有一些方法或参数,属于特殊数据类型,而如果不知道其具体类型表示只知道如何调用其方法,那么数据接收可能会出现困难。 而C++自动数据类型判断auto可以完美解决这个问题,比如: //...
  • 迭代器模式 这种类型设计模式属于结构型模式,它调整了代码结构。 迭代器模式 是一种遍历模式 他通过抽象出一个通用遍历...具体遍历实现iterator接口具体实现目标类的遍历方法 目标提供调用方法来进行遍历...
  • 迭代器模式

    2018-01-10 20:43:05
    提供一种方法访问一个容器中的各个元素,而又不暴露该对象的内部细节。 属于行为模式 迭代器模式也是使用较多的一种模式。 遍历集合时,就必须先获得集合的iterator迭代器再遍历。这里的iterator属于迭代器模式 ...
  • 它提供一种方法顺序访问一个聚合对象各个元素,而又不暴露该对象内部表示。 类图: Iterator(迭代器接口):定义、访问和遍历元素接口 ConcreteIterator(具体迭代器):实现迭代器接口,并记录遍历...
  • Java双列集合HashMap

    2020-12-22 17:16:36
    双列集合HashMap是属于java集合框架3大接口的Map, Map接口储存一组成对的键-值对象,提供key(键)到value(值)的映射.Map中的key不要求有序,不允许重复.value同样不要求有序,但允许重复.  Iterator接口是...
  • JAVA基础知识|集合

    2018-04-19 16:48:00
    Map接口:和Collection接口没有直接的关系,但都属于集合类中的一部分。 Iterator接口:所有的集合类都实现了Iterator接口,这是一个用于遍历集合中元素的接口,主要包含三个方法:hasNext()、next()、remove()。 ...
  • 迭代器模式(Iterator),提供-种方法顺序访问一个聚合对象各个元素,而又不暴露该对象内部表示。[DP]属于行为型模式之一。 Aggregate: 抽象集合 Iterator(迭代器接口): 该接口必须定义实现迭代功能最小...
  • 主要解决:提供一种方法顺序访问一个聚合对象各个元素, 而又无须暴露该对象内部表示。 优点: 1、它支持以不同方式遍历一个聚合对象。 2、迭代器简化了聚合。 3、在同一个聚合上可以有多个遍历。 ...
  • 迭代器模式-提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露其内部的表示。 模式结构和定义 我们将创建一个叙述导航方法Iterator 接口和一个返回迭代器的 Container 接口。实现了 Container 接口的...

空空如也

空空如也

1 2 3
收藏数 59
精华内容 23
热门标签
关键字:

属于iterator类中的方法