0

我正在开发一个 Android 应用程序。我需要根据另一个数组的排序对数组进行排序。我正在根据从最低到最高对一个（距离）进行排序，并且需要根据距离对我的经度值进行排序。因此，假设距离 5 的经度为 41.2265，距离 6 的经度为 41.2187，我需要将距离从最低到最高排序，{5,6}，然后根据它们的第一对对经度进行排序。我读过你可以用二维数组来做这件事，但我不想这样做。我认为这也可以通过映射来完成，但我不确定如何。我的代码如下：

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

谢谢您的帮助。

4

2 回答 2

2

我相信这就是你要找的。

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);
       }
    }
}
于 2013-10-15T01:27:46.963 回答
1

给他们上课怎么样？

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

    public double getDistanceFrom(Coord coord);

}

这应该对您有所帮助，因为它将位置与管理任务分离 - 如果您正在编写 C，您的方法将是一个很好的方法。但是您正在编写 Java。

此外：for循环将静默失败，因为您在iterator没有检查 a的情况下耗尽了hasNext(). 这只在外循环中完成。所以

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*/
于 2013-10-15T01:26:08.593 回答