排序数组的距离

Question

我有一个数据库，有经度和纬度的字段。

我将通过此函数获取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*/ 
    } 

我在这种排序距离的困难。也就是说，按最近的点排序。

Answer 1

你会想看看这个答案，它演示了如何构建order by语句按距离排序。

SQlite Getting nearest locations (with latitude and longitude)

Answer 2

这是我怎么可能会做...

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

Answer 3

我做了什么，使其工作是，假设你有地方的数组

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

并且地点是具有这些字段的类别：

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