NIO 实现大文件切割

已于 2024-01-16 12:11:11 修改
阅读量416 收藏
点赞数 1
文章标签： java jvm 开发语言
于 2023-04-07 12:59:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44588243/article/details/130009748
版权

通过NIO的FileChannel实现文件的切割。

指定大小

package com.ityj.nio;

import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StopWatch;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;

@Slf4j
public class FileSplitBySizeExample {

    public static void main(String[] args) throws IOException {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        String inputFilePath = "D:\\迅雷云盘\\国蒙双语.4K.H265.AAC-YYDS.mkv.xltd";
        String outputDirPath = "D:\\XmpCache";
        long maxFileSize = 1024 * 1024 * 1024L; // 每个输出文件的最大大小（1GB）
        Path inputFile = Paths.get(inputFilePath);
        ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);

        try (FileChannel inputFileChannel = FileChannel.open(inputFile, StandardOpenOption.READ)) {
            List<Path> outputFiles = new ArrayList<>();
            Path outputFile = null;
            long outputFileSize = 0;
            int fileCount = 0;

            while (inputFileChannel.read(buffer) > 0) {
                buffer.flip();

                while (buffer.hasRemaining()) {
                    if (outputFile == null || outputFileSize >= maxFileSize) {
                        outputFile = Paths.get(outputDirPath, "output_" + fileCount++);
                        outputFiles.add(outputFile);
                        outputFileSize = 0;
                    }

                    try (FileChannel outputFileChannel = FileChannel.open(outputFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
                        outputFileSize += outputFileChannel.write(buffer);
                    }
                }

                buffer.clear();
            }
        }
        stopWatch.stop();
        System.out.println("Split file completed.");
        log.info("Time cost:{}", stopWatch.getTotalTimeSeconds());
    }

}

指定行数

// todo error

package com.ityj.nio;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

public class FileSplitByLinesExample {
    public static void main(String[] args) throws IOException {
        Path inputFilePath = Paths.get( "D:\\XmpCache\\aa.txt");
        Path outputDirPath = Paths.get("D:\\XmpCache");
        int maxLines = 1000000; // 每个输出文件的最大行数
        Charset charset = Charset.forName("UTF-8");
        CharsetDecoder decoder = charset.newDecoder();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        FileChannel inputChannel = FileChannel.open(inputFilePath);
        List<String> lines = new ArrayList<>();
        int fileCount = 0;
        int lineCount = 0;
        int bytesRead;
        while ((bytesRead = inputChannel.read(buffer)) != -1) {
            buffer.flip();
            String data = decoder.decode(buffer).toString();
            String[] splitData = data.split("\r\n");
            for (String s : splitData) {
                if (lineCount >= maxLines) {
                    writeOutputFile(outputDirPath, fileCount++, lines);
                    lines.clear();
                    lineCount = 0;
                }
                lines.add(s);
                lineCount++;
            }
            buffer.clear();
        }
        if (!lines.isEmpty()) {
            writeOutputFile(outputDirPath, fileCount, lines);
        }
        inputChannel.close();
        System.out.println("Split file completed.");
    }

    private static void writeOutputFile(Path outputDirPath, int fileCount, List<String> lines) throws IOException {
        Path outputFilePath = outputDirPath.resolve("output_" + fileCount);
        Files.write(outputFilePath, lines, Charset.forName("UTF-8"));
    }
}

适配gzip

