{"id":2970,"date":"2024-01-19T16:05:43","date_gmt":"2024-01-19T16:05:43","guid":{"rendered":"https:\/\/msgprogramator.sk\/?p=2970"},"modified":"2025-07-07T10:57:23","modified_gmt":"2025-07-07T10:57:23","slug":"java-iterator","status":"publish","type":"post","link":"https:\/\/msgprogramator.sk\/en\/java-iterator\/","title":{"rendered":"Java design pattern Iterator"},"content":{"rendered":"

Today we will look at another Java<\/strong> design pattern<\/strong> from the category of behavioural patterns<\/strong> – Iterator. Design patterns in this category deal with the interaction<\/strong> between objects and their responsibility<\/strong>.<\/p>\n

What is the Iterator design pattern?<\/h2>\n

The Iterator design pattern in object-oriented programming provides a way to systematically access and traverse the elements of an object stored in a container without knowing its internal representation. It also separates the algorithms that apply to the elements from the container.<\/p>\n

What problem does the Iterator design pattern solve?<\/h2>\n

It solves the problem of efficiently accessing items in a collection while hiding the structure of that collection. Its main goal is to provide a consistent way to navigate through different types of collections without having to know their internal structure. <\/p>\n

This pattern defines the Iterator interface, which by default includes methods such as next()<\/em>, hasNext()<\/em>, etc. Specific implementations of this interface are provided by classes that implement collections, such as lists, sets, arrays, and so on.<\/p>\n

Example of an Iterator implementation in Java<\/h2>\n

We’ll create a program to add notes and use the Iterator<\/strong> design pattern to show how we can easily access and navigate through them. We will create the interface as a template so that it can be used for any data type.<\/p>\n

Iterator.java<\/u><\/strong><\/p>\n

package designpatterns;\n\n\/\/ Rozhranie pre iterator\npublic interface Iterator<T> {\n    boolean hasNext();\n    T next();\n}<\/code><\/pre>\n
The Iterator <\/strong> interface defines the methods hasNext()<\/em> and next()<\/em>. The first method should check if there is another element, the second should then return the next element. <\/p>\n
ListIterator.java<\/u><\/strong><\/p>\n
package designpatterns;\n\nimport java.util.List;\n\n\/\/ Konkretny iterator pre zoznam (List)\npublic class ListIterator<T> implements Iterator<T> {\n    private List<T> zoznam;\n    private int pozicia;\n\n    public ListIterator(List<T> zoznam) {\n        this.zoznam = zoznam;\n        this.pozicia = 0;\n    }\n\n    @Override\n    public boolean hasNext() {\n        return pozicia < zoznam.size();\n    }\n\n    @Override\n    public T next() {\n        if(this.hasNext())\n            return zoznam.get(pozicia++);\n        return null;\n    }\n}<\/code><\/pre>\n
ListIterator<\/strong> implements the Iterator<\/strong> interface and provides a concrete implementation for List. It holds a reference to the list (List<T>) and keeps track of the current position for the iteration. The hasNext()<\/em> method checks if there is another element in the list. The next()<\/em> method returns the next element in the list and moves the position to the next element.<\/p>\n
Notes.java<\/u><\/strong><\/p>\n
package designpatterns;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\npublic class Poznamky<T> {\n    private List<T> poznamky;\n    public Poznamky() {\n        this.poznamky = new ArrayList<>();\n    }\n\n    public void pridajPoznamku(T poznamka) {\n        poznamky.add(poznamka);\n    }\n\n    public Iterator<T> iterator() {\n        return new ListIterator<>(poznamky);\n    }\n}<\/code><\/pre>\n
The Notes <\/strong> class stores a list of notes (in this case of type T). The addNote()<\/em> method adds a new note to the list. The iterator()<\/em> method creates and returns a ListIterator <\/strong> instance, which is used to iterate over the notes in the list.  <\/p>\n
Main.java<\/u><\/strong><\/p>\n
import designpatterns.Iterator;\nimport designpatterns.Poznamky;\n\npublic class Main {\n    public static void main(String[] args) {\n        Poznamky<String> poznamky = new Poznamky<>();\n        poznamky.pridajPoznamku("Zajtra bude sne\u017ei\u0165.");\n        poznamky.pridajPoznamku("\u010coskoro bud\u00fa Vianoce.");\n        poznamky.pridajPoznamku("Treba nak\u00fapi\u0165 dar\u010deky.");\n        \/\/ Pouzitie iteratora na prechadzanie cez pridane poznamky\n        Iterator<String> iterator = poznamky.iterator();\n        while(iterator.hasNext()) {\n            System.out.println(iterator.next());\n        }\n    }\n}<\/code><\/pre>\n
Main<\/strong> is a client class that demonstrates the use of this design pattern. It creates a Notes <\/strong> instance of a given string <\/strong> type, adds some notes, iterates over them and prints them using the iterator.<\/p>\n
The output from this example is:<\/p>\n
\"Main<\/p>\n
Conclusion<\/h2>\n
The Iterator<\/strong> design pattern is used by default to iterate over a group of objects in a data structure, regardless of the specific object type. This pattern is so common that there are predefined classes in programming languages. Iterators do not have to traverse only to the next object, but can be implemented to traverse width or depth in a tree structure, for example.  <\/p>\n
We have prepared the files with the above example in the form of code that you can run directly in Java. ou can download the Java Iterator <\/strong> code here<\/a>.<\/p>\n
If you’re a Java developer<\/a> looking for work, check out our employee benefits<\/a> and respond to our job offers<\/a>!<\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
What is the Java Iterator design pattern and what is it for? Read our new article and download the sample code.<\/p>\n","protected":false},"author":14,"featured_media":2545,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[57],"tags":[],"class_list":["post-2970","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java"],"acf":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/posts\/2970","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/users\/14"}],"replies":[{"embeddable":true,"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/comments?post=2970"}],"version-history":[{"count":5,"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/posts\/2970\/revisions"}],"predecessor-version":[{"id":5266,"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/posts\/2970\/revisions\/5266"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/media\/2545"}],"wp:attachment":[{"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/media?parent=2970"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/categories?post=2970"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/msgprogramator.sk\/en\/wp-json\/wp\/v2\/tags?post=2970"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}