如何在Java中构建复杂的，层次结构的不可变数据结构？

Question

I'm building a Java library for a customer, and one of the things they want is a data representation of a particular set of standards they work with. I don't want to reveal my customer's interests, but if he were an alchemist, he might want the following:

Elements
  Fire
    Name="Fire"
    Physical
      Temperature=451
      Color="Orange"
    Magical
      Domain="Strength"
  Water
    Name="Water"
    Physical
      Color="Blue"
  Earth
    Name="Earth"
    Magical
      Domain="Stability"
      Ordinality=1

I need to be able to access various data elements by name, such as:

  Elements.Earth.Name
  Elements.Water.Physical.Color

I also need to be able to iterate through attributes, as:

  for (MagicalType attrib : Elements.Fire.Magical)
  {
    ...
  }

I have actually been able to create this data structure, and I can do everything I've asked for above -- though I had to create separate arrays for the iteration, so really what I do looks more like:

  for (MagicalType attrib : Elements.Fire.MagicalAuxArray)

Unfortunately I haven't been able to meet my last requirement: the entire data structure must be immutable. I have tried repeatedly, and scoured the web looking for examples, but so far I haven't been able to accomplish this in any reasonable manner. Note that the final data structure will be quite large; I'm really hoping to avoid a solution that is too repetitious or creates too many public symbols.

I am a very experienced programmer, less experienced with Java. Can anyone suggest how I might represent the above data to meet all my requirements?

Answer 1

A few ways that come to mind immediately:

• Don't provide setter methods for your object. You users can only create the object via a constructor and once created, it cannot be modified. This goes for other state-modification methods as well. If you want to avoid a very large parameter-list in your constructor, you can use the Builder pattern (described in Effective Java by Joshua Bloch (2nd Ed) )
• When returning collections, make defensive copies. In this case use a List instead of an array. That way you can do return new ArrayList<MagicalType>(MagicalAuxList) instead of return MagicalAuxList . This way people who use the class won't be able to modify the collection. One caveat here. If your array contains complex objects, they must be immutable as well.
• For immutable collections, you can also try using the unmodifiableCollection static method (there are similar static-methods for lists, sets, etc. - use whichever one is appropriate for you) to convert your collection when you return it. This is an alternative to defensive copying.

Answer 2

Why do you use arrays? Wouldn't immutable collections (eg from Google Guava ) do a better job?

Answer 3

You can use Iterable in your public API. Cleaner than Collections with all the mutators that you have to suppress. (unfortunately Iterator has a remove() method(?!) but that's just one)

public final Iterable<MagicalType> magics;

for(MagicalType magic : magics) ...

Answer 4

you could try the code below that uses final, enums and unmodifiable maps. but that does not let you access by name since you need to do a get from the map. you could probably do that in groovy.

import java.util.*;

enum Color {
    red, green, blue;
}

class Physical {
    Physical(final Double temperature, final Color color) {
        this.temperature = temperature;
        this.color = color;
        final Map<String, Object> map=new LinkedHashMap<String, Object>();
        map.put("temperature", temperature);
        map.put("color", color);
        this.map=Collections.unmodifiableMap(map);
    }

    final Double temperature;
    final Color color;
    final Map<String, Object> map;
}

class Magical {
    Magical(final String domain, final Integer ordinality) {
        this.domain = domain;
        this.ordinality = ordinality;
        final Map<String, Object> map=new LinkedHashMap<String, Object>();
        map.put("domain", domain);
        map.put("ordinality", ordinality);
        this.map=Collections.unmodifiableMap(map);
    }

    final String domain;
    final Integer ordinality;
    final Map<String, Object> map;
}

public enum Elements {
    earth("Earth", new Magical("Stability", 1), null), air("Air", null, null), fire("Fire", new Magical("Strength", null), new Physical(451., Color.red)), water(
            "Water", null, new Physical(null, Color.blue));
    Elements(final String name, final Magical magical, final Physical physical) {
        this.name = name;
        this.magical = magical;
        this.physical = physical;
    }

    public static void main(String[] arguments) {
        System.out.println(Elements.earth.name);
        System.out.println(Elements.water.physical.color);
        for (Map.Entry<String, Object> entry : Elements.water.physical.map.entrySet())
            System.out.println(entry.getKey() + '=' + entry.getValue());
        for (Map.Entry<String, Object> entry : Elements.earth.magical.map.entrySet())
            System.out.println(entry.getKey() + '=' + entry.getValue());
    }

    final String name;
    final Magical magical;
    final Physical physical;
}