如何從一個文件

Question

我有這樣的

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

我試圖找到該文件最大值文件內容找到我的最大值。 例如：i=2 然後我的結果應該是234,90。我應該能夠返回2個最大值。

如何做到這一點 基本上最多可以

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

隨着這種循環被確定我能夠拿到4最大值？

Answer 1

這裏有一種方法，你可以從陣列獲取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))); 
} 

輸出是（請求）

[90, 234] 

Answer 2

試試這個

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)); 
      } 
     } 
    } 
} 

Answer 3

而是完全排序元素，你可以填充一個優先級隊列並提取其根目錄兩次：

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; 
} 

這樣做的想法是建立在O（n）的堆，但是，作爲@bcorso指出，Java的PriorityQueue實現不提供生成時的複雜性。

Answer 4

如果你正在尋找從數組中找到前K元素則有幾個方式做到這一點：

1. 實現http://en.wikipedia.org/wiki/Selection_algorithm。

2. 您還可以探索TreeSet。

示例代碼：

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(); 
    } 
} 

輸出：

Top 2 elements : 234, 90, 
Top 4 elements : 234, 90, 90, 56, 

Answer 5

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 

Answer 6

一對夫婦的方式與利弊解決你的問題：

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 

這是一個for-loop方法的實現，如果你只需要一個固定的k的2就可以工作。

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; 
} 

Answer 7

試試這個，希望這有助於

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)); 
       } 
      } 

     } 
    }