0

私はAndroidアプリを開発しています。別の並べ替えに基づいて配列を並べ替える必要があります。最低から最高に基づいて 1 つ (距離) を並べ替えており、経度の値を距離に従って並べ替える必要があります。たとえば、距離 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);
   }
}

ご協力ありがとうございました。

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を使い果たすため、ループは静かに失敗します。これは、外側のループでのみ行われます。そうiteratorhasNext()

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 に答える