Java 按距离排序数组

我有一个包含字段、纬度和经度的数据库

我将通过这个函数获取bd，并将其转换为数组

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

---

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

您需要查看这个答案，它演示了如何构造按距离排序的

order by

语句

---

我可能会这样做

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

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
导入java.util.ListIterator；
公共类排序距离{
公共静态void main（字符串[]args）{
//TODO:初始化这些
列表位置=新的ArrayList（）；
最终位置myLocation=null；
排序（位置，新到可比较（）{
@凌驾
公共双ToCompable（位置）{
返回位置。距离（位置、位置）；
}
});
对于（位置：位置）
系统输出打印项次（位置）；
}
受保护的静态类位置{
私人最终双纬度、经度；
公共位置（双纬度、双经度）{
这个。纬度=纬度；
这个经度=经度；
}
公共双纬度（）{
返回纬度；
}
公共双getLongitude（）{
返回经度；
}
@凌驾
公共字符串toString（）{
返回String.format（“[latitude=%f，longitude=%f]”，latitude，longitude）；
}
公共静态双距离（位置1、位置2）{
//TODO:返回位置1和位置2之间的距离
返回0；
}
}
可比较的公共界面我所做的是，假设你有一系列的地方

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

然后，您应该做的是，首先检查所有阵列，以找到每个位置与您的位置之间的距离：

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

Collections.sort（placeList，newcomparator（）{
@凌驾
公共整数比较（位置c1，位置c2）{
返回新浮点（c1.getPlaceDistance（））.compareTo（新浮点（c2.getPlaceDistance（））；
}
});
如果您的问题在于数据排序，请参阅：
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()));
            }
        });