-1

緯度と経度のフィールドを持つデータベースがあります。

この関数で bd を取得し、配列に変換します。

ArrayList<PontoEntity> array = new ArrayList<PontoEntity>();       
Cursor c = com.vianaturismo.db.DBMain.getAll(getApplicationContext(), DALPonto.TABLE_NAME, DALPonto.columns);
array = DALPonto.converte(c);

彼女はまた、私がいる場所とポイントの間の距離を返すこの関数を持っています.

  public double getDistancia(double latitude, double longitude, double latitudePto, double longitudePto){  
            double dlon, dlat, a, distancia;  
            dlon = longitudePto - longitude;  
            dlat = latitudePto - latitude;  
            a = Math.pow(Math.sin(dlat/2),2) + Math.cos(latitude) * Math.cos(latitudePto) * Math.pow(Math.sin(dlon/2),2);  
            distancia = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));  
            return 6378140 * distancia; /* 6378140 is the radius of the Earth in meters*/  
    }

このソートにおける私の難しさは、配列を距離で並べ替えることです。つまり、最も近い点で並べ替えます。

4

3 に答える 3

2

それを機能させるために私がしたことは、場所の配列があるとします

private List<Places> placesList = new ArrayList<Places>();

place は、これらのフィールドを持つクラスです。

public class Place
{
private String placepName;
private String placeLat;
private String placeLng;
private float placeDistance;

public String getPlacepName() {
    return placepName;
}
public void setPlacepName(String placepName) {
    this.placepName = placepName;
}
public String getPlaceLat() {
    return placeLat;
}
public void setPlaceLat(String placeLat) {
    this.placeLat = placeLat;
}
public String getPlaceLng() {
    return placeLng;
}
public void setPlaceLng(String placeLng) {
    this.placeLng = placeLng;
}
public float getPlaceDistance() {
    return placeDistance;
}
public void setPlaceDistance(float placeDistance) {
    this.placeDistance = placeDistance;
}
}

次に、最初にすべての配列を調べて、場所から各場所の距離を見つけます。

for ( Place tempPlace: placeList)
{
    tempLocation = new Location("");    
    tempLocation.setLatitude(Double.parseDouble(tempPlace.getPlaceLat()));
    tempLocation.setLongitude(Double.parseDouble(tempPlace.getPlaceLng()));
    float distance = currentUserLocation.distanceTo(tempLocation);
    distance = distance/1000;
    tempPlace.setPlaceDistance(distance);
}

最後に、この配列を距離で並べ替えます。

Collections.sort(placeList, new Comparator<Place>() {
            @Override
            public int compare(Place c1, Place c2) {
                return new Float(c1.getPlaceDistance()).compareTo(new Float(c2.getPlaceDistance()));
            }
        });
于 2013-10-26T16:56:44.243 に答える
0

これは私がおそらくそれを行う方法です...

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

public class SortByDistance{
    public static void main(String[] args) {
        // TODO: initialize these
        List<Location> locations = new ArrayList<>();
        final Location myLocation = null;

        sort(locations, new ToComparable<Location, Double>() {
            @Override
            public Double toComparable(Location location) {
                return Location.distance(location, myLocation);
            }
        });

        for (Location location : locations)
            System.out.println(location);
    }

    protected static class Location {
        private final double latitude, longitude;

        public Location(double latitude, double longitude) {
            this.latitude = latitude;
            this.longitude = longitude;
        }

        public Double getLatitude() {
            return latitude;
        }

        public Double getLongitude() {
            return longitude;
        }

        @Override
        public String toString() {
            return String.format("[latitude = %f, longitude = %f]", latitude, longitude);
        }

        public static double distance(Location location1, Location location2) {
            // TODO: return the distance between location1 and location2
            return 0;
        }
    }

    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 pair) {
              return comparable == null ? 
                pair.comparable == null ? 0 : -1 :
                pair.comparable == null ? 1 : comparable.compareTo(pair.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-26T16:02:09.303 に答える