Java泛型，返回数组最大值最小值

public class NumFunc {
T[] a;

NumFunc(T[] a) {
this.a = a;
}

/**
* 最小值
* @return 最小值
*/
public T minValue() {
T min = this.a[0];
for (int i = 1; i < this.a.length; i++){
if (a[i].toString().compareTo(min.toString())<0){
min = a[i]; // 未对参数类型 T, T 定义运算符 <
}
}
return min;
}

/**
* 最大值
* @return 最大值
*/
public T maxValue() {
T max = this.a[0];
for (int i = 1; i < this.a.length; i++)
if (a[i].toString().compareTo(max.toString())>0){
max = a[i]; // 未对参数类型 T, T 定义运算符 <
}
return max;
}

/**
* 平均值
* @return 平均值
*/
@SuppressWarnings("unchecked")
public T aveValue() {
//没有特别好的方法，你先用这个方法逐一些吧：Byte、Double、Float、Integer、Long、Short
if (this.a instanceof Double[]) {
Double ave=0.0;
for (int i = 0; i < this.a.length; i++)
ave+=Double.valueOf(a[i].toString());
ave=ave/this.a.length;
return (T)ave;
}

if (this.a instanceof Integer[]) {
Double ave=0.0;
for (int i = 0; i < this.a.length; i++)
ave+=Integer.valueOf(a[i].toString());
ave=ave/this.a.length;
return (T)ave;
}

//.....
return null;
}

public static void main(String[] args) {
Integer[] i = { 9, 1, 2, 5, };
Double[] d = { 1.0, 1.1111 };
NumFunc v = new NumFunc(i);
NumFunc vs = new NumFunc(d);
System.out.println("最小值：" + vs.minValue());
System.out.println("最大值：" + vs.maxValue());
System.out.println("平均值：" + v.aveValue());
System.out.println("平均值：" + vs.aveValue());
}
}本回答被提问者采纳

public class Test {
public static void main(String[] args) {
//因为泛型的类型参数只能是引用类型，
//所以这里利用了java的自动包装机制
//注意：Integer和String类都实现了Comparable<T>接口
Integer[] arrint={12,7,9,25,36,88,1001,90};
IMinMax<Integer> i1=new MinMaxImpl<Integer>(arrint);
System.out.println(i1.toString());
System.out.println();
String[] arrstring={"green","pick","finally","much","deal","listen","what","cookie"};
IMinMax<String> i2=new MinMaxImpl<String>(arrstring);
System.out.println(i2.toString());
System.out.println();

// 下面的用来演示要使用MinMaxImpl类求某种类型的数组的最大值，最小值，
// 此类型必须实现Comparable<T>接口
// 正确，类C实现了Comparable<C>接口
C[] arrc={new C(2),new C(1),new C(2),new C(4),new C(7),new C(5)};
IMinMax<C> i3=new MinMaxImpl<C>(arrc);
System.out.println(i3.toString());
System.out.println();
// 错误，类D没有实现Comparable<D>接口
// D[] arrd={new D(2),new D(1),new D(2),new D(4),new D(7),new D(5)};
// IMinMax<D> i4=new MinMaxImpl<D>(arrd);
// System.out.println(i4.toString());
// System.out.println();
}
}
interface IMinMax<T>
{
T getMinValue();
T getMaxValue();
}
class MinMaxImpl<T extends Comparable<T>> implements IMinMax<T>
{
MinMaxImpl(T[] d)
{
data=d;
findMinMaxValue();
}
private void findMinMaxValue()
{
StringBuilder sb=new StringBuilder();
T min=max=data[0];

for(int i=1;i<data.length;i++)
{
if(data[i].compareTo(min)<0)
min=data[i];
else if(data[i].compareTo(max)>0)
max=data[i];
}
if(null==data || 0==data.length)
sb.append("数组长度为0");
else
{
sb.append("数组：");
for(int i=0;i<data.length-1;i++)
{
sb.append(data[i]);
sb.append('，');
}
sb.append(data[data.length-1]);
sb.append(MinMaxImpl.NewLine);
sb.append(String.format("的最大值是：%s，最小值是：%s%s",max,min,MinMaxImpl.NewLine));
}
str=sb.toString();
}
public T getMinValue()
{
return min;
}
public T getMaxValue()
{
return max;
}
public String toString()
{
return str;
}
private static final String NewLine=System.getProperty("line.separator");
private T[] data;
private T min,max;
private String str;
}
class C implements Comparable<C>
{
C(int i)
{
v=i;
}
public String toString()
{
return "C("+v+")";
}
public int compareTo(C o)
{
return Integer.valueOf(v).compareTo(Integer.valueOf(o.v));
}
private int v;
}
class D
{
D(int i)
{
v=i;
}
public String toString()
{
return "D("+v+")";
}
private int v;
}追答