重构：地图 <String, Double> 到地图 <String, Double or String>

Question

I've got widely used method like:

public Map<String, Double> parseData(String[] data) {
    .................

Where data is something like new String[] { "column1 -> 2.00", "column2 -> New York", ... }

Problem: It appears that data can contains both: String -> Double & String -> String values. So I need smth like:

public Map<String, String or Double> parseData(String[] data) {
    ................

Question: Any ideas besides return Map<String, Object> ?

Answer 1

Create a Wrapper StringOrDouble which will look a bit like this:

public class StringOrDouble {
    private String internalString;
    private Double internalDouble;

    public StringOrDouble(String input) {
        internalString = input;
    }

    public StringOrDouble(Double input) {
        internalDouble = input;
    }

    public boolean hasString() {
        return internalString != null;
    }

    public boolean hasDouble() {
        return internalDouble != null;
    }

    public String getString() {
        return internalString;
    }

    public Double getDouble() {
        return internalDouble;
    }
}

Then have a map of type Map<String, StringOrDouble> and use that. When you use the values, you can check which one it is by testing with hasString() and/or hasDouble() . Alternatively you could have an enum which determines which type it is.

Answer 2

public Map<String, Container> parseData(String[] data)

You can introduce a wrapper class for this

public class Container {
    private String s;
    private Double d;

    public Container(String s) {
         this.s=s;
    }
    public Container(Double d) {
         this.d=d;
    }
    public hasString() {
         return s!=null;
    }
    public hasDouble() {
         return d!=null;
    }
//getters/setters
}

Answer 3

As far as I understand, you want something like Map<String, ? extends String || Double Map<String, ? extends String || Double Map<String, ? extends String || Double as the return type, but no such thing is supported in Java:

4.9 Intersection Types An intersection type takes the form T1 & ... & Tn, n>0, where Ti, 1in, are type expressions. Intersection types arise in the processes of capture conversion (§5.1.10) and type inference (§15.12.2.7). It is not possible to write an intersection type directly as part of a program; no syntax supports this. The values of an intersection type are those objects that are values of all of the types Ti, for 1in.

So you'd better parse the input array and hold different arrays for each different type or you can use a wrapper class to represent the values in the map returned, as some other answerers explained.

Answer 4

使用超类：

public Map<String, Object> parseData(String[] data)

Answer 5

Just an alternative to @blalasaadri. don't pretend to be better:

 public static class StringDoubleValue {
        private final Optional<String> sValue;
        private final Optional<Double> dValue;

        public MetricValue(String sValue) {
            this.sValue = Optional.of(sValue);
            this.dValue = Optional.absent();
        }

        public MetricValue(Double dValue) {
            this.sValue = Optional.absent();
            this.dValue = Optional.of(dValue);
        }

        public Object get() {
            return (sValue.isPresent()) ? sValue.get() : dValue.get();
        }

        @Override
        public String toString() {
            if (sValue.isPresent()) ? sValue.get() : dValue.get().toString();
        }
    }