如何根据其他阵列对阵列进行排序

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*/