package com.ityj.utils;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class FileSplitter {

    private static final int BUFFER_SIZE = 1024 * 1024;
    private static final String GZIP_EXTENSION = ".gz";

    public static void splitFileByLineCount(File inputFile, int linesPerFile) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream(inputFile))));
        FileChannel inputChannel = new FileInputStream(inputFile).getChannel()) {
            String line;
            int lineCount = 0;
            int fileNumber = 0;
            ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
            GZIPOutputStream gzipOut = null;
            while ((line = reader.readLine()) != null) {
                if (lineCount % linesPerFile == 0) {
                    if (gzipOut != null) {
                        gzipOut.finish();
                        gzipOut.close();
                    }
                    fileNumber++;
                    String outputFilePath = inputFile.getParent() + "/" + inputFile.getName() + "." + fileNumber + GZIP_EXTENSION;
                    gzipOut = new GZIPOutputStream(new FileOutputStream(outputFilePath));
                }
                byte[] lineBytes = (line + "\n").getBytes();
                if (buffer.remaining() < lineBytes.length) {
                    buffer.flip();
                    inputChannel.write(buffer);
                    buffer.clear();
                }
                buffer.put(lineBytes);
                lineCount++;
            }
            if (gzipOut != null) {
                gzipOut.finish();
                gzipOut.close();
            }
            buffer.flip();
            inputChannel.write(buffer);
        }
    }

    public static void main(String[] args) throws IOException {
        File inputFile = new File("inputFile.gz");
        int linesPerFile = 100000;
        splitFileByLineCount(inputFile, linesPerFile);
    }
}

简单按行读文件

