如何根據其他陣列對陣列進行排序

Question

我正在開發一個Android應用程序。我需要根據另一個排序排序數組。我基於最低到最高排序一個（距離），並且需要根據距離對我的經度值進行排序。所以說，如果距離5的經度是41.2265，距離6的經度是41.2187，那麼我需要對從最低到最高的距離{5,6}進行排序，然後根據它們的第一對排序經度。我已經讀過，你可以用2D數組來做到這一點，但我不想這樣做。我認爲這也可以通過繪圖來完成，但我不知道如何。我的代碼如下：

NearestStations.java的部分

  ArrayList<String> distancetos = new ArrayList<String>(); 
      ArrayList<String> longitudeArray = new ArrayList<String>(); 

      while(iterator.hasNext()){ 
      for (int i=0; i<144;i++){ 

      double distance = 0; 

      double lat_end = 0; 
      double lon_end = 0; 


      try { 
       lat_end = Double.parseDouble(iterator.next()); 
       lon_end = Double.parseDouble(iterator1.next()); 
       longitudeArray.add(Double.toString(lon_end)); 
       Log.i("Lon_end", String.valueOf(lon_end)); 

      } catch (NumberFormatException e) { 
       Log.v("Main", "Convert to Double Failed : "); 
      } 

      Location locationA = new Location("point A"); 
      locationA.setLatitude(latitude); 
      locationA.setLongitude(longitude); 

      Location locationB = new Location("point B"); 
      locationB.setLatitude(lat_end); 
      locationB.setLongitude(lon_end); 

      distance = locationA.distanceTo(locationB) * 0.000621371192237334; 
      Log.i("distancebefore", String.valueOf(distance)); 

      String dista = Double.toString(distance); 


      distancetos.add(dista); 
      } 
      } 


       Collections.sort(distancetos); 

       distancea = distancetos.get(0); 
       distance1 = distancetos.get(1); 

       String Longa = longitudeArray.get(0); 
       String Long1 = longitudeArray.get(1); 


       Log.i("distanceafter", String.valueOf(distancea)); 
       Log.i("distance1after", String.valueOf(distance1)); 


      String[] Stations = getResources().getStringArray(R.array.Stations); 
      String[] Longitude = getResources().getStringArray(R.array.Longitude); 
      String[] Latitude = getResources().getStringArray(R.array.Latitude); 



      Map<String, String> myMap = new HashMap<String, String>();{ 
      for (int i = 0; i <144; i++) { 
       myMap.put(Latitude[i], Stations[i]); 
      } 
      } 

      Map<String, String> myMap1 = new HashMap<String, String>();{ 
      for (int h = 0; h <144; h++) { 
       myMap1.put(Longitude[h], Stations[h]); 

      } 
      } 

      String value = myMap1.get(Longa); 
    } 
} 

謝謝您的幫助。

Answer 1

我相信這就是你要找的。

import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.Collections; 
import java.util.List; 
import java.util.ListIterator; 

public class GenericCachedSorter { 
    public static void main(String[] args) { 
     List<Double> distances = new ArrayList<>(Arrays.asList(1d, 2d, 3d)); 

     sort(distances, new ToComparable<Double, Double>() { 
      @Override 
      public Double toComparable(Double distance) { 
       // return the longitude associated with this distance 
       return getLongitude(distance); 
      } 
     }); 

     for (Double distance : distances) 
      System.out.println(distances); 
    } 

    public interface ToComparable<T, C extends Comparable<? super C>> { 
     C toComparable(T t); 
    } 

    public static <T, C extends Comparable<? super C>> void sort(List<T> list, ToComparable<T, C> function) { 
     class Pair implements Comparable<Pair> { 
      final T original; 
      final C comparable; 

      Pair(T original, C comparable) { 
      this.original = original; 
      this.comparable = comparable; 
      } 

      @Override 
      public int compareTo(Pair other) { 
       return 
        comparable == null && other.comparable == null ? 0 : 
        comparable == null ? -1 : 
        other.comparable == null ? 1 : 
        comparable.compareTo(other.comparable); 
      } 
     } 

     List<Pair> pairs = new ArrayList<>(list.size()); 
     for (T original : list) 
      pairs.add(new Pair(original, function.toComparable(original))); 

     Collections.sort(pairs); 

     ListIterator<T> iter = list.listIterator(); 
     for (Pair pair : pairs) { 
      iter.next(); 
      iter.set(pair.original); 
     } 
    } 
} 

Answer 2

如何爲他們上課？

public class Coord{ 
    private int id; 
    private double lat; 
    private double long; 

    public double getDistanceFrom(Coord coord); 

} 

這應該幫助你，因爲它能夠消除管理任務的位置 - 如果你在寫C你的做法是一個很好的一個。但是你正在寫Java。

此外：for循環將無聲無息地失敗，因爲您在不檢查hasNext()的情況下耗盡iterator。這隻在外部循環完成。所以

int i=0; 
while(iterator.hasNext() && iterator1.hasNext()){ //also check iterator1 
    if(i>=144) break; //that's what your for loop essentially did 
     double distance = 0; 
     double lat_end = 0; 
     double lon_end = 0; 

     try { 
      lat_end = Double.parseDouble(iterator.next()); 
      lon_end = Double.parseDouble(iterator1.next()); 
      CoordArray.add(new Coord(lat_end, lat_long)); 
      Log.i("Lon_end", String.valueOf(lon_end)); 

     } catch (NumberFormatException e) { ... } 
//more stuff here 
i++; 
}/*while loop*/