How can you enumerate an `enum` in C#?

E.g. the following code does not compile:

&lt;!-- language: lang-cs --&gt;

    public enum Suit
    {
        Spades,
        Hearts,
        Clubs,
        Diamonds
    }

    public void EnumerateAllSuitsDemoMethod()
    {
        foreach (Suit suit in Suit)
        {
            DoSomething(suit);
        }
    }

And it gives the following compile-time error:

&lt;!-- language: lang-none --&gt;

   &gt; &#39;Suit&#39; is a &#39;type&#39; but is used like a &#39;variable&#39;

It fails on the `Suit` keyword, the second one.


How to enumerate an enum

In vs2008, is it possible to write an extension methods which would apply to any enumeration.

I know you can write extension methods against a specific enumeration, but I want to be able to every enumeration using a single extension method. Is this possible?

Enumeration extension methods

I know that PHP doesn&#39;t yet have native Enumerations. But I have become accustomed to them from the Java world. I would love to use enums as a way to give predefined values which IDEs&#39; auto-completion features could understand.

Constants do the trick, but there&#39;s the namespace collision problem and (or actually *because*) they&#39;re global. Arrays don&#39;t have the namespace problem, but they&#39;re too vague, they can be overwritten at runtime and IDEs rarely know how to autofill their keys without additional static analysis annotations or attributes.

Are there any solutions/workarounds you commonly use? Does anyone recall whether the PHP guys have had any thoughts or decisions around enumerations?

Enumerations on PHP

I have a simple collections question. I have a [`Set&lt;String&gt;`][1] object. I want an [`Enumeration&lt;String&gt;`][2] of the `String`s in that `Set`. I need an `Enumeration&lt;String&gt;` since I am overriding a method that specifically returns an `Enumeration&lt;String&gt;`. What is the cleanest/best way to go about it?


  [1]: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html
  [2]: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Enumeration.html

Java: Enumeration from Set&lt;String&gt;

I am finding some difficulty in accessing mutable dictionary keys and values in Objective-C.

Suppose I have this:

    NSMutableDictionary *xyz=[[NSMutableDictionary alloc] init];

I can set keys and values. Now, I just want to access each key and value, but I don&#39;t know the number of keys set.

In PHP it is very easy, something as follows:

    foreach ($xyz as $key =&gt; $value)

How is it possible in Objective-C?
 

for each loop in Objective-C for accessing NSMutable dictionary

I&#39;m new to programming. Can someone explain what `.map` would do in:

    params = (0...param_count).map



What does the &quot;map&quot; method do in Ruby?

Are there any best-practice guidelines on when to use [case classes][1] (or case objects) vs extending Enumeration in Scala?

They seem to offer some of the same benefits.

  [1]: http://en.wikipedia.org/wiki/Scala_%28programming_language%29#Case_classes_and_pattern_matching


Case objects vs Enumerations in Scala

Is there a function that I can use to iterate over an array and have both index and element, like Python&#39;s `enumerate`?

    for index, element in enumerate(list):
        ...


How to iterate a loop with index and element in Swift

If I have an enumeration with raw `Integer` values:

    enum City: Int {
      case Melbourne = 1, Chelyabinsk, Bursa
    }

    let city = City.Melbourne

How can I convert a `city` value to a string `Melbourne`? Is this kind of a type name introspection available in the language?

Something like (this code will not work):

    println(&quot;Your city is \(city.magicFunction)&quot;)
    &gt; Your city is Melbourne

How to get the name of enumeration value in Swift?

In Java, it&#39;s possible to have methods inside an enum.

Is there such possibility in C# or is it just a string collection and that&#39;s it?

I tried to override `ToString()` but it does not compile. Does someone have a simple code sample?

Methods inside enum in C#

There are apparently many ways to iterate over a collection. Curious if there are any differences, or why you&#39;d use one way over the other.

First type:

    List&lt;string&gt; someList = &lt;some way to init&gt;
    foreach(string s in someList) {
       &lt;process the string&gt;
    }

Other Way:

    List&lt;string&gt; someList = &lt;some way to init&gt;
    someList.ForEach(delegate(string s) {
        &lt;process the string&gt;
    });

I suppose off the top of my head, that instead of the anonymous delegate I use above, you&#39;d have a reusable delegate you could specify...