public static List<String> readFileWithNIO(String filePath) {
        List<String> lines = new ArrayList<>();

        try (FileChannel fileChannel = FileChannel.open(Path.of(filePath), StandardOpenOption.READ)) {
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024); // Buffer to hold data
            StringBuilder lineBuilder = new StringBuilder(); // StringBuilder to accumulate a line

            int bytesRead = fileChannel.read(byteBuffer); // Read first chunk of data from file

            while (bytesRead != -1) { // Loop until end of file
                byteBuffer.flip(); // Switch buffer from writing mode to reading mode

                while (byteBuffer.hasRemaining()) { // Loop until buffer is empty
                    byte b = byteBuffer.get(); // Get one byte

                    if (b == '\n') { // End of line
                        String line = lineBuilder.toString();
                        lineBuilder.setLength(0); // Reset the StringBuilder for the next line
                        // Process the line as needed
                        lines.add(line);
                    } else { // Add the byte to the StringBuilder
                        lineBuilder.append((char) b);
                    }
                }

                byteBuffer.clear(); // Switch buffer back to writing mode
                bytesRead = fileChannel.read(byteBuffer); // Read next chunk of data from file
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return lines;
    }

#!/bin/bash

# 输入文件名和输出文件名
input_file="input.txt"
output_file="output.txt"

# 如果输出文件已经存在，则删除它
if [ -f $output_file ]; then
    rm $output_file
fi

# 逐行读取输入文件，并对每行按照 | 进行分隔
while read line
do
    # 使用 awk 命令对每行进行分隔
    # 如果第三个字段不是 A999，则将该行写入输出文件
    # 注意，此处的 $0 代表整行文本
    echo $line | awk -F "|" '{ if ($3 != "A999") print $0 }' >> $output_file
done < $input_file


#!/bin/bash

# Input file name
input_file="input.txt"

# Output file name
output_file="output.txt"

# Loop through each line of the input file
while IFS= read -r line
do
  # Split the line into fields using the "|" delimiter
  fields=($(echo "$line" | tr '|' '\n'))

  # Check if the third field is "A999"
  if [ "${fields[2]}" != "A999" ]; then
    # If the third field is not "A999", output the line to the output file
    echo "$line" >> "$output_file"
  fi
done < "$input_file"

压缩一个大文件(gz)

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.zip.GZIPOutputStream;

public class GzipFileCompressor {
    public static void main(String[] args) {
        String sourceFilePath = "path/to/your/largefile.txt";
        String compressedFilePath = "path/to/your/compressedfile.gz";

        try (
            FileInputStream fileInputStream = new FileInputStream(sourceFilePath);
            FileChannel fileInputChannel = fileInputStream.getChannel();
            GZIPOutputStream gzipOutputStream = new GZIPOutputStream(new FileOutputStream(compressedFilePath))
        ) {
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
            while (fileInputChannel.read(buffer) != -1) {
                buffer.flip();
                byte[] data = new byte[buffer.limit()];
                buffer.get(data);
                gzipOutputStream.write(data);
                buffer.clear();
            }

            System.out.println("File compressed successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.zip.GZIPOutputStream;

public class NIOGzipFileCompressor {
    public static void main(String[] args) {
        String sourceFilePath = "path/to/your/largefile.txt";
        String compressedFilePath = "path/to/your/compressedfile.gz";

        try (
            FileInputStream fileInputStream = new FileInputStream(sourceFilePath);
            FileOutputStream fileOutputStream = new FileOutputStream(compressedFilePath);
            GZIPOutputStream gzipOutputStream = new GZIPOutputStream(fileOutputStream);
            FileChannel inChannel = fileInputStream.getChannel();
            FileChannel outChannel = fileOutputStream.getChannel()
        ) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while (inChannel.read(buffer) != -1) {
                buffer.flip(); // Switch to read mode
                outChannel.write(buffer);
                buffer.clear(); // Switch to write mode
            }
            
            System.out.println("File compressed successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


ByteBuffer buffer = ByteBuffer.allocate(8192); // 8KB缓冲区大小
            while (inputChannel.read(buffer) > 0 || buffer.position() > 0) {
                buffer.flip();
                gzipOut.write(buffer.array(), 0, buffer.limit());
                buffer.clear();
            }



String url = "http://192.168.142.129:9000/api/rules/search";
String token = "8eb31bf43a5bc196cb9eed880be4a46651fbc8c8:";
String basicAuth = "Basic " + new String(Base64.getEncoder().encode(token.getBytes("UTF-8")));
HttpHeaders requestHeaders = new HttpHeaders();
//添加认证的请求头
requestHeaders.add("Authorization", basicAuth);
HttpEntity<String> requestEntity = new HttpEntity<String>(null, requestHeaders);
ResponseEntity<JSONObject> repsonse = restTemplate.exchange(url, HttpMethod.GET, requestEntity, JSONObject.class);
JSONObject body = repsonse.getBody();
return body;

#!/bin/bash

output_file="/path/to/your/directory/output.log"

for ((count=0; count<250; count++)); do
    current_time=$(date +"%Y-%m-%d %H:%M:%S")
    echo "[$current_time] $(zing-ps)" >> "$output_file"  # 追加带时间戳的输出到文件
    sleep 60
done


import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class GenericSplitCollectionExample {

    public static void main(String[] args) {
        // 创建一个示例列表
        List<String> originalList = List.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t");

        // 将列表分为小集合
        int batchSize = 5; // 定义小集合的大小
        Map<Integer, List<String>> splitCollections = splitCollection(originalList, batchSize);

        // 打印结果
        splitCollections.forEach((key, value) -> System.out.println("Collection " + key + ": " + value));
    }

    // 将列表分为小集合
    private static <T> Map<Integer, List<T>> splitCollection(List<T> list, int batchSize) {
        return list.stream()
                .collect(Collectors.groupingBy(index -> (list.indexOf(index)) / batchSize));
    }
}



package com.ityj.algorithm.gz;

import java.io.*;
import java.util.zip.GZIPOutputStream;

public class CompressFileToGz {
    public static void main(String[] args) {
        // 指定输入文件路径
        String inputFilePath = "data.dat";

        // 指定输出文件路径
        String outputFilePath = "data.dat.gz";

        // 使用try-with-resources确保资源正确关闭
        try (FileInputStream fis = new FileInputStream(inputFilePath);
             GZIPOutputStream gzipOS = new GZIPOutputStream(new FileOutputStream(outputFilePath))) {

            // 设置缓冲区大小
            byte[] buffer = new byte[1024];
            int bytesRead;

            // 从输入文件读取数据并写入GZ压缩输出流
            while ((bytesRead = fis.read(buffer)) != -1) {
                gzipOS.write(buffer, 0, bytesRead);
            }

            System.out.println("文件已成功压缩成 " + outputFilePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


package com.ityj.algorithm.gz;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class WriteCollectionToDatFile {
    public static void main(String[] args) {
        // 创建一个ArrayList并添加一些数据
        ArrayList<String> dataList = new ArrayList<>();
        dataList.add("Item 1");
        dataList.add("Item 2");
        dataList.add("Item 3");

        // 指定输出文件的路径
        String filePath = "data.dat";

        // 使用try-with-resources确保资源正确关闭
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            // 按行写入集合数据
            for (String item : dataList) {
                writer.write(item);
                writer.newLine(); // 换行
            }

            System.out.println("集合数据已成功写入到 " + filePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


package com.ityj.algorithm.gz;

import java.io.*;
import java.util.ArrayList;
import java.util.zip.GZIPOutputStream;

public class WriteCollectionToGzInMemory {
    public static void main(String[] args) {
        // 创建一个ArrayList并添加一些数据
        ArrayList<String> dataList = new ArrayList<>();
        dataList.add("Item 1");
        dataList.add("Item 2");
        dataList.add("Item 3");

        // 使用try-with-resources确保资源正确关闭
        try (ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
             GZIPOutputStream gzipOS = new GZIPOutputStream(byteStream)) {

            // 按行写入集合数据到Gzip压缩输出流
            try (PrintWriter writer = new PrintWriter(new OutputStreamWriter(gzipOS))) {
                for (String item : dataList) {
                    writer.println(item);
                }
            }

            // 获取压缩后的字节数组
            byte[] compressedData = byteStream.toByteArray();

            // 将压缩后的数据保存到文件
            String gzFilePath = "data.dat.gz";
            try (FileOutputStream fos = new FileOutputStream(gzFilePath)) {
                fos.write(compressedData);
            }

            System.out.println("集合数据已成功写入到 " + gzFilePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}




import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.stream.IntStream;

public class WriteLargeDataFileExample {
    public static void main(String[] args) {
        // 指定要写入的文件路径
        Path filePath = Path.of("large_data_file.txt");

        try (BufferedWriter writer = Files.newBufferedWriter(filePath, StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
            // 生成要写入文件的大量数据，这里使用简单的示例，写入十亿行每行10个字段的数据
            IntStream.range(0, 1000000000).forEach(i -> {
                StringBuilder line = new StringBuilder();
                IntStream.range(0, 10).forEach(j -> line.append("Field").append(j + 1).append("\t")); // 用制表符分隔字段
                line.append(System.lineSeparator());

                try {
                    writer.write(line.toString());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            System.out.println("大数据文件写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.stream.IntStream;

public class WriteBillionDataWithNIO {
    public static void main(String[] args) {
        // 指定要写入的文件路径
        Path filePath = Path.of("billion_data_nio.txt");

        try (FileChannel channel = FileChannel.open(filePath, StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
            // 生成十亿条包含10个字段的数据
            for (int i = 0; i < 1000000000; i++) {
                StringBuilder line = new StringBuilder();
                for (int j = 0; j < 10; j++) {
                    // 生成字段数据，这里简单地使用数字和逗号分隔
                    line.append("Field").append(j + 1).append(",");
                }

                // 将数据写入ByteBuffer
                ByteBuffer buffer = ByteBuffer.wrap(line.toString().getBytes());

                // 将ByteBuffer写入文件Channel
                channel.write(buffer);

                // 写入换行符
                channel.write(ByteBuffer.wrap(System.lineSeparator().getBytes()));
            }

            System.out.println("十亿条数据使用NIO写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
惊涛骇浪、
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java大文件切割_Java实现大文件的切割与合并操作示例
weixin_42422362的博客
02-13 307
本文实例讲述了Java实现大文件的切割与合并操作。分享给大家供大家参考，具体如下：这里实现对大文件的切割与合并。按指定个数切(如把一个文件切成10份)或按指定大小切(如每份最大不超过10M)，这两种方式都可以。在这里我只是给大家写下我自己的一点简单的代码：package io2;import java.io.File;import java.io.FileInputStream;import ja...
java切割打文本文件
qq_36364521的博客
04-21 886
package com.sgcc.controller; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public cla...
最全通过NIO分割文件和合并文件和计算文件md5，2024年最新阿里、百度、美团、携程、蚂蚁面经分享
最新发布
2401_84520093的博客
05-11 388
第三，到了合适的年纪，后续不知道该如何发展，转型管理，还是加强技术研究。说不定能改变你现在的状态呢！如果大家觉得自己在网上找的资料非常杂乱、不成体系的话，我也分享一套给大家，比较系统，我平常自己也会经常研读。很多朋友不是没有资料，大多都是有几十上百个G，但是杂乱无章，不知道怎么看从哪看起，甚至是看后就忘。在当下这个信息共享的时代，很多资源都可以在网络上找到，只取决于你愿不愿意找或是找的方法对不对了。只有系统，有方向的学习，才能在段时间内迅速提高自己的技术。第二，开发几年，不知道如何进阶更进一步，比较迷茫。
文件分割器（IO and NIO 两个版本）
01-16
这是用java做的文件分割器，有两个版本，一个使用IO，另一个使用NIO，可以分割任意格式的文件。是在Linux下的eclipse中做的。
Java读取 写入 大文件 （上亿行数据）
吉他程序员的博客
06-17 1万+
Path 类是jdk7新增加的特性之一，用来代替java.io.File类。 之所以新增这个类，是由于java.io.File类有很多缺陷： 1.java.io.File类里面很多方法失败时没有异常处理，或抛出异常 java.io.File.delete()方法返回一个布尔值指示成功或失败但是没有失败原因 2.Path 速度快，方便。Path 操作1.删除文件 2.遍历目录,不包括子
多线程 + java nio 实现按行读取并处理超大文件
C18298182575的博客
11-02 2094
参考： https://blog.csdn.net/qq_25473933/article/details/79603253 https://blog.csdn.net/icy_1992/article/details/41869365
【JAVA使用笔记】——大文件分割、内容处理
NEU_LightBulb的博客
03-24 1083
简述 对于提高大文件读写效率的方法网上数不胜数，我这里选择了使用NIO结合多线程处理的方式。 通过 io 的RandomAccessFile实现对大文件按行分片。 通过 nio 的MappedByteBuffer 和 ByteBuffer 对缓冲区内的数据进行处理 通过nio 的 FileChannel，实现大文件的读写。 分片 实现在限制的分片大小（partitionSize）...
NIO(byteBuffer)按行读取文件
08-31
使用nio byteBuffer 实现按行读取文件(大文件) 在window/linux/macOS上均测试通过 对于中文乱码也已处理成功 完整注释，可随需求更改 有问题请邮件:mly610865580@126.com
如何用Java来进行文件切割和简单的内容过滤的实现
08-31
Java文件切割和内容过滤是常见的文件操作需求，尤其在处理大量数据或大文件时显得尤为重要。本文将介绍如何使用Java实现这些功能，主要基于提供的代码示例进行解析。 首先，文件切割是将一个大文件分割成多个小文件...
java 文件切割合并
03-16
在Java编程语言中，文件切割和合并是...总之，Java的IO流为我们提供了强大的文件操作能力，不论是文件切割还是合并，都能够通过合理的编程实现。理解并熟练运用这些API，能帮助开发者在各种场景下有效地处理文件数据。
java实现文件的分割.rar
12-17
2. **文件定位(seek())**: `RandomAccessFile`中的`seek(long position)`方法用于设置文件指针到指定的字节位置，这是实现文件切割的核心功能。通过改变指针的位置，我们可以选择性地读取或写入文件的特定部分。 3....
NIO处理大文件
05-29
NIO 处理大文件
JAVA NIO 按行读取大文件，支持 GB级别
08-29
本类，是专门为了处理大文件，按行读取开发的类。 采用读文件的缓存 fbb 1024*5 行缓存 bb 256 字节 设计思想： 每次通过nio读取字节到 fbb中 然后对fbb自己中的内容进行行判断即 10 回车 13 行号 0 文件结束 这样字节的判断，然后 返回行 如果 到达 fbb的结尾 还没有结束，就再通过nio读取一段字节，继续处理。 由于对于本程序 116个字节以上的行才有意义，所以 在next实现方法中，有对 116 长度的判断，否则返回 null
JAVA NIO 按行读取大文件支持 GB级别-修正版
10-24
本类，是专门为了处理大文件，按行读取开发的类。 采用读文件的缓存 fbb 1024*5 行缓存 bb 256 字节 设计思想： 每次通过nio读取字节到 fbb中 然后对fbb自己中的内容进行行判断即 10 回车 13 行号 0 文件结束 这样字节的判断，然后 返回行 如果 到达 fbb的结尾 还没有结束，就再通过nio读取一段字节，继续处理。 由于对于本程序 116个字节以上的行才有意义，所以 在next实现方法中，有对 116 长度的判断，否则返回 null 修正了之前版本中的问题： 修正后的方法 private int readByte() throws IOException{ fbb.rewind(); fbb.clear(); if(this.fc.read(fbb)==-1){ EOF=true; return 0;}else{ fbb.flip(); return fbb.limit(); } } 把 fbb.position() 改成 fbb.limit()
nio大文件分批传输
qq_40996012的博客
06-29 293
nio文件传输
android解析JSON数据
2401_84132644的博客
04-30 58
/ TODO 状态处理 500 200。
Java NIO内存映射---上G大文件处理
热门推荐
Evankaka的专栏
09-16 1万+
本文主要讲了java中内存映射的原理及过程，与传统IO进行了对比，最后，用实例说明了结果。
通过NIO分割文件和合并文件和计算文件md5
Android菜鸟的专栏
11-25 948
NIO就是香啊，不但效率高，而且写起来代码也少，示例如下： object FileUtil { fun getFileMd5(file: File): String { // 获取md5签名 val md5Bytes = FileInputStream(file).channel.use { channel -> val byteBuffer = channel.map(FileChannel.MapMode.READ_ONLY, 0,
java 切割音频文件
02-21
在Java中，可以使用Java Sound API来切割音频文件。下面是一个简单的示例代码，演示如何使用Java Sound API来切割音频文件： ```java import javax.sound.sampled.*; import java.io.File; import java.io.IOException; public class AudioCutter { public static void main(String[] args) { String inputFile = "input.wav"; // 输入音频文件路径 String outputFile = "output.wav"; // 输出音频文件路径 int startSecond = 10; // 起始时间（秒） int endSecond = 20; // 结束时间（秒） try { AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(new File(inputFile)); AudioFormat format = audioInputStream.getFormat(); long frames = audioInputStream.getFrameLength(); double durationInSeconds = (frames + 0.0) / format.getFrameRate(); // 计算起始和结束帧数 int startFrame = (int) (startSecond * format.getFrameRate()); int endFrame = (int) (endSecond * format.getFrameRate()); // 限制起始和结束帧数在有效范围内 startFrame = Math.max(0, startFrame); endFrame = Math.min((int) frames, endFrame); // 计算切割后的帧数 int cutLength = endFrame - startFrame; // 创建切割后的音频流 AudioInputStream cutAudioInputStream = new AudioInputStream(audioInputStream, format, cutLength); AudioSystem.write(cutAudioInputStream, AudioFileFormat.Type.WAVE, new File(outputFile)); System.out.println("音频切割成功！"); } catch (UnsupportedAudioFileException | IOException e) { e.printStackTrace(); } } } ``` 上述代码中，我们首先使用`AudioSystem.getAudioInputStream()`方法获取音频文件的输入流。然后，我们获取音频的格式和帧数，并根据起始和结束时间计算出对应的起始和结束帧数。接下来，我们使用`AudioInputStream`的构造函数创建一个切割后的音频流，并使用`AudioSystem.write()`方法将切割后的音频流写入到输出文件中。 请注意，上述代码仅适用于切割WAV格式的音频文件。如果要切割其他格式的音频文件，需要相应地调整代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值