仓颉语言Array数组底层实现深度解析：从理论到业务实战

// 日志记录结构
struct LogEntry {
    let timestamp: Int64
    let level: String
    let message: String
    let responseTime: Float64
}

// 日志分析器
class LogAnalyzer {
    private var entries: Array<LogEntry> = Array<LogEntry>()
    private let capacity: Int64 = 1000000
    
    init() {
        // 预分配容量减少扩容开销
        entries = Array<LogEntry>(capacity)
    }
    
    // 批量添加日志
    public func addBatch(logs: Array<LogEntry>) {
        for log in logs {
            entries.append(log)
        }
    }
    
    // 按时间窗口统计
    public func analyzeWindow(startTime: Int64, endTime: Int64): Statistics {
        var errorCount: Int64 = 0
        var totalResponseTime: Float64 = 0.0
        var count: Int64 = 0
        
        for entry in entries {
            if entry.timestamp >= startTime && entry.timestamp <= endTime {
                if entry.level == "ERROR" {
                    errorCount += 1
                }
                totalResponseTime += entry.responseTime
                count += 1
            }
        }
        
        return Statistics(
            errorCount: errorCount,
            avgResponseTime: totalResponseTime / Float64(count),
            totalLogs: count
        )
    }
}

// 订单结构
struct Order {
    let orderId: Int64
    let price: Float64
    let quantity: Int64
    let timestamp: Int64
    let side: OrderSide  // BUY or SELL
}

enum OrderSide {
    | BUY
    | SELL
}

// 价格档位
class PriceLevel {
    let price: Float64
    private var orders: Array<Order>
    
    init(price: Float64) {
        this.price = price
        this.orders = Array<Order>(100)  // 预估每档位100笔订单
    }
    
    public func addOrder(order: Order) {
        orders.append(order)
    }
    
    public func getTotalQuantity(): Int64 {
        var total: Int64 = 0
        for order in orders {
            total += order.quantity
        }
        return total
    }
    
    public func matchOrder(quantity: Int64): Array<Order> {
        var matched = Array<Order>()
        var remaining = quantity
        var i: Int64 = 0
        
        while i < orders.size && remaining > 0 {
            let order = orders[i]
            if order.quantity <= remaining {
                matched.append(order)
                remaining -= order.quantity
            } else {
                // 部分成交
                let partialOrder = Order(
                    orderId: order.orderId,
                    price: order.price,
                    quantity: remaining,
                    timestamp: order.timestamp,
                    side: order.side
                )
                matched.append(partialOrder)
                remaining = 0
            }
            i += 1
        }
        
        return matched
    }
}

// 订单簿
class OrderBook {
    private var buyLevels: Array<PriceLevel>
    private var sellLevels: Array<PriceLevel>
    
    init() {
        buyLevels = Array<PriceLevel>()
        sellLevels = Array<PriceLevel>()
    }
    
    public func addOrder(order: Order) {
        let levels = order.side == OrderSide.BUY ? buyLevels : sellLevels
        
        // 查找对应价格档位
        var found = false
        for level in levels {
            if level.price == order.price {
                level.addOrder(order)
                found = true
                break
            }
        }
        
        if !found {
            let newLevel = PriceLevel(order.price)
            newLevel.addOrder(order)
            levels.append(newLevel)
            // 这里可以添加排序逻辑保持价格有序
        }
    }
    
    public func getBestBidPrice(): Float64? {
        if buyLevels.isEmpty() {
            return None
        }
        // 假设已按价格降序排列
        return Some(buyLevels[0].price)
    }
}

// RGB像素结构
struct Pixel {
    var r: UInt8
    var g: UInt8
    var b: UInt8
    
    public func brightness(): Float64 {
        return 0.299 * Float64(r) + 0.587 * Float64(g) + 0.114 * Float64(b)
    }
}

// 图像处理类
class ImageProcessor {
    private var pixels: Array<Pixel>
    private let width: Int64
    private let height: Int64
    
    init(width: Int64, height: Int64) {
        this.width = width
        this.height = height
        let totalPixels = width * height
        this.pixels = Array<Pixel>(totalPixels)
        
        // 初始化为黑色
        for i in 0..totalPixels {
            pixels.append(Pixel(r: 0, g: 0, b: 0))
        }
    }
    
    // 根据坐标访问像素
    public func getPixel(x: Int64, y: Int64): Pixel {
        let index = y * width + x
        return pixels[index]
    }
    
    public func setPixel(x: Int64, y: Int64, pixel: Pixel) {
        let index = y * width + x
        pixels[index] = pixel
    }
    
    // 应用灰度滤镜
    public func applyGrayscale(): ImageProcessor {
        let result = ImageProcessor(width, height)
        
        for i in 0..pixels.size {
            let pixel = pixels[i]
            let gray = UInt8(pixel.brightness())
            result.pixels[i] = Pixel(r: gray, g: gray, b: gray)
        }
        
        return result
    }
    
    // 应用高斯模糊(简化版)
    public func applyBlur(radius: Int64): ImageProcessor {
        let result = ImageProcessor(width, height)
        
        for y in 0..height {
            for x in 0..width {
                var sumR: Int64 = 0
                var sumG: Int64 = 0
                var sumB: Int64 = 0
                var count: Int64 = 0
                
                // 采样周围像素
                for dy in -radius..=radius {
                    for dx in -radius..=radius {
                        let nx = x + dx
                        let ny = y + dy
                        if nx >= 0 && nx < width && ny >= 0 && ny < height {
                            let pixel = getPixel(nx, ny)
                            sumR += Int64(pixel.r)
                            sumG += Int64(pixel.g)
                            sumB += Int64(pixel.b)
                            count += 1
                        }
                    }
                }
                
                result.setPixel(x, y, Pixel(
                    r: UInt8(sumR / count),
                    g: UInt8(sumG / count),
                    b: UInt8(sumB / count)
                ))
            }
        }
        
        return result
    }
    
    // 直方图统计
    public func calculateHistogram(): Array<Int64> {
        var histogram = Array<Int64>(256)
        for i in 0..256 {
            histogram.append(0)
        }
        
        for pixel in pixels {
            let brightness = Int64(pixel.brightness())
            histogram[brightness] += 1
        }
        
        return histogram
    }
}