In convertible cast, casting from T to double

Question

I want to create generic method for getting maximal value from the array. However I got stuck at the problem of conversion between T to type Math.max method uses.

here is my code: First I cannot initialize the maxValue like:

T maxVaue = 0;

secondly I cannot use data[i] in Math.max, in both cases I got error of In convertible cast.

class Matrix<T>{
    public T getMaxValue(T[] data){
        T maxValue;
        for (int i=0; i<data.length; i++){
            maxValue = Math.max(data[i], maxValue);
        }
        return maxValue;
    }
}

score 3 · Accepted Answer · edited May 23 '17 at 10:32

3

Math.max takes only int, float, double and long. So you can not use it with T.

What you can do is write your own max() method using T. For example, your method could take a Comparator object in param. Or your T objects can implement the Comparable interface.

Have a look at this post : How to implement a generic `max(Comparable a, Comparable b)` function in Java?

edited May 23 '17 at 10:32

Community

1
1

answered Mar 06 '14 at 07:55

Junior Dussouillez

2,327
3
30
39

1

I agree, `Comparable` is the best way to go here. – Jason C Mar 06 '14 at 07:59

Jason C · Answer 2 · 2014-03-06T08:04:22.977

You cannot do that as you are doing it because a T can be anything. You could e.g. limit T to a Number but then you'd have to choose an intermediate primitive type and you will still run into issues returning the value.

However, you could just limit T to Comparable and use that instead, e.g.:

class Matrix<T extends Comparable<T>>{
    public T getMaxValue(T[] data){
        T maxValue = null;
        for (int i=0; i<data.length; i++){
            if (maxValue == null || data[i].compareTo(maxValue) > 0)
                maxValue = data[i];
        }
        return maxValue;
    }
}

All of Java's primitive wrapper types implement Comparable, as well as many other types:

byte by = new Matrix<Byte>().getMaxValue(new Byte[]{1, 2, 3});
char ch = new Matrix<Character>().getMaxValue(new Character[]{'a', 'b', 'c'});
int in = new Matrix<Integer>().getMaxValue(new Integer[]{1, 2, 3});
short sh = new Matrix<Short>().getMaxValue(new Short[]{1, 2, 3});
long lo = new Matrix<Long>().getMaxValue(new Long[]{1L, 2L, 3L});
float fl = new Matrix<Float>().getMaxValue(new Float[]{0.1f, 0.2f, 0.3f});
double db = new Matrix<Double>().getMaxValue(new Double[]{0.1, 0.2, 0.3});
boolean bo = new Matrix<Boolean>().getMaxValue(new Boolean[]{false, true});
String st = new Matrix<String>().getMaxValue(new String[]{"turtles", "are", "weird"});
BigInteger bi = new Matrix<BigInteger>().getMaxValue(new BigInteger[]{...});

Pshemo · Answer 3 · 2016-11-21T22:13:09.473

T can hold only classes like Double, Integer, not primitive types like double, int. Maybe just use built-in Collections.max(Collection<T extends Comparable<T>>) and array of Doubles instead of doubles like in this code example

class Matrix<T extends Comparable<T>> {
    public T getMaxValue(T[] data) {
        return Collections.max(Arrays.asList(data));
    }

    public static void main(String[] args) throws IOException {
        Matrix<Double> m = new Matrix<>();
        System.out.println(m.getMaxValue(new Double[] { 1., 42., 3., 4., 5. }));
    }
}

In convertible cast, casting from T to double

3 Answers3