Java 旋转大数据文件

我有一些以制表符分隔的大数据文件。这些文件的行数比列数多几个数量级。问题是我想透视这些文件，但在本例中，“大”被定义为太大而无法在内存中执行此操作

我希望能找到一些关于最快的方法的建议。我主要是在UNIX上使用Java，不过如果出现更快的特定于语言的解决方案（或者使用awk等），我也愿意接受

---

目前，我们在内存中执行此操作，但随着时间的推移，文件的容量将超过我们的内存容量。显然，“买一台更大的机器”是一个解决方案，但目前还不可能

下面的内容可能适合您。此代码首先以

缓冲读取器

的形式打开源文件，然后读取第一行并将其拆分为

\t

结果数组的长度是目标文件的行数。创建了一个新的

FileHolder

对象数组，其中

FileHolder

基本上包含一个文件描述符和一个

ByteBuffer

以用作缓存（这样就不会写入每个字）。创建所有保持器后，将写入第一行

然后再次读取源文件，再逐行拆分，直到为空，并将所有文件持有者附加到源文件

完成后，将创建（最后）目标文件，所有FileHolder实例都将按数组顺序（因此是按行顺序）写入该文件

下面是一个示例代码（很长，也可用）。它当然可以改进（资源并没有真正关闭在正确的位置等），但它是有效的。它在大约25秒内将一个275 MB的文件传输到这里（四核Q6600、4 GB RAM、x86_64 Linux 3.1.2-rc5），并使用Sun（64位）JDK的“脆弱”默认值64 MB运行：

package net.sf.jpam；
导入java.io.BufferedReader；
导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.IOException；
导入java.io.RandomAccessFile；
导入java.io.Reader；
导入java.nio.ByteBuffer；
导入java.nio.channels.FileChannel；
导入java.util.regex.Pattern；
公开期末考试
{
私有静态最终模式选项卡=Pattern.compile（“\t”）；
私有静态类文件持有者
{
私有静态最终字节TABCHAR[]=“\t”.getBytes（）；
//缓冲区大小的大小
专用静态最终int BUFSZ=32768；
//格式化文件的字符串
私有静态最终字符串格式=“/home/fge/t2.txt.%d”；
//拜特缓冲器
私有最终ByteBuffer buf=ByteBuffer.allocate（BUFSZ）；
//文件对象
私人最终文件fd；
//随机存取文件
私有最终随机存取文件；
文件持有者（最终整数索引）
抛出FileNotFoundException
{
最终字符串名称=String.format（格式，索引）；
fd=新文件（名称）；
文件=新的随机访问文件（fd，“rw”）；
}
公共无效写入（最终字符串s）
抛出IOException
{
最终字节[]b=s.getBytes（）；
if（buf.remaining（）package net.sf.jpam;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.regex.Pattern;

public final class Test
{
    private static final Pattern TAB = Pattern.compile("\t");

    private static class FileHolder
    {
        private static final byte TABCHAR[] = "\t".getBytes();
        // Size of the buffer size
        private static final int BUFSZ = 32768;

        // Format string for a file
        private static final String FORMAT = "/home/fge/t2.txt.%d";

        // The ByteBuffer
        private final ByteBuffer buf = ByteBuffer.allocate(BUFSZ);

        // The File object
        private final File fd;

        // RandomAccessFile
        private final RandomAccessFile file;

        FileHolder(final int index)
            throws FileNotFoundException
        {
            final String name = String.format(FORMAT, index);
            fd = new File(name);
            file = new RandomAccessFile(fd, "rw");
        }

        public void write(final String s)
            throws IOException
        {
            final byte[] b = s.getBytes();
            if (buf.remaining() < b.length + TABCHAR.length)
                flush();
            buf.put(b).put(TABCHAR);
        }

        private void flush()
            throws IOException
        {
            file.write(buf.array(), 0, buf.position());
            buf.position(0);
        }

        public void copyTo(final RandomAccessFile dst)
            throws IOException
        {
            flush();
            final FileChannel source = file.getChannel();
            final FileChannel destination = dst.getChannel();
            source.force(false);
            final long len = source.size() - TABCHAR.length;

            source.transferTo(0, len, destination);
            dst.writeBytes("\n");

        }

        public void tearDown()
            throws IOException
        {
            file.close();
            if (!fd.delete())
                System.err.println("Failed to remove file " + fd);
        }

        @Override
        public String toString()
        {
            return fd.toString();
        }
    }

    public static void main(final String... args)
        throws IOException
    {
        long before, after;

        before = System.currentTimeMillis();
        final Reader r = new FileReader("/home/fge/t.txt");
        final BufferedReader reader = new BufferedReader(r);

        /*
         * Read first line, count the number of elements. All elements are
         * separated by a single tab.
         */
        String line = reader.readLine();
        String[] elements = TAB.split(line);

        final int nrLines = elements.length;
        final FileHolder[] files = new FileHolder[nrLines];

        /*
         * Initialize file descriptors
         */
        for (int i = 0; i < nrLines; i++)
            files[i] = new FileHolder(i);


        /*
         * Write first lines, then all others
         */
        writeOneLine(elements, files);

        while ((line = reader.readLine()) != null) {
            elements = TAB.split(line);
            writeOneLine(elements, files);
        }

        reader.close();
        r.close();
        after = System.currentTimeMillis();

        System.out.println("Read time: " + (after - before));

        before = System.currentTimeMillis();
        final RandomAccessFile out = new RandomAccessFile("/home/fge/t2.txt",
            "rw");

        for (final FileHolder file: files) {
            file.copyTo(out);
            file.tearDown();
        }

        out.getChannel().force(false);
        out.close();

        after = System.currentTimeMillis();

        System.out.println("Write time: " + (after - before));
        System.exit(0);
    }

    private static void writeOneLine(final String[] elements,
        final FileHolder[] fdArray)
        throws IOException
    {  
        final int len = elements.length;
        String element;
        FileHolder file;

        for (int index = 0; index < len; index++) {
            element = elements[index];
            file = fdArray[index];
            file.write(element);
        }
    }
}

initially..

private Matcher matcher;
Pattern regexPattern = Pattern.compile( pattern );
matcher = regexPattern.matcher("");

and then for matching pattern.. you do this..

matcher.reset(charBuffer).find()

Pattern.matcher(CharSequence input) {
 Matcher m = new Matcher(this, input);
}