LOF 是一位“密度侦探”，通过比较每个数据点与其邻居的人口密度差异，精准锁定那些“人烟稀少区域”的孤独离群者，像用显微镜观察数据社会的异常个体。

import java.util.*;

public class LOFDetector {
    // 计算两点欧氏距离  
    static double distance(double[] a, double[] b) {
        double sum = 0;
        for (int i=0; i<a.length; i++) 
            sum += Math.pow(a[i]-b[i], 2);
        return Math.sqrt(sum);
    }

    // 获取k近邻索引  
    static List<Integer> getKNN(double[][] data, int targetIdx, int k) {
        PriorityQueue<Map.Entry<Double, Integer>> pq = new PriorityQueue<>(
            (a,b) -> Double.compare(b.getKey(), a.getKey()));
        
        for (int i=0; i<data.length; i++) {
            if (i == targetIdx) continue;
            double dist = distance(data[targetIdx], data[i]);
            pq.offer(new AbstractMap.SimpleEntry<>(dist, i));
            if (pq.size() > k) pq.poll();
        }
        List<Integer> neighbors = new ArrayList<>();
        while (!pq.isEmpty()) neighbors.add(pq.poll().getValue());
        return neighbors;
    }

    // 计算局部可达密度  
    static double lrd(double[][] data, int idx, int k) {
        List<Integer> neighbors = getKNN(data, idx, k);
        double sum = 0;
        for (int n : neighbors) {
            double reachDist = Math.max(
                distance(data[idx], data[n]), 
                distance(data[n], data[getKNN(data, n, k).get(0)])
            );
            sum += reachDist;
        }
        return neighbors.size() / sum;
    }

    // 计算LOF值  
    static double lof(double[][] data, int idx, int k) {
        double lrdP = lrd(data, idx, k);
        List<Integer> neighbors = getKNN(data, idx, k);
        double sum = 0;
        for (int n : neighbors) 
            sum += lrd(data, n, k) / lrdP;
        return sum / neighbors.size();
    }

    public static void main(String[] args) {
        double[][] data = loadSensorData(); // 加载工业传感器数据
        int k = 20; // 邻居数量
        
        for (int i=0; i<data.length; i++) {
            double score = lof(data, i, k);
            System.out.printf("点%d LOF=%.3f %s\n", 
                i, score, score > 1.5 ? "⚠异常" : "");
        }
    }
}

// 距离计算优化：提前缓存距离矩阵  
double[][] distMatrix = new double[n][n];  
Arrays.parallelSetAll(distMatrix, i -> 
    Arrays.stream(data).mapToDouble(d -> distance(data[i], d)).toArray()
);

// 并行化处理  
List<Double> scores = data.parallelStream()
    .mapToDouble(p -> lof(data, indexOf(p), k))
    .boxed().collect(Collectors.toList());