Getting previous element in Enumaration

[Jayasri kurra]

Hi Friends,

How to get previous element in Enumaration.
Thanks,

[Stuart A. Burkett]

You can't. If you need access to the previous element then you need to declare a variable and point this to the current value before you call the next() method.

[John Vorwald]

You could use the ordinal method.

public class EnumNextPrevious {
    
    public static void main(String[] args) {
        Planet p = Planet.EARTH;
        System.out.println("Planet: "+p.toString());
        System.out.println("Previous planet: "+p.getPrevious().toString());
        System.out.println("Next planet: "+p.getNext().toString());
    }
    
    enum Planet {
            MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE;
            public Planet getNext() {
            return values()[(ordinal()+1) % values().length];
            }
            public Planet getPrevious() {
            return values()[(ordinal()-1) % values().length];
            }
    }
    
}

[Jeff Verdegan]

Stuart A. Burkett wrote:You can't.

John Vorwald wrote:You could use the ordinal method.

That depends on whether the OP is talking about an Enumeration or an Enum (enum). Given that he said "Enumeration" and is asking about the "previous element," my money is on Enumeration.

[Jeff Verdegan]

Jayasri kurra wrote:How to get previous element in Enumaration.

Why do you want to? And why are you using Enumeration in the first place? If you tell us WhatNotHow(←click), (that is, what are you trying to accomplish--going backwards with an Enumeration is just how you're trying to do it) someone can probably advise a better approach to attain your actual goal.

[John Vorwald]

Let's see

Enumeration: a predefined interface that tests for more elements and accesses the next element.

And the question is can Enumeration have previousElement();

Is it satisfactory to extend Enumeration? i.e.

    public interface NewEnumeration<E> extends Enumeration<E> {
        public E previousElement();
    }

Maybe something like

import java.util.Enumeration;
import java.util.LinkedList;
import java.util.ListIterator;

public class EnumerationPrev {
    
    public static void main(String[] args) {
        TestNew<DataObject> t = new TestNew<DataObject>();
        t.add(new DataObject(1, 3, 5));
        t.add(new DataObject(2, 7, 8));
        t.add(new DataObject(4, 0, 10));
        t.add(new DataObject(6, 31, 511));
        
        ListIterator<DataObject> iterator = t.listIterator();
        
        System.out.println("Iterating through elements of in forward direction...");
        while (iterator.hasNext()) {
            DataObject d = iterator.next();
            System.out.println(d);
        }
        
        System.out
                .println("Iterating through elements in reverse direction...");
        while (iterator.hasPrevious()) {
            DataObject d = iterator.previous();
            System.out.println(d);
        }
        
    }
    
}

class TestNew<E> implements NewEnumeration<E> {
    
    LinkedList<E> list;
    
    public TestNew() {
        super();
        list = new LinkedList<E>();
    }
    
    public ListIterator<E> listIterator() {
        ListIterator<E> iter = list.listIterator();
        return iter;
    }

    public boolean hasMoreElements() {
        boolean isEmpty = list.isEmpty();
        return !isEmpty;
    }
    
    public E nextElement() {
        return iter.next();
    }
    
    public E previousElement() {
        return iter.previous();
    }
    
    public boolean add(E e) {
        
        return list.add(e);
    }
    
}

interface NewEnumeration<E> extends Enumeration<E> {
    public E previousElement();
}

class DataObject {
    final int i;
    final double x, y;
    
    public DataObject(int aI, double aX, double aY) {
        super();
        i = aI;
        x = aX;
        y = aY;
    }

    @Override
    public String toString() {
        return "DataObject [i=" + i + ", (x, y)=(" + x + ", " + y + ")";
    }
    
}

produces output

Iterating through elements of in forward direction...
DataObject [i=1, (x, y)=(3.0, 5.0)
DataObject [i=2, (x, y)=(7.0, 8.0)
DataObject [i=4, (x, y)=(0.0, 10.0)
DataObject [i=6, (x, y)=(31.0, 511.0)
Iterating through elements in reverse direction...
DataObject [i=6, (x, y)=(31.0, 511.0)
DataObject [i=4, (x, y)=(0.0, 10.0)
DataObject [i=2, (x, y)=(7.0, 8.0)
DataObject [i=1, (x, y)=(3.0, 5.0)

[John Vorwald]

Jeff Verdegan wrote:

Stuart A. Burkett wrote:You can't.

John Vorwald wrote:You could use the ordinal method.

That depends on whether the OP is talking about an Enumeration or an Enum (enum). Given that he said "Enumeration" and is asking about the "previous element," my money is on Enumeration.

Appears I need to read the question more carefully.... in order to avoid the dreaded "mouth in gear before brain is engaged" syndrome

[Stuart A. Burkett]

Ignore. Seems I was talking rubbish.

[Jeff Verdegan]

Stuart A. Burkett wrote:ListIterator class doesn't have hasPrevious or previous methods.

Not sure what ListIterator class you're talking about, but the java.util.ListIterator interface has

hasPrevious() and previous().

[Stuart A. Burkett]

Jeff Verdegan wrote:Not sure what ListIterator class you're talking about

Neither do I Ignore that post.

[Jeff Verdegan]

Now we just need to hear back from the OP as to what he's actually trying to accomplish and why getting the previous element in an Enumeration is a solution to that problem.

[Ranu Gokhe]

public Planet getPrevious() {
           return values()[(values().length + (ordinal() -1)) % values().length];
       }

[Campbell Ritchie]

Welcome to the Ranch

That code appears to be the solution to a different question.
[edit]I see what has happened. You have interpreted the question as being about enumerated types, and used the values() array, whereas the original question was about the Enumeration interface, which I think is obsolete anyway.