孤立森林是一位“异常猎人“，通过构建随机分割的森林，让异常值如同雪地中的黑点般快速暴露——正常数据需要复杂的迷宫才能困住，而异常点只需几步就会被隔离到孤岛。

import java.util.*;

class IsolationTree {
    static class Node {
        int splitFeature;
        double splitValue;
        Node left, right;
    }

    // 递归构建孤立树  
    Node buildTree(double[][] data, int depth, int maxDepth) {
        if (data.length == 0 || depth >= maxDepth) 
            return null;
        
        Node node = new Node();
        int feature = new Random().nextInt(data[0].length);
        double min = Arrays.stream(data).mapToDouble(d -> d[feature]).min().getAsDouble();
        double max = Arrays.stream(data).mapToDouble(d -> d[feature]).max().getAsDouble();
        
        node.splitFeature = feature;
        node.splitValue = min + (max - min) * new Random().nextDouble();
        
        // 分割数据集
        List<double[]> left = new ArrayList<>();
        List<double[]> right = new ArrayList<>();
        for (double[] d : data) {
            if (d[feature] < node.splitValue) left.add(d);
            else right.add(d);
        }
        
        node.left = buildTree(left.toArray(new double[0][]), depth+1, maxDepth);
        node.right = buildTree(right.toArray(new double[0][]), depth+1, maxDepth);
        return node;
    }

    // 计算路径长度  
    int pathLength(double[] sample, Node node, int depth) {
        if (node == null || node.left == null) return depth;
        if (sample[node.splitFeature] < node.splitValue)
            return pathLength(sample, node.left, depth+1);
        else
            return pathLength(sample, node.right, depth+1);
    }
}

public class IsolationForest {
    List<IsolationTree> trees = new ArrayList<>();
    
    public void fit(double[][] data, int numTrees, int maxDepth) {
        for (int i=0; i<numTrees; i++) {
            IsolationTree tree = new IsolationTree();
            tree.buildTree(data, 0, maxDepth);
            trees.add(tree);
        }
    }
    
    public double anomalyScore(double[] sample) {
        double avgPath = trees.stream()
            .mapToInt(t -> t.pathLength(sample, t.root, 0))
            .average().orElse(0);
        return Math.pow(2, -avgPath / c(data.length)); // c(n)为标准化函数
    }
    
    public static void main(String[] args) {
        double[][] data = loadSensorData(); // 加载工业传感器数据
        IsolationForest forest = new IsolationForest();
        forest.fit(data, 100, 15); // 100棵树，最大深度15
        
        double[] testSample = {23.5, 150.0, 0.98};
        System.out.println("异常得分：" + forest.anomalyScore(testSample));
    }
}

// 并行化训练  
ExecutorService pool = Executors.newFixedThreadPool(8);
trees.parallelStream().forEach(tree -> 
    tree.buildTree(subSample(data), 0, maxDepth)
);

// 内存优化：稀疏采样  
double[][] subSample = Arrays.copyOfRange(data, 0, Math.min(256, data.length));