以下是一个使用Arrow和Java从流/文件中填充VectorSchemaRoot的示例代码：

import org.apache.arrow.memory.BufferAllocator;
import org.apache.arrow.vector.*;
import org.apache.arrow.vector.ipc.ArrowFileReader;
import org.apache.arrow.vector.ipc.ArrowReader;
import org.apache.arrow.vector.ipc.SeekableReadChannel;
import org.apache.arrow.vector.ipc.message.ArrowBlock;
import org.apache.arrow.vector.ipc.message.ArrowRecordBatch;
import org.apache.arrow.vector.types.pojo.Field;
import org.apache.arrow.vector.types.pojo.Schema;

import java.io.File;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.nio.file.StandardOpenOption;
import java.util.List;
import java.util.Vector;

public class ArrowVectorSchemaRootExample {
  
  public static void main(String[] args) {
    // 创建一个BufferAllocator，用于分配内存
    try (BufferAllocator allocator = new RootAllocator(Long.MAX_VALUE)) {
      // 从文件中创建SeekableReadChannel
      File file = new File("path/to/arrow/file.arrow");
      FileChannel fileChannel = FileChannel.open(file.toPath(), StandardOpenOption.READ);
      SeekableReadChannel seekableReadChannel = new SeekableReadChannel(fileChannel);
      
      // 创建ArrowFileReader并打开文件
      try (ArrowReader arrowReader = new ArrowFileReader(seekableReadChannel, allocator)) {
        // 从文件中读取模式（schema）
        Schema schema = arrowReader.getVectorSchemaRoot().getSchema();
        
        // 创建VectorSchemaRoot来填充数据
        try (VectorSchemaRoot vectorSchemaRoot = new VectorSchemaRoot(schema, allocator)) {
          // 检索所有的字段
          List fields = schema.getFields();
          
          // 填充数据
          while (arrowReader.loadNextBatch()) {
            ArrowBlock block = arrowReader.getRecordBlock();
            // 从block中读取记录批次
            ArrowRecordBatch recordBatch = arrowReader.getVectorSchemaRoot().getRecordBatch(block);
            
            // 将记录批次复制到VectorSchemaRoot
            vectorSchemaRoot.setRowCount(recordBatch.getLength());
            for (Field field : fields) {
              ValueVector targetVector = vectorSchemaRoot.getVector(field.getName());
              ValueVector sourceVector = recordBatch.getVectors()[field.getIndex()];
              targetVector.setInitialCapacity(recordBatch.getLength());
              targetVector.allocateNewSafe();
              targetVector.copyFromSafe(0, 0, sourceVector);
              targetVector.setValueCount(recordBatch.getLength());
            }
            
            // 在VectorSchemaRoot中处理填充的数据
            processVectorSchemaRoot(vectorSchemaRoot);
          }
        }
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  
  private static void processVectorSchemaRoot(VectorSchemaRoot vectorSchemaRoot) {
    // 在这里处理填充的数据
    // 例如，可以通过以下方式访问每个字段的数据：
    List fieldVectors = vectorSchemaRoot.getFieldVectors();
    for (FieldVector fieldVector : fieldVectors) {
      // 处理每个字段向量的数据
      // 例如，可以通过以下方式访问字段向量的数据：
      int valueCount = fieldVector.getValueCount();
      for (int i = 0; i < valueCount; i++) {
        Object value = fieldVector.getObject(i);
        // 处理每个值
      }
    }
  }
}

在上述代码中，我们首先创建了一个BufferAllocator来分配内存。然后，我们从文件中创建了一个SeekableReadChannel，然后使用ArrowFileReader打开文件。然后，我们可以使用arrowReader.getVectorSchemaRoot().getSchema()从文件中读取模式（schema）。

接下来，我们创建了一个VectorSchemaRoot来填充数据。我们使用arrowReader.loadNextBatch()循环读取文件中的每个记录批次（batch）。在每个批次中，我们使用arrowReader.getVectorSchemaRoot().getRecordBatch(block)从ArrowBlock中读取记录批次。然后，我们将记录批次复制到VectorSchemaRoot中。

最后，我们可以在processVectorSchemaRoot()方法中处理填充的数据。在这个方法中，我们可以访问每个字段的数据，并对其进行处理。