Class that holds calculation results and has to be immutable I'm roughly trying to follow the guidelines in "Effective Java", "Item 15: Minimize mutability", hence the class is not "final" on purpose.  

Information is gathered from a number of temperature meters.
Some may fail to report, so the size of the map is not known.  

The serializing bothers me. Is there a simpler way to make this class immutable ?  

public class Result&lt;T extends Number&gt; {
    private final Map&lt;String, T&gt; result;

    private Result(final Map&lt;String, T&gt; result) {
        this.result = result;
    }

    public static final Result&lt;Number&gt; of() {
        return new Result&lt;&gt;(new LinkedHashMap&lt;&gt;());
    }

    /** Add or replace value. */
    public Result&lt;T&gt; put(final String key, final T value) {
        final Map&lt;String, T&gt; copy = new LinkedHashMap&lt;&gt;(result);
        copy.put(key, value);
        return new Result&lt;&gt;(copy);
    }

    @SuppressWarnings("unchecked")
    public T get(final String key) throws Exception {
        return ((T) convertFromBytes(convertToBytes(result.get(key))));
    }

    @Override
    public String toString() {
        return result.toString();
    }

    private byte[] convertToBytes(Object object) throws IOException {
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutput out = new ObjectOutputStream(bos)) {
            out.writeObject(object);
            return bos.toByteArray();
        }
    }

    private Object convertFromBytes(byte[] bytes) throws IOException, ClassNotFoundException {
        try (ObjectInput in = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
            return in.readObject();
        }
    }
}
At the moment your class is not immutable because the Map given in the constructor is not copied (and Map itself isn't immutable). You should instead have a constructor like

public Result(final Map&lt;String, T&gt; result) {
    this.result = new LinkedHashMap&lt;&gt;(result);
}


What's the goal of the of() method ? Shouldn't it be named empty() instead ?

public static final Result&lt;Number&gt; empty() {
    return new Result&lt;&gt;(new LinkedHashMap&lt;&gt;());
}


Or having two parameters (1 key, 1 value) ?

public static final Result&lt;Number&gt; of(final String key, final T value) {
    Map&lt;String, T&gt; base = new LinkedHashMap&lt;&gt;();
    base.put(key, value);
    return new Result&lt;&gt;(base);
}


The fact that get() throws an IOException or a ClassNotFoundException bothers me because it makes the current underlying implementation "leaking" out of your class. Who wants (and expects) to have to handle an IOException when getting a value from a Map ?
Since these exceptions are not supposed to happen in this case, I would rethrow them as unchecked exceptions

@SuppressWarnings("unchecked")
public T get(final String key) throws Exception {
    try {
        return ((T) convertFromBytes(convertToBytes(result.get(key))));
    } 
    catch(IOException | ClassNotFoundException e) {
        throw new RuntimeException(e);
    }
}