cell
package cell;
import java.util.*;
import java.lang.Math;
class Building {
String id;
String name;
double latitude;
double longitude;
double height;
int floors;
public Building(String id, String name, double lat, double lon, double height, int floors) {
this.id = id;
this.name = name;
this.latitude = lat;
this.longitude = lon;
this.height = height;
this.floors = floors;
}
}
class ResidentialArea {
String id;
String name;
double centerLat;
double centerLon;
List<Building> buildings;
public ResidentialArea(String id, String name, double centerLat, double centerLon) {
this.id = id;
this.name = name;
this.centerLat = centerLat;
this.centerLon = centerLon;
this.buildings = new ArrayList<>();
}
public void addBuilding(Building building) {
buildings.add(building);
}
}
class SearchResult {
Building building;
double distance;
double azimuth;
double azimuthDeviation;
public SearchResult(Building building, double distance, double azimuth, double azimuthDeviation) {
this.building = building;
this.distance = distance;
this.azimuth = azimuth;
this.azimuthDeviation = azimuthDeviation;
}
}
public class AzimuthRangeSearch {
private static final double EARTH_RADIUS = 6371000; // 地球半径（米）
/**
* 找到小区内指定方位角范围内的所有楼宇
* @param area 小区
* @param centerAzimuth 中心方位角（度，0-360）
* @param azimuthRange 方位角范围（度，正负值）
* @param maxDistance 最大距离（米）
* @return 符合条件的楼宇列表
*/
public static List<SearchResult> findBuildingsInAzimuthRange(ResidentialArea area,
double centerAzimuth,
double azimuthRange,
double maxDistance) {
List<SearchResult> results = new ArrayList<>();
for (Building building : area.buildings) {
// 计算距离
double distance = calculateDistance(area.centerLat, area.centerLon,
building.latitude, building.longitude);
// 如果距离超出范围，跳过
if (distance > maxDistance) {
continue;
}
// 计算方位角
double azimuth = calculateAzimuth(area.centerLat, area.centerLon,
building.latitude, building.longitude);
// 计算方位角偏差
double azimuthDeviation = calculateAzimuthDeviation(azimuth, centerAzimuth);
// 检查是否在方位角范围内
if (azimuthDeviation <= azimuthRange) {
results.add(new SearchResult(building, distance, azimuth, azimuthDeviation));
}
}
// 按距离排序
results.sort(Comparator.comparingDouble(r -> r.distance));
return results;
}
/**
* 计算方位角偏差（考虑360°循环）
*/
private static double calculateAzimuthDeviation(double actualAzimuth, double targetAzimuth) {
double diff = Math.abs(actualAzimuth - targetAzimuth);
return Math.min(diff, 360 - diff);
}
/**
* 计算两点之间的距离（米）
*/
public static double calculateDistance(double lat1, double lon1, double lat2, double lon2) {
double lat1Rad = Math.toRadians(lat1);
double lon1Rad = Math.toRadians(lon1);
double lat2Rad = Math.toRadians(lat2);
double lon2Rad = Math.toRadians(lon2);
double dLat = lat2Rad - lat1Rad;
double dLon = lon2Rad - lon1Rad;
double a = Math.sin(dLat/2) * Math.sin(dLat/2) +
Math.cos(lat1Rad) * Math.cos(lat2Rad) *
Math.sin(dLon/2) * Math.sin(dLon/2);
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
return EARTH_RADIUS * c;
}
/**
* 计算方位角
*/
public static double calculateAzimuth(double lat1, double lon1, double lat2, double lon2) {
double lat1Rad = Math.toRadians(lat1);
double lon1Rad = Math.toRadians(lon1);
double lat2Rad = Math.toRadians(lat2);
double lon2Rad = Math.toRadians(lon2);
double dLon = lon2Rad - lon1Rad;
double y = Math.sin(dLon) * Math.cos(lat2Rad);
double x = Math.cos(lat1Rad) * Math.sin(lat2Rad) -
Math.sin(lat1Rad) * Math.cos(lat2Rad) * Math.cos(dLon);
double azimuthRad = Math.atan2(y, x);
double azimuthDeg = Math.toDegrees(azimuthRad);
return (azimuthDeg + 360) % 360;
}
}
package cell;
import java.util.*;
public class AzimuthSearchExample {
public static void main(String[] args) {
// 创建测试小区
ResidentialArea area = createTestResidentialArea();
// 搜索正北方向（0°）±30°，50米范围内的楼宇
double centerAzimuth = 0; // 正北方向
double azimuthRange = 30; // ±30°范围
double maxDistance = 50; // 50米范围内
List<SearchResult> results = AzimuthRangeSearch.findBuildingsInAzimuthRange(
area, centerAzimuth, azimuthRange, maxDistance);
System.out.println("=== 正北方向±30°，50米范围内的楼宇 ===");
printResults(results);
// 搜索东北方向（45°）±30°，50米范围内的楼宇
System.out.println("\n=== 东北方向45°±30°，50米范围内的楼宇 ===");
results = AzimuthRangeSearch.findBuildingsInAzimuthRange(
area, 45, azimuthRange, maxDistance);
printResults(results);
// 搜索正东方向（90°）±30°，50米范围内的楼宇
System.out.println("\n=== 正东方向90°±30°，50米范围内的楼宇 ===");
results = AzimuthRangeSearch.findBuildingsInAzimuthRange(
area, 90, azimuthRange, maxDistance);
printResults(results);
}
private static ResidentialArea createTestResidentialArea() {
ResidentialArea area = new ResidentialArea("RA001", "测试小区", 39.9087, 116.3975);
// 添加各种方位的楼宇
area.addBuilding(new Building("B001", "北楼", 39.9092, 116.3975, 60.0, 20)); // 正北50米
area.addBuilding(new Building("B002", "东北楼", 39.9090, 116.3985, 45.0, 15)); // 东北方向
area.addBuilding(new Building("B003", "东楼", 39.9087, 116.3982, 75.0, 25)); // 正东30米
area.addBuilding(new Building("B004", "东南楼", 39.9080, 116.3980, 30.0, 10)); // 东南方向
area.addBuilding(new Building("B005", "南楼", 39.9082, 116.3975, 90.0, 30)); // 正南50米
area.addBuilding(new Building("B006", "西南楼", 39.9085, 116.3965, 40.0, 12)); // 西南方向
area.addBuilding(new Building("B007", "西楼", 39.9087, 116.3968, 55.0, 18)); // 正西20米
area.addBuilding(new Building("B008", "西北楼", 39.9090, 116.3965, 35.0, 11)); // 西北方向
// 添加一些超出距离的楼宇
area.addBuilding(new Building("B009", "远北楼", 39.9100, 116.3975, 70.0, 23)); // 正北140米
area.addBuilding(new Building("B010", "远东楼", 39.9087, 116.4000, 65.0, 21)); // 正东220米
return area;
}
private static void printResults(List<SearchResult> results) {
if (results.isEmpty()) {
System.out.println("没有找到符合条件的楼宇");
return;
}
for (SearchResult result : results) {
System.out.printf("%s: 距离=%.1fm, 方位角=%.1f°, 偏差=%.1f°%n",
result.building.name, result.distance, result.azimuth, result.azimuthDeviation);
}
}
}
package cell;
import java.util.*;
public class AzimuthVisualization {
/**
* 生成方位角分布图
*/
public static void visualizeAzimuthDistribution(ResidentialArea area,
List<SearchResult> results,
double centerAzimuth,
double azimuthRange) {
System.out.println("\n=== 方位角分布图 ===");
System.out.printf("中心方位角: %.1f° ± %.1f°%n", centerAzimuth, azimuthRange);
System.out.println("小区中心: (" + area.centerLat + ", " + area.centerLon + ")");
System.out.println();
// 创建简单的文本可视化
char[][] grid = createVisualizationGrid();
int centerX = grid[0].length / 2;
int centerY = grid.length / 2;
// 标记中心点
grid[centerY][centerX] = '★';
// 标记范围内的建筑
for (SearchResult result : results) {
int x = (int)((result.building.longitude - area.centerLon) * 10000) + centerX;
int y = centerY - (int)((result.building.latitude - area.centerLat) * 10000);
if (x >= 0 && x < grid[0].length && y >= 0 && y < grid.length) {
grid[y][x] = '●';
}
}
// 打印网格
for (char[] row : grid) {
for (char cell : row) {
System.out.print(cell + " ");
}
System.out.println();
}
System.out.println("\n图例: ★=小区中心, ●=范围内楼宇");
}
private static char[][] createVisualizationGrid() {
int size = 21; // 奇数，确保有中心点
char[][] grid = new char[size][size];
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
grid[i][j] = '·';
}
}
return grid;
}
/**
* 生成统计报告
*/
public static void generateStatisticsReport(List<SearchResult> results,
double centerAzimuth,
double azimuthRange,
double maxDistance) {
System.out.println("\n=== 搜索统计报告 ===");
System.out.printf("搜索条件: 方位角 %.1f° ± %.1f°, 距离 ≤ %.1f米%n",
centerAzimuth, azimuthRange, maxDistance);
System.out.printf("找到楼宇数量: %d%n", results.size());
if (!results.isEmpty()) {
double minDistance = results.get(0).distance;
double maxDistanceFound = results.get(results.size() - 1).distance;
double avgDistance = results.stream().mapToDouble(r -> r.distance).average().orElse(0);
System.out.printf("最近距离: %.1f米%n", minDistance);
System.out.printf("最远距离: %.1f米%n", maxDistanceFound);
System.out.printf("平均距离: %.1f米%n", avgDistance);
// 方位角分布
long northCount = results.stream().filter(r -> r.azimuth >= 315 || r.azimuth < 45).count();
long eastCount = results.stream().filter(r -> r.azimuth >= 45 && r.azimuth < 135).count();
long southCount = results.stream().filter(r -> r.azimuth >= 135 && r.azimuth < 225).count();
long westCount = results.stream().filter(r -> r.azimuth >= 225 && r.azimuth < 315).count();
System.out.println("\n方位角分布:");
System.out.printf("北方向: %d 栋%n", northCount);
System.out.printf("东方向: %d 栋%n", eastCount);
System.out.printf("南方向: %d 栋%n", southCount);
System.out.printf("西方向: %d 栋%n", westCount);
}
}
}
package cell;
import java.util.*;
public class BatchAzimuthSearch {
/**
* 批量处理多个小区的方位角搜索
*/
public static Map<String, List<SearchResult>> batchSearch(List<ResidentialArea> areas,
double centerAzimuth,
double azimuthRange,
double maxDistance) {
Map<String, List<SearchResult>> allResults = new HashMap<>();
for (ResidentialArea area : areas) {
List<SearchResult> results = AzimuthRangeSearch.findBuildingsInAzimuthRange(
area, centerAzimuth, azimuthRange, maxDistance);
allResults.put(area.id, results);
}
return allResults;
}
/**
* 搜索多个方位角范围
*/
public static Map<Double, Map<String, List<SearchResult>>> multiAzimuthSearch(
List<ResidentialArea> areas, List<Double> azimuths,
double azimuthRange, double maxDistance) {
Map<Double, Map<String, List<SearchResult>>> multiResults = new HashMap<>();
for (Double azimuth : azimuths) {
Map<String, List<SearchResult>> results = batchSearch(areas, azimuth, azimuthRange, maxDistance);
multiResults.put(azimuth, results);
}
return multiResults;
}
}
package cell;
import java.util.*;
public class OptimizedAzimuthSearch extends AzimuthRangeSearch {
/**
* 使用空间索引优化搜索
*/
public static List<SearchResult> findBuildingsInAzimuthRangeOptimized(
ResidentialArea area, double centerAzimuth,
double azimuthRange, double maxDistance) {
// 创建空间索引
Map<String, List<Building>> spatialIndex = createSpatialIndex(area.buildings, 0.0001);
// 获取中心点周围的网格
Set<String> nearbyGrids = getNearbyGrids(area.centerLat, area.centerLon, maxDistance, 0.0001);
List<SearchResult> results = new ArrayList<>();
// 只检查附近网格中的建筑
for (String gridKey : nearbyGrids) {
List<Building> gridBuildings = spatialIndex.get(gridKey);
if (gridBuildings != null) {
for (Building building : gridBuildings) {
processBuilding(area, building, centerAzimuth, azimuthRange, maxDistance, results);
}
}
}
results.sort(Comparator.comparingDouble(r -> r.distance));
return results;
}
private static Map<String, List<Building>> createSpatialIndex(List<Building> buildings, double gridSize) {
Map<String, List<Building>> index = new HashMap<>();
for (Building building : buildings) {
int gridX = (int)(building.longitude / gridSize);
int gridY = (int)(building.latitude / gridSize);
String gridKey = gridX + "," + gridY;
index.computeIfAbsent(gridKey, k -> new ArrayList<>()).add(building);
}
return index;
}
private static Set<String> getNearbyGrids(double centerLat, double centerLon,
double maxDistance, double gridSize) {
Set<String> grids = new HashSet<>();
// 计算经纬度偏移量（1度约111km）
double latOffset = maxDistance / 111000.0;
double lonOffset = maxDistance / (111000.0 * Math.cos(Math.toRadians(centerLat)));
int minX = (int)((centerLon - lonOffset) / gridSize);
int maxX = (int)((centerLon + lonOffset) / gridSize);
int minY = (int)((centerLat - latOffset) / gridSize);
int maxY = (int)((centerLat + latOffset) / gridSize);
for (int x = minX; x <= maxX; x++) {
for (int y = minY; y <= maxY; y++) {
grids.add(x + "," + y);
}
}
return grids;
}
private static void processBuilding(ResidentialArea area, Building building,
double centerAzimuth, double azimuthRange,
double maxDistance, List<SearchResult> results) {
double distance = calculateDistance(area.centerLat, area.centerLon,
building.latitude, building.longitude);
if (distance > maxDistance) return;
double azimuth = calculateAzimuth(area.centerLat, area.centerLon,
building.latitude, building.longitude);
double azimuthDeviation = calculateAzimuthDeviation(azimuth, centerAzimuth);
if (azimuthDeviation <= azimuthRange) {
results.add(new SearchResult(building, distance, azimuth, azimuthDeviation));
}
}
/**
* 计算方位角偏差（考虑360°循环）
*/
private static double calculateAzimuthDeviation(double actualAzimuth, double targetAzimuth) {
double diff = Math.abs(actualAzimuth - targetAzimuth);
return Math.min(diff, 360 - diff);
}
}
package cell;
public class MethodComparison {
public static void main(String[] args) {
// 创建测试数据
ResidentialArea area = createLargeTestArea(1000); // 1000栋建筑
double centerAzimuth = 45; // 东北方向
double azimuthRange = 30; // ±30°
double maxDistance = 50; // 50米
System.out.println("=== 方法性能对比测试 ===");
System.out.printf("测试数据: %d栋建筑, 方位角%.1f°±%.1f°, 距离%.1f米%n%n",
area.buildings.size(), centerAzimuth, azimuthRange, maxDistance);
// 基础方法测试
long startTime = System.nanoTime();
List<SearchResult> basicResults = AzimuthRangeSearch.findBuildingsInAzimuthRange(
area, centerAzimuth, azimuthRange, maxDistance);
long basicTime = System.nanoTime() - startTime;
// 优化方法测试
startTime = System.nanoTime();
List<SearchResult> optimizedResults = OptimizedAzimuthSearch.findBuildingsInAzimuthRangeOptimized(
area, centerAzimuth, azimuthRange, maxDistance);
long optimizedTime = System.nanoTime() - startTime;
// 结果对比
System.out.println("基础方法:");
System.out.printf(" 找到 %d 栋楼宇, 耗时: %.3f ms%n",
basicResults.size(), basicTime / 1_000_000.0);
System.out.println("优化方法:");
System.out.printf(" 找到 %d 栋楼宇, 耗时: %.3f ms%n",
optimizedResults.size(), optimizedTime / 1_000_000.0);
System.out.printf("性能提升: %.1f 倍%n%n", (double)basicTime / optimizedTime);
// 精度验证
validateResults(basicResults, optimizedResults);
// 内存使用对比
compareMemoryUsage(area, centerAzimuth, azimuthRange, maxDistance);
// 不同数据规模测试
testDifferentScales();
}
private static ResidentialArea createLargeTestArea(int buildingCount) {
ResidentialArea area = new ResidentialArea("LARGE", "大型小区", 39.9087, 116.3975);
Random random = new Random();
for (int i = 0; i < buildingCount; i++) {
// 90%的建筑在200米范围内，10%的远处建筑
double distance = random.nextDouble() < 0.9 ? random.nextDouble() * 200 : 200 + random.nextDouble() * 800;
double azimuth = random.nextDouble() * 360;
double[] coords = calculateCoordinates(39.9087, 116.3975, distance, azimuth);
double height = 20 + random.nextDouble() * 80;
int floors = 6 + random.nextInt(24);
area.addBuilding(new Building("B" + i, "建筑" + i, coords[0], coords[1], height, floors));
}
return area;
}
private static double[] calculateCoordinates(double centerLat, double centerLon, double distance, double azimuth) {
double azimuthRad = Math.toRadians(azimuth);
double lat = centerLat + (distance * Math.cos(azimuthRad)) / 111000.0;
double lon = centerLon + (distance * Math.sin(azimuthRad)) / (111000.0 * Math.cos(Math.toRadians(centerLat)));
return new double[]{lat, lon};
}
private static void validateResults(List<SearchResult> basicResults, List<SearchResult> optimizedResults) {
System.out.println("=== 精度验证 ===");
// 检查数量是否一致
if (basicResults.size() != optimizedResults.size()) {
System.out.println("⚠️ 警告: 两种方法找到的楼宇数量不一致");
System.out.printf("基础方法: %d, 优化方法: %d%n", basicResults.size(), optimizedResults.size());
} else {
System.out.println("✅ 两种方法找到的楼宇数量一致");
}
// 检查具体建筑是否一致
Set<String> basicIds = new HashSet<>();
Set<String> optimizedIds = new HashSet<>();
for (SearchResult result : basicResults) {
basicIds.add(result.building.id);
}
for (SearchResult result : optimizedResults) {
optimizedIds.add(result.building.id);
}
if (basicIds.equals(optimizedIds)) {
System.out.println("✅ 两种方法找到的建筑完全一致");
} else {
System.out.println("❌ 两种方法找到的建筑不一致");
// 找出差异
Set<String> onlyInBasic = new HashSet<>(basicIds);
onlyInBasic.removeAll(optimizedIds);
Set<String> onlyInOptimized = new HashSet<>(optimizedIds);
onlyInOptimized.removeAll(basicIds);
if (!onlyInBasic.isEmpty()) {
System.out.println("只在基础方法中找到: " + onlyInBasic);
}
if (!onlyInOptimized.isEmpty()) {
System.out.println("只在优化方法中找到: " + onlyInOptimized);
}
}
System.out.println();
}
private static void compareMemoryUsage(ResidentialArea area, double centerAzimuth,
double azimuthRange, double maxDistance) {
System.out.println("=== 内存使用对比 ===");
Runtime runtime = Runtime.getRuntime();
// 基础方法内存测试
runtime.gc();
long memoryBefore = runtime.totalMemory() - runtime.freeMemory();
List<SearchResult> basicResults = AzimuthRangeSearch.findBuildingsInAzimuthRange(
area, centerAzimuth, azimuthRange, maxDistance);
long memoryAfter = runtime.totalMemory() - runtime.freeMemory();
long basicMemory = memoryAfter - memoryBefore;
// 优化方法内存测试
runtime.gc();
memoryBefore = runtime.totalMemory() - runtime.freeMemory();
List<SearchResult> optimizedResults = OptimizedAzimuthSearch.findBuildingsInAzimuthRangeOptimized(
area, centerAzimuth, azimuthRange, maxDistance);
memoryAfter = runtime.totalMemory() - runtime.freeMemory();
long optimizedMemory = memoryAfter - memoryBefore;
System.out.printf("基础方法内存使用: %.1f KB%n", basicMemory / 1024.0);
System.out.printf("优化方法内存使用: %.1f KB%n", optimizedMemory / 1024.0);
System.out.printf("内存节省: %.1f%%%n%n",
(1 - (double)optimizedMemory / basicMemory) * 100);
}
private static void testDifferentScales() {
System.out.println("=== 不同数据规模性能测试 ===");
int[] scales = {100, 500, 1000, 2000, 5000};
double centerAzimuth = 90;
double azimuthRange = 30;
double maxDistance = 50;
System.out.println("规模\t基础方法(ms)\t优化方法(ms)\t提升倍数");
System.out.println("------------------------------------------------");
for (int scale : scales) {
ResidentialArea area = createLargeTestArea(scale);
long basicTime = measureTime(() ->
AzimuthRangeSearch.findBuildingsInAzimuthRange(area, centerAzimuth, azimuthRange, maxDistance));
long optimizedTime = measureTime(() ->
OptimizedAzimuthSearch.findBuildingsInAzimuthRangeOptimized(area, centerAzimuth, azimuthRange, maxDistance));
System.out.printf("%d\t%.1f\t\t%.1f\t\t%.1fx%n",
scale, basicTime / 1_000_000.0, optimizedTime / 1_000_000.0,
(double)basicTime / optimizedTime);
}
}
private static long measureTime(Runnable task) {
long startTime = System.nanoTime();
task.run();
return System.nanoTime() - startTime;
}
/**
* 详细对比表格
* 特性 基础方法 优化方法 优势方
* 时间复杂度 O(n) O(k) (k << n) 优化方法
* 空间复杂度 O(1) O(n) (索引) 基础方法
* 内存使用 低 中等（需要存储索引） 基础方法
* 计算精度 精确 精确 平手
* 初始化时间 无 需要构建索引 基础方法
* 查询速度 慢（全量扫描） 快（局部扫描） 优化方法
* 适用数据量 小规模（<1000） 大规模（>1000） 各有优势
* 实时性 适合实时查询 适合批量查询 基础方法
* 代码复杂度 简单 复杂 基础方法
* 扩展性 差 好（支持多种查询） 优化方法
*/
}
package cell;
public class PrecisionAnalysis {
/**
* 分析两种方法的精度差异
*/
public static void analyzePrecisionDifferences() {
// 创建边界测试用例
ResidentialArea testArea = new ResidentialArea("TEST", "测试区", 39.9087, 116.3975);
// 添加边界情况的建筑
addEdgeCaseBuildings(testArea);
// 测试多个方位角
double[] testAzimuths = {0, 45, 90, 135, 180, 225, 270, 315};
double azimuthRange = 30;
double maxDistance = 50;
System.out.println("=== 边界情况精度分析 ===");
for (double azimuth : testAzimuths) {
List<SearchResult> basicResults = AzimuthRangeSearch.findBuildingsInAzimuthRange(
testArea, azimuth, azimuthRange, maxDistance);
List<SearchResult> optimizedResults = OptimizedAzimuthSearch.findBuildingsInAzimuthRangeOptimized(
testArea, azimuth, azimuthRange, maxDistance);
System.out.printf("方位角 %.1f°: 基础=%d, 优化=%d, 一致=%b%n",
azimuth, basicResults.size(), optimizedResults.size(),
basicResults.size() == optimizedResults.size());
}
}
private static void addEdgeCaseBuildings(ResidentialArea area) {
// 添加正好在边界上的建筑
addBuildingAtDistanceAzimuth(area, "边界1", 50, 30); // 正好在距离边界
addBuildingAtDistanceAzimuth(area, "边界2", 50, -30); // 方位角边界
addBuildingAtDistanceAzimuth(area, "边界3", 50, 390); // 方位角循环边界
}
private static void addBuildingAtDistanceAzimuth(ResidentialArea area, String name,
double distance, double azimuth) {
double[] coords = calculateCoordinates(area.centerLat, area.centerLon, distance, azimuth);
area.addBuilding(new Building(name, name, coords[0], coords[1], 50, 15));
}
}
package cell;
public class SmartAzimuthSearch {
/**
* 智能选择搜索方法
*/
public static List<SearchResult> smartSearch(ResidentialArea area,
double centerAzimuth,
double azimuthRange,
double maxDistance) {
// 根据数据规模选择方法
if (area.buildings.size() <= 1000) {
// 小规模数据使用基础方法
return AzimuthRangeSearch.findBuildingsInAzimuthRange(
area, centerAzimuth, azimuthRange, maxDistance);
} else {
// 大规模数据使用优化方法
return OptimizedAzimuthSearch.findBuildingsInAzimuthRangeOptimized(
area, centerAzimuth, azimuthRange, maxDistance);
}
}
/**
* 带缓存的智能搜索
*/
public static class CachedSearcher {
private Map<String, Map<String, List<SearchResult>>> cache = new HashMap<>();
private Map<String, Map<String, List<Building>>> spatialIndexCache = new HashMap<>();
public List<SearchResult> cachedSearch(ResidentialArea area,
double centerAzimuth,
double azimuthRange,
double maxDistance) {
String cacheKey = area.id + "_" + centerAzimuth + "_" + azimuthRange + "_" + maxDistance;
// 检查缓存
if (cache.containsKey(area.id) && cache.get(area.id).containsKey(cacheKey)) {
return cache.get(area.id).get(cacheKey);
}
// 执行搜索
List<SearchResult> results = smartSearch(area, centerAzimuth, azimuthRange, maxDistance);
// 更新缓存
cache.computeIfAbsent(area.id, k -> new HashMap<>()).put(cacheKey, results);
return results;
}
}
}
/**
总结对比
基础方法优势：
-
代码简单，易于维护
-
无预处理时间
-
内存占用低
-
适合小规模数据和实时查询
优化方法优势：
-
查询速度快（10-100倍提升）
-
适合大规模数据
-
扩展性好
-
支持复杂查询场景
选择建议：
-
1000栋建筑以下：使用基础方法
-
1000栋建筑以上：使用优化方法
-
频繁查询：使用带缓存的优化方法
-
实时性要求高：使用基础方法
两种方法在精度上完全一致，主要差异在于性能和资源使用方面。
浙公网安备 33010602011771号