We Keep Coding

inherited java ArrayList to JSON

I have a class that overrides ArrayList like:
public class SkmeList extends ArrayList<SkmeStatement> {
private static final long serialVersionUID = 1L;
private int skmeMajor = 0;
private int skmeMinor = 0;
private String skmeTable = null;
public void setTable(String table) {
System.out.println("Set Table: " + table);
skmeTable = table;
}
public String getTable() {
return skmeTable;
}
public void setMajor(int major) {
System.out.println("SetMajor: " + major);
skmeMajor = major;
}
public int getMajor() {
return skmeMajor;
}
public void setMinor(int minor) {
System.out.println("SetMinor: " + minor);
skmeMinor = minor;
}
public int getMinor() {
return skmeMinor;
}
}
when I attempt to write this class to a file or even a string using jackson I can only see the list contents, I do not see any of class specific attributes like Major or minor in the string/file? I treat this class just like any other java class. Is there something that is different with lists in jackson object mapper?
public void WriteJson(SkmeList statements) {
final ByteArrayOutputStream out = new ByteArrayOutputStream();
final ObjectMapper mapper = new ObjectMapper();
try {
mapper.writeValue(out, statements);
final byte[] data = out.toByteArray();
System.out.println(new String(data));
}
catch (IOException ioe) {
System.out.println("Foo");
}
}