foreach vs someList.ForEach(){}

In a C# (feel free to answer for other languages) loop, what&#39;s the difference between `break` and `continue` as a means to leave the structure of the loop, and go to the next iteration?

Example:

    foreach (DataRow row in myTable.Rows)
    {
        if (someConditionEvalsToTrue)
        {
            break; //what&#39;s the difference between this and continue ?
            //continue;
        }
    }

C# loop - break vs. continue

I have an enumeration:

    public enum MyColours
    {
        Red,
        Green,
        Blue,
        Yellow,
        Fuchsia,
        Aqua,
        Orange
    }

and I have a string:

    string colour = &quot;Red&quot;;

I want to be able to return:

    MyColours.Red

from:

    public MyColours GetColour(string colour)

------------
So far i have:

    public MyColours GetColours(string colour)
    {
        string[] colours = Enum.GetNames(typeof(MyColours));
        int[]    values  = Enum.GetValues(typeof(MyColours));
        int i;
        for(int i = 0; i &lt; colours.Length; i++)
        {
            if(colour.Equals(colours[i], StringComparison.Ordinal)
                break;
        }
        int value = values[i];
        // I know all the information about the matched enumeration
        // but how do i convert this information into returning a
        // MyColour enumeration?
    }

As you can see, I&#39;m a bit stuck.  Is there anyway to select an enumerator by value.  Something like:

    MyColour(2) 

would result in

    MyColour.Green

Search for a string in Enum and return the Enum

I&#39;m always surprised that even after using C# for all this time now, I still manage to find things I didn&#39;t know about...

I&#39;ve tried searching the internet for this, but using the &quot;~&quot; in a search isn&#39;t working for me so well and I didn&#39;t find anything on MSDN either (not to say it isn&#39;t there)

I saw this snippet of code recently, what does the tilde(~) mean?

    /// &lt;summary&gt;
    /// Enumerates the ways a customer may purchase goods.
    /// &lt;/summary&gt;
    [Flags]
    public enum PurchaseMethod
    {	
        All = ~0,
        None =  0,
        Cash =  1,
        Check =  2,
        CreditCard =  4
    }

I was a little surprised to see it so I tried to compile it, and it worked... but I still don&#39;t know what it means/does. Any help??

What is the tilde (~) in the enum definition?

Consider:

    using System;

    public class Test
    {
        enum State : sbyte { OK = 0, BUG = -1 }

        static void Main(string[] args)
        {
            var s = new State[1, 1];
            s[0, 0] = State.BUG;
            State a = s[0, 0];
            Console.WriteLine(a == s[0, 0]); // False
        }
    }

How can this be explained? It occurs in debug builds in Visual Studio 2015 when running in the x86 JIT. A release build or running in the x64 JIT prints True as expected.

To reproduce from the command line:

    csc Test.cs /platform:x86 /debug

(`/debug:pdbonly`, `/debug:portable` and `/debug:full` also reproduce.)


Why is the enumeration value from a multi dimensional array not equal to itself?

Are there any standard methods to get `Enumeration names by value?`

An example:

    class Example(enum.Enum):
        one = 1
        two = 2

    ex_variable = 1

Given `ex_variable`, can I obtain the string contained in Example.one.name?

Get enumeration name by value

What is the exact difference between these two interfaces? Does [`Enumeration`](http://docs.oracle.com/javase/7/docs/api/java/util/Enumeration.html) have benefits over using [`Iterator`](http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html)?  If anyone could elaborate, a reference article would be appreciated.

Difference between Java Enumeration and Iterator

A colleague of mine states that **booleans as method arguments are not acceptable**. They shall be replaced by enumerations. At first I did not see any benefit, but he gave me an example.

What&#39;s easier to understand?

    file.writeData( data, true );

Or

    enum WriteMode {
      Append,
      Overwrite
    };
    
    file.writeData( data, Append );

Now I got it! ;-)  
This is definitely an example where an enumeration as second parameter makes the code much more readable.

So, what&#39;s your opinion on this topic?


Are booleans as method arguments unacceptable?

I would like to declare an enum Direction, that has a method that returns the opposite direction (the following is not syntactically correct, i.e, enums cannot be instantiated, but it illustrates my point). Is this possible in Java?

Here is the code: 

    public enum Direction {

         NORTH(1),
         SOUTH(-1),
         EAST(-2),
         WEST(2);

         Direction(int code){
              this.code=code;
         }
         protected int code;
         public int getCode() {
               return this.code;
         }
         static Direction getOppositeDirection(Direction d){
               return new Direction(d.getCode() * -1);
         }
    }

Java Enum Methods - return opposite direction enum

Do you use singular or plural for enumerations? I think it makes best sense with plural in the declaration

    enum Weekdays
    {
        Monday,
        Tuesday,
        Wednesday,
        Thursday,
        Friday,
        Saturday,
        Sunday
    }

... but I think it makes more sense with singular when using the type, e.g.

    Weekday firstDayOfWeek = Weekday.Monday;

I read a recommendation somewhere to use singular whith regular enums and plural with flags, but I would like to hear some more pros and cons.

Singular or plural for enumerations?

I&#39;m looking to see if there is an official enumeration for months in the .net framework.

It seems possible to me that there is one, because of how common the use of month is, and because there are other such enumerations in the .net framework.

For instance, there is an enumeration for the days in the week, System.DayOfWeek, which includes Monday, Tuesday, etc..

I&#39;m wondering if there is one for the months in the year, i.e. January, February, etc?

Does anyone know?

Is there a predefined enumeration for Month in the .NET library?

This question came to my mind, when I had something like

    enum Folders {FA, FB, FC};
and wanted to create an array of containers for each folder:

    ContainerClass*m_containers[3];
    ....
    m_containers[FA] = ...; // etc.
(Using maps it&#39;s much more elegant to use: `std::map&lt;Folders, ContainerClass*&gt; m_containers;`)

But to come back to my original question: What if I do not want to hard-code the array size, is there a way to figure out how many items are in Folders? (Without relying on e.g. `FC` being the last item in the list which would allow something like `ContainerClass*m_containers[FC+1]` if I&#39;m not mistaken.)

(How) can I count the items in an enum?

I have the classic case of trying to remove an item from a collection while enumerating it in a loop:

    List&lt;int&gt; myIntCollection = new List&lt;int&gt;();
    myIntCollection.Add(42);
    myIntCollection.Add(12);
    myIntCollection.Add(96);
    myIntCollection.Add(25);
    
    foreach (int i in myIntCollection)
    {
        if (i == 42)
            myIntCollection.Remove(96);    // The error is here.
        if (i == 25)
            myIntCollection.Remove(42);    // The error is here.
    }

At the beginning of the iteration after a change takes place, an `InvalidOperationException` is thrown, because enumerators don’t like when the underlying collection changes.

I need to make changes to the collection while iterating. There are many **patterns that can be used to avoid this**, but none of them seems to have a good solution:

 1. Do not delete inside this loop, instead keep a separate “Delete List”, that you process after the main loop.  
    
    This is normally a good solution, but in my case, I need the item to be gone instantly as “waiting” till after 
the main loop to really delete the item changes the logic flow of my code.

 2. Instead of deleting the item, simply set a flag on the item and mark it as inactive. Then add the functionality of pattern 1 to clean up the list.  
    
    This *would* work for all of my needs, but it means that a *lot* of code will have to change in order to check the inactive flag every time an item is accessed. This is far too much administration for my liking.

 3. Somehow incorporate the ideas of pattern 2 in a class that derives from `List&lt;T&gt;`. This Superlist will handle the inactive flag, the deletion of objects after the fact and also will not expose items marked as inactive to enumeration consumers. Basically, it just encapsulates all the ideas of pattern 2 (and subsequently pattern 1).  
    
    Does a class like this exist? Does anyone have code for this? Or is there a better way?

 4. I’ve been told that accessing `myIntCollection.ToArray()` instead of `myIntCollection` will solve the problem and allow me to delete inside the loop.  
    
    This seems like a bad design pattern to me, or maybe it’s fine?

Details:

  * The list will contain many items and I will be removing only some of them.

  * Inside the loop, I will be doing all sorts of processes, adding, removing etc., so the solution needs to be fairly generic.

  * The item that I need to delete *may not* be the current item in the loop. For example, I may be on item 10 of a 30 item loop and need to remove item 6 or item 26. Walking backwards through the array will no longer work because of this. ;o(

Intelligent way of removing items from a List&lt;T&gt; while enumerating in C#

A new feature in C# / .NET 4.0 is that you can change your enumerable in a `foreach` without getting the exception. See Paul Jackson&#39;s blog entry *[An Interesting Side-Effect of Concurrency: Removing Items from a Collection While Enumerating][1]* for information on this change.

What is the best way to do the following?

    foreach(var item in Enumerable)
    {
        foreach(var item2 in item.Enumerable)
        {
            item.Add(new item2)
        }
    }

Usually I use an `IList` as a cache/buffer until the end of the `foreach`, but is there better way?

  [1]: https://web.archive.org/web/20160308065012/www.lovethedot.net/2009/03/interesting-side-effect-of-concurrency.html

What is the best way to modify a list in a &#39;foreach&#39; loop?

I&#39;m trying to find a way to iterate through an enum&#39;s values while using generics.  Not sure how to do this or if it is possible.  

The following code illustrates what I want to do. Note that the code **T.values()** is not valid in the following code.

    public class Filter&lt;T&gt; {
    	private List&lt;T&gt; availableOptions = new ArrayList&lt;T&gt;();
    	private T selectedOption;
    
    	public Filter(T selectedOption) {
    		this.selectedOption = selectedOption;
    		for (T option : T.values()) {  // INVALID CODE
    			availableOptions.add(option);
    		}
    	}
    }

Here is how I would instantiate a Filter object:

    Filter&lt;TimePeriod&gt; filter = new Filter&lt;TimePeriod&gt;(TimePeriod.ALL);

The enum is defined as follows:

    public enum TimePeriod {
    	ALL(&quot;All&quot;), 
    	FUTURE(&quot;Future&quot;), 
    	NEXT7DAYS(&quot;Next 7 Days&quot;), 
    	NEXT14DAYS(&quot;Next 14 Days&quot;), 
    	NEXT30DAYS(&quot;Next 30 Days&quot;), 
    	PAST(&quot;Past&quot;),
    	LAST7DAYS(&quot;Last 7 Days&quot;), 
    	LAST14DAYS(&quot;Last 14 Days&quot;),
    	LAST30DAYS(&quot;Last 30 Days&quot;); 
    
    	private final String name;
    	
    	private TimePeriod(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public String toString() {
    		return name;
    	}
    }

I realize it might not make sense to copy a enum&#39;s values to a list, but I&#39;m using a library that needs a list of values as input and won&#39;t work with enums.

---

EDIT 2/5/2010:

Most of the answers proposed are very similar and suggest doing something like this:

    class Filter&lt;T extends Enum&lt;T&gt;&gt; {
        private List&lt;T&gt; availableOptions = new ArrayList&lt;T&gt;();
        private T selectedOption;
    
        public Filter(T selectedOption) {
            Class&lt;T&gt; clazz = (Class&lt;T&gt;) selectedOption.getClass();
            for (T option : clazz.getEnumConstants()) {
                availableOptions.add(option);
            }
        }
    }

This would work great if I can be sure that selectedOption has a non-null value.  Unfortunately, in my use case, this value is often null, as there is a **public Filter()** no-arg constructor as well. This means I can&#39;t do a selectedOption.getClass() without getting an NPE.  This filter class manages a list of available options which of the options is selected. When nothing is selected, selectedOption is null.

The only thing I can think to solve this is to actually pass in a Class&lt;T&gt; in the constructor.  So something like this:

    class Filter&lt;T extends Enum&lt;T&gt;&gt; {
        private List&lt;T&gt; availableOptions = new ArrayList&lt;T&gt;();
        private T selectedOption;

        public Filter(Class&lt;T&gt; clazz) {
            this(clazz,null);
        }
    
        public Filter(Class&lt;T&gt; clazz, T selectedOption) {
            this.selectedOption = selectedOption;
            for (T option : clazz.getEnumConstants()) {
                availableOptions.add(option);
            }
        }
    }

Any ideas how to do this without needing an extra Class&lt;T&gt; parameter in the constructors?






Iterate enum values using java generics

I&#39;m looking for the standard idiom to iterate over an NSArray. My code needs to be suitable for OS X 10.4+.

How do I iterate over an NSArray?

I&#39;ve been using `enumerateObjectsUsingBlock:` a lot lately for my fast-enumeration needs, and I&#39;m having a hard time understanding the usage of `BOOL *stop` in the enumeration block.

The `NSArray` class reference states

&gt; `stop`: A reference to a Boolean value. The block can set the value to `YES` to
&gt; stop further processing of the array. The `stop` argument is an out-only
&gt; argument. You should only ever set this Boolean to `YES` within the
&gt; Block.

So then of course I can add the following in my block to stop the enumeration:


    if (idx == [myArray indexOfObject:[myArray lastObject]]) {
        *stop = YES;
    }

From what I&#39;ve been able to tell, not explicitly setting `*stop` to `YES` doesn&#39;t have any negative side effects. The enumeration seems to automatically stop itself at the end of the array. So is using `*stop` really necessary in a block?

What is the BOOL *stop argument for enumerateObjectsUsingBlock: used for?

I want to enumerate through an array in Swift, and remove certain items. I&#39;m wondering if this is safe to do, and if not, how I&#39;m supposed to achieve this.

Currently, I&#39;d be doing this:

    for (index, aString: String) in enumerate(array) {
        //Some of the strings...
        array.removeAtIndex(index)
    }

Removing from array during enumeration in Swift?

A friend asked me last week how to enumerate or list all variables within a program/function/etc. for the purposes of debugging (essentially getting a snapshot of everything so you can see what variables are set to, or if they are set at all). I looked around a bit and found a relatively good way for Python:

&lt;pre&gt;
#!/usr/bin/python                                                                                                                                                                                                                           
foo1 = &quot;Hello world&quot;
foo2 = &quot;bar&quot;
foo3 = {&quot;1&quot;:&quot;a&quot;,
        &quot;2&quot;:&quot;b&quot;}
foo4 = &quot;1+1&quot;

for name in dir():
    myvalue = eval(name)
    print name, &quot;is&quot;, type(name), &quot;and is equal to &quot;, myvalue
&lt;/pre&gt;

which will output something like:

&lt;pre&gt;
__builtins__ is &amp;lt;type &#39;str&#39;&amp;gt; and is equal to  &amp;lt;module &#39;__builtin__&#39; (built-in)&amp;gt;
__doc__ is &amp;lt;type &#39;str&#39;&amp;gt; and is equal to  None
__file__ is &amp;lt;type &#39;str&#39;&amp;gt; and is equal to  ./foo.py
__name__ is &amp;lt;type &#39;str&#39;&amp;gt; and is equal to  __main__
foo1 is &amp;lt;type &#39;str&#39;&amp;gt; and is equal to  Hello world
foo2 is &amp;lt;type &#39;str&#39;&amp;gt; and is equal to  bar
foo3 is &amp;lt;type &#39;str&#39;&amp;gt; and is equal to  {&#39;1&#39;: &#39;a&#39;, &#39;2&#39;: &#39;b&#39;}
foo4 is &amp;lt;type &#39;str&#39;&amp;gt; and is equal to  1+1
&lt;/pre&gt;

I have so far found a partial way in PHP (courtesy of [link text][1]) but it only lists all variables and their types, not the contents:

&lt;pre&gt;
&amp;lt;?php
// create a few variables
$bar = &#39;foo&#39;;
$foo =&#39;bar&#39;;
// create a new array object
$arrayObj = new ArrayObject(get_defined_vars());
// loop over the array object and echo variables and values
for($iterator = $arrayObj-&amp;gt;getIterator(); $iterator-&amp;gt;valid(); $iterator-&amp;gt;next())
        {
        echo $iterator-&amp;gt;key() . &#39; =&amp;gt; &#39; . $iterator-&amp;gt;current() . &#39;&amp;lt;br /&amp;gt;&#39;;
        }
?&amp;gt;
&lt;/pre&gt;

**So I put it to you: how do you list all variables and their contents in your favorite language?**

-------

Edit by [VonC][2]: I propose this question follows the spirit of a little &quot;[code-challenge][3]&quot;.  
If you do not agree, just edit and remove the tag and the link.


  [1]: http://www.phpro.org/examples/List-all-variables.html
  [2]: https://stackoverflow.com/users/6309/vonc
  [3]: https://stackoverflow.com/questions/172184

Enumerate or list all variables in a program of [your favorite language here]

An interview question for a .NET 3.5 job is &quot;What is the difference between an iterator and an enumerator&quot;?

This is a core distinction to make, what with LINQ, etc.

Anyway, what is the difference? I can&#39;t seem to find a solid definition on the net. Make no mistake, I can find the meaning of the two terms but I get slightly different answers. What would be the best answer for an interview?

IMO an iterator &quot;iterates&quot; over a collection, and an enumerator provides the functionality to iterate, but this has to be called.

Also, using the yield keyword is said to save state. What exactly is this state? Is there an example of this benefit occurring?

Distinction between iterator and enumerator

I&#39;m trying to remove an item from an `ArrayList` and I get this Exception:  
`Collection was modified; enumeration operation may not execute.` 
 
Any ideas?

Collection was modified; enumeration operation may not execute in ArrayList

In the two following snippets, is the first one safe or must you do the second one?

By safe I mean is each thread guaranteed to call the method on the Foo from the same loop iteration in which the thread was created?

Or must you copy the reference to a new variable &quot;local&quot; to each iteration of the loop?

    var threads = new List&lt;Thread&gt;();
    foreach (Foo f in ListOfFoo)
    {      
        Thread thread = new Thread(() =&gt; f.DoSomething());
        threads.Add(thread);
        thread.Start();
    }

-

    var threads = new List&lt;Thread&gt;();
    foreach (Foo f in ListOfFoo)
    {      
        Foo f2 = f;
        Thread thread = new Thread(() =&gt; f2.DoSomething());
        threads.Add(thread);
        thread.Start();
    }

**Update:** As pointed out in Jon Skeet&#39;s answer, this doesn&#39;t have anything specifically to do with threading.

The foreach identifier and closures

Is it possible to iterate an `Enumeration` by using Lambda Expression? What will be the Lambda representation of the following code snippet:

    Enumeration&lt;NetworkInterface&gt; nets = NetworkInterface.getNetworkInterfaces();
    
    while (nets.hasMoreElements()) {
    	NetworkInterface networkInterface = nets.nextElement();
    	
    }

I didn&#39;t find any stream within it.

Iterate an Enumeration in Java 8

In Java 5 and above you have the foreach loop, which works magically on anything that implements ```Iterable```:

    for (Object o : list) {
      doStuff(o);
    }

However, ```Enumerable``` still does not implement ```Iterable```, meaning that to iterate over an ```Enumeration``` you must do the following:

    for(; e.hasMoreElements() ;) {
      doStuff(e.nextElement());
    }

Does anyone know if there is a reason why ```Enumeration``` still does not implement ```Iterable```?

**Edit:** As a clarification, I&#39;m not talking about the language concept of an [enum][1], I&#39;m talking a Java-specific class in the Java API called &#39;[Enumeration][2]&#39;. 


  [1]: http://en.wikipedia.org/wiki/Enumerated_type
  [2]: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Enumeration.html

Why aren&#39;t Enumerations Iterable?

I am trying to iterate through a list of keys from a hash table  using enumeration however I keep getting a NoSuchElementException at the last key in list?


    Hashtable&lt;String, String&gt; vars = new Hashtable&lt;String, String&gt;();
		
    vars.put(&quot;POSTCODE&quot;,&quot;TU1 3ZU&quot;);
    vars.put(&quot;EMAIL&quot;,&quot;job.blogs@lumesse.com&quot;);
    vars.put(&quot;DOB&quot;,&quot;02 Mar 1983&quot;);
		    
    Enumeration&lt;String&gt; e = vars.keys();

    while(e.hasMoreElements()){
		
	System.out.println(e.nextElement());
	String param = (String) e.nextElement();
    }

Console output:

&lt;pre&gt;
EMAIL
POSTCODE
&lt;/pre&gt;

&lt;pre&gt;
Exception in thread &quot;main&quot; java.util.NoSuchElementException: Hashtable Enumerator
	at java.util.Hashtable$Enumerator.nextElement(Unknown Source)
	at testscripts.webdrivertest.main(webdrivertest.java:47)

&lt;/pre&gt;

iterating through Enumeration of hastable keys throws NoSuchElementException error

I was trying to understand how Java enum really works and I have come to the conclusion that it is very similar to a normal Java class that has its constructor declared private.

I have just come to this conclusion and it isn&#39;t based on much thinking, but Id like to know whether I miss anything.

So below is an implementation of a simple Java enum and an equivalent Java class.

    public enum Direction {
        ENUM_UP(0, -1),
        ENUM_DOWN(0, 1),
        ENUM_RIGHT(1, 0),
        ENUM_LEFT(-1, 0);
        

        private int x;
        private int y;
        
        private Direction(int x, int y){
            this.x = x;
            this.y = y;
        }
        public int getEnumX(){
            return x;
        }
        public int getEnumY(){
            return y;
        }
    }

What is the difference in meaning between the code above and below?

    public class Direction{
        public static final Direction UP = new Direction(0, -1) ;
        public static final Direction DOWN = new Direction(0, 1) ;
        public static final Direction LEFT = new Direction(-1, 0) ;
        public static final Direction RIGHT = new Direction(1, 0) ;


        private int x ;
        private int y ;
    
        private Direction(int x, int y){
            this.x = x ;
            this.y = y ;
        }
        public int getX(){
            return x;
        }
        public int getY(){
            return y;
        }
    }

  

What are the differences between a Java enum and a class with private constructor?

If we have to store the available positions at a company (i.e. Manager, Team Lead, ... etc). What are the best practices for storing it? I have two opinions with comments... &quot;sure, welcoming yours&quot;&lt;br/&gt;
&lt;b&gt;
&lt;ol&gt;
    &lt;li&gt;Storing it as DB table with columns ID and Name, and deal with it using queries and joins.&lt;/li&gt;
    &lt;li&gt;Storing it as Enum and forget about the DB table.&lt;/li&gt;
&lt;/ol&gt;
&lt;/b&gt;
In my opinion, I will choose the first solution if I have changing items. So that I won&#39;t hard code these options as Enum.&lt;br/&gt;
I may choose the Enum solution, if I have no doubt that data won&#39;t change (for example, Gender: Male, Female). &lt;br/&gt;&lt;br/&gt;
&lt;b&gt;NOTE:&lt;/b&gt; I code in English, and the UI Culture may be Arabic. If I will work with the Enum Solution, I will hard code the culture-based strings in the presentation layer, is it okay from the best practices perspective!!!! &lt;br/&gt;&lt;br/&gt;
I would like to know your opinions and if my thoughts correspond to what is most recommended &quot;Best Practices&quot;?? 

Lookup Tables Best Practices: DB Tables... or Enumerations

How can I get the name of a Java Enum type given its value?

I have the following code which works for a **particular** Enum type, can I make it more **generic**?

	public enum Category {

        APPLE(&quot;3&quot;), 
        ORANGE(&quot;1&quot;), 

		private final String identifier;

        private Category(String identifier) {
		    this.identifier = identifier;
		}

		public String toString() {
			return identifier;
		}
		 
		public static String getEnumNameForValue(Object value){
            Category[] values = Category.values();
		    String enumValue = null;
		    for(Category eachValue : values) {
		        enumValue = eachValue.toString();

		        if (enumValue.equalsIgnoreCase(value)) {
		            return eachValue.name();
                }
		    }
            return enumValue;
        }
	}



Java getting the Enum name given the Enum Value

If I have an `enum` that does not assign numbers to the enumerations, will it&#39;s ordinal value be 0? For example:

    enum enumeration { ZERO,
                       ONE,
                       TWO,
                       THREE,
                       FOUR,
                       FIVE,
                       SIX,
                       SEVEN,
                       EIGHT,
                       NINE };

I&#39;ve been able to find a [post citing that the C99 standard requires a 0 ordinal number](https://stackoverflow.com/a/30312219/2642059). But I know C++ ignores several things in the C99 standard. And I&#39;ve also been able to find a [post witnessing the compiler using an ordinal value of 1](https://stackoverflow.com/a/404253/2642059), something I also seem recall seeing, though I can&#39;t say how long ago that was.

I would really like to see an answer that confirms this for C++, but I&#39;d also like to know if an ordinal 0 holds *even if* I specify a value in the middle of an `enum`:

    enum enumeration { ZERO,
                       ONE,
                       TWO,
                       THREE = 13,
                       FOUR,
                       FIVE,
                       SIX,
                       SEVEN,
                       EIGHT,
                       NINE };

All Enumeration Solutions on Gang of Coders

Total of 39 Enumeration Solutions