converting a string color to an object color

[Kee Kee moon]

Would any one please shed a light.
how to convert a String like:

String colorStr = "Red";
to an Object Color.red

Thanks.

[Randall Twede]

is this what you were looking for?

 * Created on February 13, 2004, 10:00 AM
 */

/**
 *
 * Randall Twede
 */
import java.awt.*;
import javax.swing.*;

public class StandardColorSelector extends JPanel
{
    private String names[] = {"Black", "Blue", "Cyan", "Dark Gray", "Gray", "Green", "Light Gray",
                              "Magenta", "Orange", "Pink", "Red", "White", "Yellow"};  
    private Color colors[] = {Color.black, Color.blue, Color.cyan, Color.darkGray, Color.gray, Color.green, Color.lightGray,
                              Color.magenta, Color.orange, Color.pink, Color.red, Color.white, Color.yellow};  
    private JComboBox selector = new JComboBox(names);
    
    /** Creates a new instance of StandardColorSelector */
    public StandardColorSelector()
    {
        selector.setEditable(false);
        selector.setSelectedIndex(0);	// Default selection is black
        add(selector);
    }
    
    public Color getSelectedColor()
    {
        return colors[selector.getSelectedIndex()];
    }

    // Requires an integer parameter between 0 and 12 inclusive
    public void setDefaultSelection(int selection)
    {
        selector.setSelectedIndex(selection);
    }
    
}

[Joanne Neal]

A Map would be better than two separate arrays, then you could have a getColour method which took a String as a parameter and use that as a key into the Map. The user wouldn't have to know the index of each of the colours then.

[Randall Twede]

joanne, i would marry you if i could

[Joanne Neal]

Randall Twede wrote:joanne, i would marry you if i could

I think Campbell is first in line at the moment, but feel free to try and push in front.

[Campbell Ritchie]

Joanne Neal wrote: . . . I think Campbell is first in line at the moment, but feel free to try and push in front.

Oh, Joanne, how sweet of you.

As long as Ruth doesn’t find out. And as long as Eleanor (my smaller daughter) doesn’t think I am marrying somebody younger than herself

[Paul Clapham]

(blushing) Bringing this thread back on-topic... the other part of the answer to the original question is "No, you may find it surprising, but there is nothing in the standard Java API to convert strings to Color objects, at least, not in the way you describe."

[Kee Kee moon]

Thank you very much that is exactly what I was looking for.

Randall Twede wrote:is this what you were looking for?

 * Created on February 13, 2004, 10:00 AM
 */

/**
 *
 * Randall Twede
 */
import java.awt.*;
import javax.swing.*;

public class StandardColorSelector extends JPanel
{
    private String names[] = {"Black", "Blue", "Cyan", "Dark Gray", "Gray", "Green", "Light Gray",
                              "Magenta", "Orange", "Pink", "Red", "White", "Yellow"};  
    private Color colors[] = {Color.black, Color.blue, Color.cyan, Color.darkGray, Color.gray, Color.green, Color.lightGray,
                              Color.magenta, Color.orange, Color.pink, Color.red, Color.white, Color.yellow};  
    private JComboBox selector = new JComboBox(names);
    
    /** Creates a new instance of StandardColorSelector */
    public StandardColorSelector()
    {
        selector.setEditable(false);
        selector.setSelectedIndex(0);	// Default selection is black
        add(selector);
    }
    
    public Color getSelectedColor()
    {
        return colors[selector.getSelectedIndex()];
    }

    // Requires an integer parameter between 0 and 12 inclusive
    public void setDefaultSelection(int selection)
    {
        selector.setSelectedIndex(selection);
    }
    
}

[Darryl Burke]

If you want to map the named constants of the Color class (or any other) which are instances of the same class, here's a utility I wrote some time back that uses Reflection to do it.

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
 
public abstract class StaticFieldMap<T> implements Map<String, T> {
 
  private final Map<String, T> content = new HashMap<String, T>();
 
