Java 常用的几个算法（菜鸟初学）

【数组，数组列表，链表求最大值的算法比较（只是例子，可以举一反三）】

方法类

/**
 * 算法练习
 * @author Jason
 *
 */
public class Methods {
    /**
     * 在数组中查找最大值算法（一般）
     * compareTo 不支持int 比较 所以要转成Integer  
     * 22行 报错详情：Cannot invoke(包含) compareTo(int) on the primitive(原始的) type int
     */
    public void SearchMaxFromArray(int prams[]){        
        if (prams.length==0) 
            throw new NoSuchElementException();
        int    largest=prams[0];
        for (int i = 0; i < prams.length; i++) {            
            if (Integer.valueOf(largest).compareTo(Integer.valueOf(prams[i]))<0) {
                largest=prams[i];
            }
        }
        System.out.println(largest);    
    }
    /**
     * 在数组列表中找出最大元素
     * 与数组算法有点小的差别
     */
    public void SearchMaxFromArrayList(List<Integer> prams){
        if (prams.size()==0) 
            throw new NoSuchElementException();
            Integer    largest=prams.get(0);
        for (int i = 0; i < prams.size(); i++) {            
            if (Integer.valueOf(largest).compareTo(Integer.valueOf(prams.get(i)))<0) {
                largest=prams.get(i);
            }
        }
        System.out.println(largest);    
    }
    /**
     * Linked 链表 无法高效的随机访问，但可以使用迭代器
     */
    public void SearchMaxFromLinked(List<Integer> list){
        if (list.isEmpty())
            throw new NoSuchElementException();
        Iterator<Integer> iter=list.iterator();
        Integer largest=iter.next();
        while (iter.hasNext()) {
            Integer next= (Integer) iter.next();
            if (Integer.valueOf(largest).compareTo(next)<0) {
                largest=next;
            }
        }
        System.out.println(largest);
    }
}

测试类

public class test {
    public static void main(String[] args) {
        /**
         * 测试第一个算法
         */
        int a[] =new int[]{1,4,3,6,78};
        Methods m=new Methods();
        m.SearchMaxFromArray(a);
        
        /**
         * 测试数组列表算法
         * 添加数据的时候要按下标序
         * 如果25，26换下位置就报错（这是码的时候有意测试的，错了就记录一下以便以后复习）
         */
        List<Integer> list =new ArrayList<Integer>();
        list.add(0, 12);    
        list.add(1,100);
        list.add(2,12);
        list.add(3,43);
        m.SearchMaxFromArrayList(list);
        
        /**
         * 测试LinkedList(链表算法)
         */
        List<Integer> list2 =new LinkedList<Integer>();
        list2.add(0, 12);    
        list2.add(1,100);
        list2.add(2,12);
        list2.add(3,43);
        m.SearchMaxFromLinked(list2);
        
    }
}

但有时候这些循环代码很容易出错，也不想每次都实现下面一系列的方法：

1. static <T extends Comparable> T max(T[] a)
2. static <T extends Comparable> T max(ArrayList<T> a)
3. static <T extends Comparable> T max(LinkedList<T> a)

为了高效使用最小的集合接口，采用set get方法进行随机访问比直接迭代层次高，上述计算链表最大值的过程中已经看到，这项任务并不需要进行随机访问，直接使用迭代就可以实现。因此可以简化上述方法：（使用一个方法实现上述3个方法的功能）

小弟初学，下面的代码老是报hot Code 编码警告我不清楚具体原因，还请大家指教，谢谢！

/**
     * 可以使用于数组，数组列表，LinkedList(链表)
     */
public static <T extends Comparable<T>> T max(Collection<T> c)
    {
        if (c.isEmpty()) throw  new NoSuchElementException();
        Iterator<T> iter=c.iterator(); //迭代
        T largest=iter.next();
        while (iter.hasNext()) {
            T next=iter.next();
            if (largest.compareTo(next)<0) {
                largest=next;
            }
        }
        return largest;
    }
//main方法中直接调用 测试一句话我就不写了。