Java 如何从文件中查找i最大值

我有一个这样的文件内容

id  value
1   56
2   5
3   90
4   12
5   234
6   90

我正在尝试从文件中查找最大值。 例如：

i=2

然后我的结果应该是

234,90

。我应该能够返回两个最大值

如何做到这一点 基本上，max可以通过

if (value < min) {
 min = value;
}
if (value > max) {
 max = value;
}

if（值最大值）{
最大值=最大值；
}

---

通过这个循环，我可以获得4个最大值吗？

这里有一种方法可以从数组中获得

count

最大值

public static int[] getMaxValues(int count, int... values) {
    int[] v = values.clone();
    Arrays.sort(v);
    return Arrays.copyOfRange(v, v.length - count, v.length);
}

public static void main(String[] args) {
    System.out.println(Arrays.toString(getMaxValues(2, 56, 5, 90, 12, 234, 90)));
}

输出是（请求的）

试试这个

import java.util.*;

public class Test {

    public static void main(String ar[])
    {
        ArrayList<Integer> i = new ArrayList<Integer>();

        i.add(200);
        i.add(203);
        i.add(250);
        i.add(270);
        i.add(20);
        i.add(300);
        i.add(60);
        i.add(10);

        System.out.println(i);
        Collections.sort(i);
        System.out.println(i);

        int someValue = 3;
        if(i.size()>=someValue)
        {
            for(int j = i.size() - 1; someValue>0; j--)
            {
                someValue--;
                System.out.println(i.get(j));
            }
        }
    }
}

import java.util.*；
公开课考试{
公共静态void main（字符串ar[]
{
ArrayList i=新的ArrayList（）；
i、 增加（200）；
i、 增加（203）；
i、 增加（250）；
i、 增加（270）；
i、 增加（20）；
i、 增加（300）；
i、 增加（60）；
i、 增加（10）；
系统输出打印LN（i）；
收集.分类（i）；
系统输出打印LN（i）；
int-someValue=3；
如果（i.size（）>=someValue）
{
对于（int j=i.size（）-1；someValue>0；j--）
{
某个值--；
系统输出println（i.get（j））；
}
}
}
}

您可以填充优先级队列并提取其根两次，而不是对元素进行完全排序：

public static int[] minmax(File f)
{
    int [] res = {-1,-1};
    try {
        Scanner scan = new Scanner(f);
        scan.nextLine();
        PriorityQueue<Integer> values = new PriorityQueue(10, new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        while(scan.hasNextInt())
        {
            int id = scan.nextInt();
            if(!scan.hasNextInt()) continue;
            int val = scan.nextInt();
            values.add(val);
        }
        scan.close();
        res[0] = values.poll();
        res[1] = values.poll();
    } catch (FileNotFoundException ex) {
        Logger.getLogger(Test2.class.getName()).log(Level.SEVERE, null, ex);
    }
    return res;
}

publicstaticint[]minmax（文件f）
{
int[]res={-1，-1}；
试一试{
扫描仪扫描=新扫描仪（f）；
scan.nextLine（）；
PriorityQueue值=新的PriorityQueue（10，新的比较器（）{
@凌驾
公共整数比较（整数o1，整数o2）{
返回o2.compareTo（o1）；
}
});
while（scan.hasNextInt（））
{
int id=scan.nextInt（）；
如果（！scan.hasnetint（））继续；
int val=scan.nextInt（）；
值。添加（val）；
}
scan.close（）；
res[0]=values.poll（）；
res[1]=values.poll（）；
}捕获（FileNotFoundException ex）{
Logger.getLogger（Test2.class.getName（））.log（Level.SEVERE，null，ex）；
}
返回res；
}

---

其思想是在O（n）中构建堆，但正如@bcorso所指出的，Java的

PriorityQueue

实现并没有提供构建时的复杂性。

如果您希望从数组中找到top K元素，那么有几种方法可以做到这一点：

实施

你也可以探索

示例代码：

package impatient;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

public class Test1 {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        List<Integer> list = new ArrayList<Integer>();
        list.add(56);
        list.add(5);
        list.add(90);
        list.add(12);
        list.add(234);
        list.add(90);
        test1.findTopN(list, 2);
        test1.findTopN(list, 4);
    }

    private void findTopN(List<Integer> list, int n) {
        TreeSet<Integer> sortedList = new TreeSet<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return a > b ? 1 : -1;
            }
        });

        sortedList.addAll(list);

        Iterator<Integer> it = sortedList.descendingIterator();

        int index = 0;
        System.out.print("Top " + n + " elements : ");
        while (it.hasNext() && index < n) {
            System.out.print(it.next() + ", ");
            index++;
        }
        System.out.println();
    }
}

public void findhigest（int[]数组）{
int最高=数组[0]；
int secondHighest=数组[0]；
对于（int i=0；i最高）{
第二高=最高；
最高=数组[i]；
}  
}//结束
}//结束方法

