Home | History | Annotate | Download | only in DefaultMethods
      1 /*
      2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  *
      8  *   - Redistributions of source code must retain the above copyright
      9  *     notice, this list of conditions and the following disclaimer.
     10  *
     11  *   - Redistributions in binary form must reproduce the above copyright
     12  *     notice, this list of conditions and the following disclaimer in the
     13  *     documentation and/or other materials provided with the distribution.
     14  *
     15  *   - Neither the name of Oracle nor the names of its
     16  *     contributors may be used to endorse or promote products derived
     17  *     from this software without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
     20  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
     21  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
     27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
     28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 import java.util.Iterator;
     33 import java.util.NoSuchElementException;
     34 
     35 /**
     36  * The code sample illustrates the usage of default methods in the JDK 8. Most
     37  * implementations of {@link Iterator} don't provide a useful
     38  * {@link Iterator#remove()} method, however,
     39  * they still have to implement this method to throw
     40  * an UnsupportedOperationException. With the default method, the same
     41  * default behavior in interface Iterator itself can be provided.
     42  */
     43 public class ArrayIterator {
     44 
     45     /** Close the constructor because ArrayIterator is part of the utility
     46      * class.
     47      */
     48     protected ArrayIterator() {
     49         throw new UnsupportedOperationException();
     50     }
     51 
     52     /**
     53      * Returns an iterator that goes over the elements in the array.
     54      *
     55      * @param <E> type of an array element
     56      * @param array source array to iterate over it
     57      * @return an iterator that goes over the elements in the array
     58      */
     59     public static <E> Iterator<E> iterator(final E[] array) {
     60         return new Iterator<E>() {
     61             /**
     62              * Index of the current position
     63              *
     64              */
     65             private int index = 0;
     66 
     67             /**
     68              * Returns the next element in the iteration
     69              *
     70              * @return the next element in the iteration
     71              * @throws NoSuchElementException if the iteration has no more
     72              * elements
     73              */
     74             @Override
     75             public boolean hasNext() {
     76                 return (index < array.length);
     77             }
     78 
     79             /**
     80              * Returns {@code true} if the iteration has more elements. (In
     81              * other words, returns {@code true} if {@link #next} returns
     82              * an element, rather than throwing an exception.)
     83              *
     84              * @return {@code true} if the iteration has more elements
     85              */
     86             @Override
     87             public E next() {
     88                 if (!hasNext()) {
     89                     throw new NoSuchElementException();
     90                 }
     91                 return array[index++];
     92             }
     93 
     94             /**
     95              * This method does not need to be overwritten in JDK 8.
     96              */
     97             //@Override
     98             //public void remove() {
     99             //    throw UnsupportedOperationException(
    100             //            "Arrays don't support remove.")
    101             //}
    102         };
    103     }
    104 
    105     /**
    106      * Sample usage of the ArrayIterator
    107      *
    108      * @param args command-line arguments
    109      */
    110     public static void main(final String[] args) {
    111         Iterator<String> it = ArrayIterator.iterator(
    112                 new String[]{"one", "two", "three"});
    113 
    114         while (it.hasNext()) {
    115             System.out.println(it.next());
    116         }
    117     }
    118 }
    119