int max(int[] data,int len)
{
int result=-1;
for(int i=0;i {
if(i==0)
{
result=0;
}
else
{
if(data[i]>data[result])
r=i;
}
}
}
有没有办法用一个max搞定所有的数据类型呢？（用Java语言）
或者加上泛型的通配符的话……
[code="java"]import java.util.*;
public class Util {
public static T max(Iterable<? extends T> items, Comparator<? super T> comparator) {
T maxItem = null;
for (T obj : items) {
if (null == maxItem || 0 < comparator.compare(obj, maxItem)) {
maxItem = obj;
}
}
return maxItem;
}
public static <T> T max(T[] items, Comparator<? super T> comparator) {
T maxItem = null;
for (T obj : items) {
if (null == maxItem || 0 < comparator.compare(obj, maxItem)) {
maxItem = obj;
}
}
return maxItem;
}
public static void main(String[] args) {
Comparator<Integer> comp = new Comparator<Integer>() {
public int compare(Integer x, Integer y) {
return x - y;
}
public boolean equals(Object obj) {
return obj.getClass() == this.getClass();
}
};
Integer[] array = new Integer[] { 2, 1, 4, 0, 3 };
int maxOfArray = max(array, comp);
System.out.println(maxOfArray); // 4
Iterable<Integer> list = Arrays.asList(1, 3, 2, -1, 5, 0);
int maxOfList = max(list, comp);
System.out.println(maxOfList); // 5
}
}[/code]
把max方法写成泛型的，接受一个[url=http://java.sun.com/javase/6/docs/api/java/util/Comparator.html]java.util.Comparator[/url]为参数来判断大小就行。
[code="java"]import java.util.*;
public class Util {
public static T max(Iterable items, Comparator
comparator) {
T maxItem = null;
for (T obj : items) {
if (null == maxItem || 0 < comparator.compare(obj,
maxItem)) {
maxItem = obj;
}
}
return maxItem;
}
public static void main(String[] args) {
Iterable<Integer> list = Arrays.asList(1, 3, 2, -1, 5, 0);
Comparator<Integer> comp = new Comparator<Integer>() {
public int compare(Integer x, Integer y) {
return x - y;
}
public boolean equals(Object obj) {
return obj.getClass() == this.getClass();
}
};
int m = max(list, comp);
System.out.println(m); // 5
}
}[/code]
如果要全面一些的话，给数组、原始类型等参数类型做一下重载，效率能高些。
呃，代码乱掉了……重来
[code="java"]import java.util.*;
public class Util {
public static T max(Iterable items, Comparator comparator) {
T maxItem = null;
for (T obj : items) {
if (null == maxItem || 0 < comparator.compare(obj, maxItem)) {
maxItem = obj;
}
}
return maxItem;
}
public static void main(String[] args) {
Iterable<Integer> list = Arrays.asList(1, 3, 2, -1, 5, 0);
Comparator<Integer> comp = new Comparator<Integer>() {
public int compare(Integer x, Integer y) {
return x - y;
}
public boolean equals(Object obj) {
return obj.getClass() == this.getClass();
}
};
int m = max(list, comp);
System.out.println(m); // 5
}
}[/code]
RednaxelaFX
太强大了,实在敬佩
不用这么复杂吧，直接equals搞定了，包装类型有自己实现，自定义类型重写equals和hashCode，欢迎喷水
我错了，看错了题目
[code="java"]
public static T max(T[] items) {
T maxItem = null;
for (T obj : items) {
if (null == maxItem || maxItem.compareTo(obj)<0) {
maxItem = obj;
}
}
return maxItem;
}
[/code]
well，限定了Comparable之后就没办法接受“任意类型”了。本来我也想用Comparable的……
TO:RednaxelaFX
大家都是接口，有必要分彼此吗?
[quote="lt0604"]大家都是接口，有必要分彼此吗?[/quote]
嗯，有的。不然Sun就不会再同一时期提供Comparable与Comparator两个看似相似的接口了。
使用Comparable意味着要排序的元素自身必须有公认的排序规则，例如说整数可以按照从小到大，英文字符串可以按照字典序。
但如果是排序的元素可以是“任意类型”，则无法对元素实现的接口做任何要求（否则就不是任意类型了）。例如要对这样类型求最大、最小、整体排序的话：
[code="java"]public class IntPair {
private int first;
private int second;
public IntPair(int first, int second) {
this.first = first;
this.second = second;
}
public void setFirst(int value) {
first = value;
}
public int getFirst() {
return first;
}
public void setSecond(int value) {
second = value;
}
public int getSecond() {
return second;
}
}[/code]
对于这样一个对偶，该如何判断大小顺序呢？一种合理的思路是把第一项的权重看得更高，第二项看得低一些，则先按first的大小排序，first相同时按照second排序。此时可以把判断大小的逻辑写在IntPair中，实现Comparable接口的compareTo方法。
但对偶的使用，或者扩展到N-tuple的使用，通常每个域都是同等重要的；而在某一次的排序或比较大小时，希望指定使用其中的一个或多个域作为比较标准。此时就无法用Comparable来满足要求，而必须把比较逻辑放在外面。
Comparator正是放在外面的比较逻辑的封装。使用外部提供的Comparator，即使要比较的元素本身没有实现任何特别的接口，也能够进行比较。从比较大小的角度看，使用Comparator是策略模式的一种应用。
有道理！ :idea: 这看实际情况取舍了。+上接口的限制，更强化和和符合java泛型的类型检查。继续学习中。。。
hmm，兴起了，再说一点：
[quote="lt0604"][code="java"] public static T max(T[] items) {
T maxItem = null;
for (T obj : items) {
if (null == maxItem || maxItem.compareTo(obj) maxItem = obj;
}
}
return maxItem;
}[/code][/quote]
因为Java的数组是协变（covariant）的，所以如果要写T extends Comparable然后T只是应用在数组上，那直接用Comparable[]就行。这个例子里要返回T类型所以就不满足了，不过换个例子，例如说printMax的话：
[code="java"] public static void max(Comparable[] items) {
Comparable maxItem = null;
for (Comparable obj : items) {
if (null == maxItem || maxItem.compareTo(obj) maxItem = obj;
}
}
System.out.println(maxItem);
}[/code]
然后用的时候，直接把实现了Comparable接口的类型的数组扔进去也没问题：
[code="java"]class Foo implements Comparable {
// ...省略
}
// 在某个方法里：
Foo[] array = new Foo[] { ... };
printMax(array);[/code]
也就是说Foo[]可以赋值给Comparable[]。这是Java里很邪恶的一个地方，呵呵～
不明白为什么要这么做呢