  @SuppressWarnings("unchecked")
  protected StaticFieldMap() {
    Type superType = getClass().getGenericSuperclass();
    if (superType instanceof ParameterizedType) {
      ParameterizedType paraType = (ParameterizedType) superType;
      Class clazz = (Class) paraType.getActualTypeArguments()[0];
      Field[] fields = clazz.getDeclaredFields();
      for (Field field : fields) {
        if (field.getType() == clazz) {
          try {
            put(field.getName(), (T) field.get(null));
          } catch (IllegalArgumentException ex) {
            ex.printStackTrace();
          } catch (IllegalAccessException ex) {
            ex.printStackTrace();
          }
        }
      }
    }
  }
 
  public int size() {
    return content.size();
  }
 
  public boolean isEmpty() {
    return content.isEmpty();
  }
 
  public boolean containsKey(Object key) {
    return content.containsKey(key);
  }
 
  public boolean containsValue(Object value) {
    return content.containsValue(value);
  }
 
  public T get(Object key) {
    return content.get(key);
  }
 
  public T put(String key, T value) {
    return content.put(key, value);
  }
 
  public T remove(Object key) {
    return remove(key);
  }
 
  public void putAll(Map<? extends String, ? extends T> m) {
    content.putAll(m);
  }
 
  public void clear() {
    content.clear();
  }
 
  public Set<String> keySet() {
    return content.keySet();
  }
 
  public Collection<T> values() {
    return content.values();
  }
 
  public Set<Entry<String, T>> entrySet() {
    return content.entrySet();
  }
}

Usage to obtain a Map of static Color fields of the Color class:

Map<String, Color> colorMap = new StaticFieldMap<Color>(){};

edit: Thought I should mention that the class is abstract to force instances to be named or anonymous subclasses, which makes it possible to obtain the ParameterizedType from the genericSuperclass.

[Rob Spoor]

Your class is missing the following three methods:

  public boolean equals(Object o)   {
    return this == o || content.equals(o);
  }

  public int hashCode()   {
    return content.hashCode();
  }

  public String toString() {
    return content.toString();
  }

The first two are required as per the contract of java.util.Map.

I actually don't like this trick. Instead of an entire class I'd use one static utility method instead:

public static <T> Map<String,T> getStaticFields(Class<T> cls)
{
    Map<String,T> map = new HashSet<String,T>();
    Field[] fields = cls.getDeclaredFields();
    for (Field field : fields)
    {
        int modifiers = field.getModifiers();
        // limit to public static final fields only
        if (field.getType() == cls && Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers))
        {
            try
            {
                // using Class.cast gets rid of compiler warning
                map.put(field.getName(), cls.cast(field.get(null)));
            }
            // IllegalArgumentException won't occur anymore because the field is checked to be static
            catch (IllegalAccessException ex)
            {
                // won't occur because the field is checked to be public
                // however, the exception is checked so needs to be caught
                ex.printStackTrace();
            }
        }
    }
    return map;
}

[Darryl Burke]

Rob Spoor wrote:Your class is missing the following three methods:

The first two are required as per the contract of java.util.Map.

Thanks Rob, for pointing that out. I'll keep that in mind if I ever publish the class.

Rob Spoor wrote:I actually don't like this trick. Instead of an entire class I'd use one static utility method instead:

I actually had this approach too, and the code is very similar to yours (but yours is more complete in that it checks the modifiers)

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class StaticFieldMapper {

  @SuppressWarnings("unchecked")
  public static <T> Map<String, T> getFieldMap(Class<T> clazz) {
    Map<String, T> map = new HashMap<String, T>();
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
      if (field.getType() == clazz) {
        try {
          map.put(field.getName(), (T) field.get(null));
        } catch (IllegalArgumentException ex) {
          ex.printStackTrace();
        } catch (IllegalAccessException ex) {
          ex.printStackTrace();
        }
      }
    }
    return map;
  }
}

I didn't think of using Class#cast(...) instead of suppressing the warning.