A List has elements and no further non-element data. If you need more data, you need something that's more than a List.
The user of your class already has to treat it specially if they care about any of the extra fields you've added.
In favoring composition over inheritance, here's how I'd suggest this class could look like.
public class SkmeList {
private final int major;
private final int minor;
private final String table;
private final List<SkmeStatement> statements;
// ctor, getters, hashCode, equals and toString omitted
}
With more context on what Skme means, we could make the naming even clearer.
To make it easier to reason about, the class should be immutable, to make it safe for use in a Collection it should have hashCode() and equals(), and a toString() in case it ever gets printed/logged/debugged around.
If you don't feel like implementing all the omitted methods, consider AutoValue: you specify the getters and a factory method, the rest is generated for you.
For the user of your class, it's almost the same:
SkmeList list = ...
for (SkmeStatement stmt : list) {
...
now becomes
SkmeList list = ...
for (SkmeStatement stmt : list.getStatements()) {
...

Issue with static code in Android

I am building my own class, which is similar to an Enum. Here's the code:
public final class MyClass {
public final static MyClass V1 = new MyClass("v1");
public final static MyClass V2 = new MyClass("v2");
public final static MyClass V3 = new MyClass("v3");
private static Map<String, MyClass> values;
private final String name;
private MyClass(String name) {
this.name = name;
if (values == null)
values = new HashMap<>();
values.put(name,this);
}
public static MyClass[] values() {
return values.values().toArray(new MyClass[values.size()]);
}
public static MyClass valueOf(String key) {
return values.get(key);
}
public String getName() {
return name;
}
public String toString() {
return getName();
}
public static void print() {
Iterator<Map.Entry<String, MyClass>> i = values.entrySet().iterator();
while (i.hasNext()) {
String key = i.next().getKey();
System.out.println(MyClass.class.getSimpleName() + ": " + key + ", " + values.get(key));
}
}
}
I am observing a weird behavior: when I try to invoke MyClass.valueOf("v1") I get null.
I tried to debug and:
the constructor is invoked long before valueOf is invoked (when I invoke print, it gets invoked 3 times)
values gets populated (last constructor invocation, of course, takes the map size to 3, as expected.
when in valueOf, values is empty
====UPDATE
ONLY if I am in debug mode and put a breakpoint in the print method, then I can see the "enum-like-class" values printed in the console. When I do htis, valueOf returns the correct results.
What's happening?

Currently, the best way I found to tackle the issue is to move values definition and initialization before the other static variables.
This way, it gets initialized before the constructors are invoked.
Look at this: Static initializer not called on Activity creation

Better way to map from String constants to int constants in Java

I have a load of images of musical symbols which I need to do some processing on and for each one I need to get the integer code corresponding to its file name. There are 23 possible file name strings and 23 integer code and there are many images with the same name under different directories.
The solution I have so far is given (abbreviated) below. I have just defined a load of int and String constants and then written a method which is just a huge chain of if statements to do the translation.
What would be a better way to achieve the same effect? The way I've done it seems really awful! I thought about using some kind of Map, but I wasn't sure of the best way to do so.
public class Symbol {
public static final int TREBLE_CLEF = 0;
public static final int BASS_CLEF = 1;
public static final int SEMIBREVE = 2;
// ...
public static final String S_TREBLE_CLEF = "treble-clef";
public static final String S_BASS_CLEF = "bass-clef";
public static final String S_SEMIBREVE = "semibreve";
// ...
public static int stringCodeToIntCode(String strCode) {
if (strCode == S_TREBLE_CLEF) {
return TREBLE_CLEF;
} else if (strCode == S_BASS_CLEF) {
return BASS_CLEF;
} else if (strCode == S_SEMIBREVE) {
return SEMIBREVE;
} //...
else {
return -1;
}
}
}

I think you are looking for Enum where you can have String constant and its value.
Example:
public enum YourEnumClass{
STRING_CONST (5),
STRING_CONST2 (7),
.....
//constructor
//getValue() method
}
read linked tutorial for more details.

enum StringToInt{
TREBLE_CLEF(0),
......
}
Enum is the way to go.
Another example:
public enum Color {
WHITE(21), BLACK(22), RED(23), YELLOW(24), BLUE(25);
private int code;
private Color(int c) {
code = c;
}
public int getCode() {
return code;
}

how about a hashmap
HashMap<String,Integer> hm=new HashMap<String,Integer();
hm.put("treble-clef",0);
//rest
and get it by using this
int value=hm.get("treble-clef");

Why is a java enum not constructing till after a class callback is hit?

I have an Android class which has a callback from an asynchronous HTTP process, and an enum with a number of status codes in:
public abstract class HttpPackage {
public enum StatusCode {
SUCCESS(0),
NOT_FOUND(100),
USERNAME_NOT_FOUND(101),
AUTH_FAILED(110),
SAVE_ERROR(111)
//etc.
private final int mCode;
StatusCode(int i) {
mCode = i;
sByCode.put(i, this);
}
}
private static final HashMap<Integer, StatusCode> sByCode = new HashMap<Integer, StatusCode>();
//...
}
I've discovered the callback in the HttpPackage class is being hit before the enum constructs, which means that when I try to extract a status code from the static code map, it returns null, and my code thinks all the feeds are failing (when they aren't). Why would this enum be constructing after the callback is hit?

Classes are loaded lazily in Java. If you access the map before the StatusCode class is loaded, then of course it will be empty.
The map should be in the enum itself. This way, if you're accessing the map, you're guaranteed that the enum class has been loaded, and that the map is not empty. The map should also be hidden from the outside code. You should provide a static StatusCode getByCode(int code) method in the enum.
EDIT: example code:
public enum StatusCode {
SUCCESS(0),
NOT_FOUND(100),
USERNAME_NOT_FOUND(101),
AUTH_FAILED(110),
SAVE_ERROR(111);
private final int code;
private static final Map<Integer, StatusCode> map = new HashMap<Integer, StatusCode>();
static {
for (StatusCode sc : values()) {
map.put(sc.getCode(), sc);
}
}
StatusCode(int i) {
this.code = i;
}
public static StatusCode getByCode(int code) {
return map.get(code);
}
public int getCode() {
return code;
}
public static void main(String[] args) {
System.out.println(StatusCode.getByCode(111));
}
}
Or you could also use a getMap() static method inside the constructor which lazily initializes the map if it's null.

java - an enum question

I have encountered a weird problem in my app (java).
I have an enum. Something like that
public enum myEnum implement myIntrface{
valueA(1),valueb(2),valuec(3),valued(4)
private int i;
// and then - a constructor
public MyEnum(int number){
i = number;
}
private MyObj obj = new MyObj;
// getter and setter for obj
}
and in another class I have this
MyEnum.valueA.setObj(new Obj(...))
in briefe - I have an enum with a private instance member that has a set and a get.
So far so good -
The only thing that amazes me is that later on I look at the value of the MyEnum.valueA().obj is null.
there is nothing that updates the value to null, I have even gave it a default value in the constructor and I still see it null later.
any suggestions?

Enums should be un-modifiable classes so you shouldn't really be doing this. If your looking to modify the state of a type based object like an enum you should use an final class approach with embedded constants. Below is an example of a class based approach with a modifiable name an a un-modifiable name...
public final class Connection {
public static final Connection EMAIL = new Connection("email");
public static final Connection PHONE = new Connection("phone");
public static final Connection FAX = new Connection("fax");
/**/
private final String unmodifiableName; //<-- it's final
private String modifiableName;
/*
* The constructor is private so no new connections can be created outside.
*/
private Connection(String name) {
this.unmodifiableName = name;
}
public String getUnmodifiableName() {
return unmodifiableName;
}
public String getModifiableName() {
return modifiableName;
}
public void setModifiableName(String modifiableName) {
this.modifiableName = modifiableName;
}
}

The purpose of enums is to represent constant values. It does not make any sense to set the fields of a constant value.
You should declare your fields as final, and use the constructor to initialize all of them.

For reference, the following code works as expected:
public class Test {
public static enum MyEnum {
valueA(1),valueb(2),valuec(3),valued(4);
private int i;
private Object o;
private MyEnum(int number) {
i = number;
}
public void set(Object o) {
this.o = o;
}
public Object get() {
return o;
}
}
public static void main(String[] args) {
System.out.println(MyEnum.valueA.get()); // prints "null"
MyEnum.valueA.set(new Integer(42));
System.out.println(MyEnum.valueA.get()); // prints "42"
}
}

the cause of this problem is the db40 framework . It loads an enum from the db using reflection. This is well documented .
http://developer.db4o.com/Forums/tabid/98/aft/5439/Default.aspx