我之前做过类似的需求，核心是让表头和内容区域的横向滚动完全同步，同时纵向滚动时表头固定在顶部。结合你已经手动完成表头开发的情况，给你一套可行的实现思路和代码示例（以iOS Swift为例，Android思路完全相通）：

一、核心布局结构 #

首先要把表头和内容TableView拆成两个独立容器，但必须保证它们的列宽完全对齐：

• 顶部放置你已开发好的自定义表头View（如果表头需要横向滚动，把它包裹在一个UIScrollView里）
• 下方是承载API数据的内容UITableView，开启横向滚动（只需设置contentSize.width大于容器宽度即可）

二、同步横向滚动逻辑 #

通过监听内容TableView的滚动事件，实时同步表头的横向偏移：

1. 给内容TableView设置UIScrollViewDelegate
2. 在滚动回调方法中，将表头的横向滚动偏移量与内容保持一致，纵向偏移固定为0（确保表头始终钉在顶部）

代码示例（Swift） #

class SyncScrollTableVC: UIViewController, UIScrollViewDelegate {
    // 包裹表头的滚动容器（如果表头不需要单独滚动，可直接用UIView）
    private let headerScrollView = UIScrollView()
    private let contentTableView = UITableView()
    private var dataSource: [TableRowModel] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        loadDataFromAPI()
    }
    
    private func setupUI() {
        // 配置表头滚动容器
        headerScrollView.translatesAutoresizingMaskIntoConstraints = false
        headerScrollView.showsHorizontalScrollIndicator = false
        view.addSubview(headerScrollView)
        
        // 把你已开发好的表头添加到容器中
        let customHeader = YourPrebuiltHeaderView()
        customHeader.translatesAutoresizingMaskIntoConstraints = false
        headerScrollView.addSubview(customHeader)
        
        // 配置内容TableView
        contentTableView.translatesAutoresizingMaskIntoConstraints = false
        contentTableView.delegate = self
        contentTableView.dataSource = self
        contentTableView.register(ContentCell.self, forCellReuseIdentifier: "ContentCell")
        contentTableView.showsHorizontalScrollIndicator = false
        view.addSubview(contentTableView)
        
        // AutoLayout约束配置
        NSLayoutConstraint.activate([
            // 表头约束：固定顶部，宽度匹配父视图，高度自定义
            headerScrollView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
            headerScrollView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            headerScrollView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            headerScrollView.heightAnchor.constraint(equalToConstant: 55),
            
            // 表头内部视图约束：宽度要和内容TableView的可滚动宽度一致
            customHeader.topAnchor.constraint(equalTo: headerScrollView.topAnchor),
            customHeader.leadingAnchor.constraint(equalTo: headerScrollView.leadingAnchor),
            customHeader.trailingAnchor.constraint(equalTo: headerScrollView.trailingAnchor),
            customHeader.bottomAnchor.constraint(equalTo: headerScrollView.bottomAnchor),
            
            // 内容TableView约束：位于表头下方，填满剩余屏幕空间
            contentTableView.topAnchor.constraint(equalTo: headerScrollView.bottomAnchor),
            contentTableView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            contentTableView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            contentTableView.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor)
        ])
    }
    
    // 监听滚动，同步表头横向偏移
    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        // 只同步横向偏移，纵向保持表头固定在顶部
        headerScrollView.contentOffset = CGPoint(x: scrollView.contentOffset.x, y: 0)
    }
    
    // 从API加载表格数据
    private func loadDataFromAPI() {
        guard let apiURL = URL(string: "your-api-endpoint-url") else { return }
        
        URLSession.shared.dataTask(with: apiURL) { [weak self] data, _, error in
            guard let self = self, let data = data, error == nil else {
                print("API请求失败：\(error?.localizedDescription ?? "未知错误")")
                return
            }
            
            do {
                // 解析API返回的数据到自定义模型
                self.dataSource = try JSONDecoder().decode([TableRowModel].self, from: data)
                DispatchQueue.main.async {
                    self.contentTableView.reloadData()
                    // 数据刷新后同步表头与内容的列宽（如果列宽是动态的）
                    self.syncHeaderContentColumnWidths()
                }
            } catch {
                print("数据解析失败：\(error)")
            }
        }.resume()
    }
    
    // 同步表头与内容单元格的列宽，避免滚动错位
    private func syncHeaderContentColumnWidths() {
        guard let sampleCell = contentTableView.dequeueReusableCell(withIdentifier: "ContentCell") as? ContentCell else { return }
        let headerColumns = headerScrollView.subviews.first?.subviews.filter({ $0 is UILabel }) ?? []
        
        for (index, headerLabel) in headerColumns.enumerated() {
            guard let contentColumn = sampleCell.columnLabels[index] else { continue }
            headerLabel.frame.size.width = contentColumn.frame.width
        }
        
        // 更新表头滚动容器的可滚动宽度
        headerScrollView.contentSize = CGSize(width: sampleCell.frame.width, height: headerScrollView.frame.height)
    }
}

// 内容单元格示例（根据你的列数自定义）
class ContentCell: UITableViewCell {
    var columnLabels: [UILabel] = []
    
    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
        super.init(style: style, reuseIdentifier: reuseIdentifier)
        setupColumnLabels()
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    private func setupColumnLabels() {
        // 示例：创建3列，可根据API返回的列数动态调整
        for i in 0..<3 {
            let label = UILabel()
            label.translatesAutoresizingMaskIntoConstraints = false
            label.textAlignment = .center
            contentView.addSubview(label)
            
            NSLayoutConstraint.activate([
                label.topAnchor.constraint(equalTo: contentView.topAnchor, constant: 8),
                label.bottomAnchor.constraint(equalTo: contentView.bottomAnchor, constant: -8),
                label.widthAnchor.constraint(equalToConstant: 150) // 根据业务需求设置列宽
            ])
            
            if i == 0 {
                label.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 8).isActive = true
            } else {
                label.leadingAnchor.constraint(equalTo: columnLabels[i-1].trailingAnchor, constant: 8).isActive = true
            }
            
            columnLabels.append(label)
        }
        
        // 设置单元格可滚动宽度，开启横向滚动
        contentView.frame.size.width = 150*3 + 8*4
    }
}

三、关键注意事项 #

• 列宽严格对齐：必须保证表头每一列的宽度和内容单元格对应列的宽度完全一致，否则同步滚动时会出现错位
• 性能优化：滚动回调里的操作要尽量轻量，避免在scrollViewDidScroll中做复杂计算或频繁UI更新
• Android平台适配：思路和iOS一致，用HorizontalScrollView包裹表头和内容RecyclerView，监听RecyclerView的滚动事件，调用headerScrollView.scrollTo(contentScrollView.getScrollX(), 0)实现同步
• API数据适配：加载完API数据后，一定要刷新内容TableView，同时同步更新表头的列宽（如果列宽是动态变化的）

内容的提问来源于stack exchange，提问作者saurabh tripathi