解决问题的两种方法，各有利弊：

description          |           pros          |         cons
------------------------------------------------------------------------------
Collections.sort     |  simple                 | inefficient O(nlogn)
selection algorithm  |  efficient O(n)         | implement from scratch, not sorted
PriorityQueue        |  simple                 | inefficient O(nlogn)
heap (bottom up)     |  efficient O(n + klogn) | implement from scratch
for-loop             |  efficient O(n), simple | hardcoded for k = 2
bubble sort          |  efficient if k << n    | O(kn) --> O(n^2) if k~n 

---

试试这个，希望对你有帮助

 import java.util.*;

    public class TestNumber {

        public static void main(String args[]) {

            int[] ints = { 2, 56, 5, 90, 12, 234, 90 };
            Integer i = 3;
            getMaxValues(ints, i);
        }

        private static void getMaxValues(int[] ints, Integer i) {
            int maxRange = i;

            List<Integer> intList = new ArrayList<Integer>();
            for (int index = 0; index < ints.length; index++) {
                intList.add(ints[index]);
            }
            Collections.sort(intList);

            System.out.println("The maximum requested numbers are :");
            if (intList.size() >= maxRange) {
                for (int j = intList.size() - 1; maxRange > 0; j--) {
                    maxRange--;
                    System.out.println(intList.get(j));
                }
            }

        }
    }

import java.util.*；
公共类测试号{
公共静态void main（字符串参数[]）{
int[]int={2,56,5,90,12,234,90}；
整数i=3；
GetMaxValue（整数，i）；
}
私有静态void getMaxValues（int[]int，整数i）{
int maxRange=i；
List intList=new ArrayList（）；
对于（int index=0；index=maxRange）{
对于（int j=int list.size（）-1；maxRange>0；j--）{
最大范围--；
System.out.println（intList.get（j））；
}
}
}
}

您停留在哪个部分？我对存储2个最大值感到困惑。请更清楚地了解它。复制数组列表中的所有值，这样我认为您正在查找数组中的前k个元素（在您的情况下，它是文件）。使用。您可以通过将第一个

if

设置为使用

=

来删除最后一个

else if

如果我比较arry>secondHighest，则如何在first中查看，如果我比较scondHighest==highest，则在else中查看。这两个条件都是不同的。是的，实际上最后一个

else if

不应该存在。我不知道你想对这种情况做什么。尽管如此，第一个

if

应该是

=

。不幸的是，Java中的PriorityQueue实现只需要

O（nlogn）

时间来创建，因此它不会给您渐进更快的算法。为此，您必须创建自己的堆并实现自底向上的创建，以获得

O（n）

的好处。@bcorso我想当然地认为Java的

PriorityQueue

将使用提供所需

O（n）

时间复杂度的堆来实现。你是对的。尽管如此，我还是想建议OP使用这个数据结构。如何在我的问题中包含的循环中获得3个值。有其他选择吗ways@SreeVeni对于三个值，将第一个参数传递给getMaxValues（3,56,5,90,12,234,90）中的3

public void findHighest(int[] array){  
        int highest = array[0];  
        int secondHighest = array[0];  

            for(int i=0;i<array.length;i++) {  


            if(array[i] > highest){  

                secondHighest = highest;  
                highest = array[i];  



             }  
        } // end for  
    } // end method  

description          |           pros          |         cons
------------------------------------------------------------------------------
Collections.sort     |  simple                 | inefficient O(nlogn)
selection algorithm  |  efficient O(n)         | implement from scratch, not sorted
PriorityQueue        |  simple                 | inefficient O(nlogn)
heap (bottom up)     |  efficient O(n + klogn) | implement from scratch
for-loop             |  efficient O(n), simple | hardcoded for k = 2
bubble sort          |  efficient if k << n    | O(kn) --> O(n^2) if k~n 

public int[] largestTwo(int[] A){
    int[] largest = new {A[0], A[0]};  
    for(int i = 0; i < A.length; i++) {
        if(A[i] >= largest[0]){  
            largest[1] = largest[0];  
            largest[0] = A[i];  
        }else if(A[i] > largest[1]){  
            largest[1] = A[i];
        }
    }
    return largest;
}

 import java.util.*;

    public class TestNumber {

        public static void main(String args[]) {

            int[] ints = { 2, 56, 5, 90, 12, 234, 90 };
            Integer i = 3;
            getMaxValues(ints, i);
        }

        private static void getMaxValues(int[] ints, Integer i) {
            int maxRange = i;

            List<Integer> intList = new ArrayList<Integer>();
            for (int index = 0; index < ints.length; index++) {
                intList.add(ints[index]);
            }
            Collections.sort(intList);

            System.out.println("The maximum requested numbers are :");
            if (intList.size() >= maxRange) {
                for (int j = intList.size() - 1; maxRange > 0; j--) {
                    maxRange--;
                    System.out.println(intList.get(j));
                }
            }

        }
    }