标签: inputstream

注意:我目前正在用java编写代码.我希望将输入数据读入一个字符串,一次一行(或更多),我期待很多总行.

现在我已经实施了

scanner in = new Scanner(System.in)
while (in.hasNextLine()) {
    separated = in.nextLine().split(" ");
    ...
}

因为在行内我的输入是空格分隔的.

不幸的是,有了数百万行,这个过程非常慢,而且他的扫描程序比我的数据处理花费的时间更多,所以我查看了java.io库并发现了一堆可能性,我不确定使用哪一个(ByteArrayInputStream,FileInputStream,BufferedInputStream,PipedInputStream).我应该使用哪一个？

要指定,我的数据是从文本文件传入的,每行有4或6个单词以换行符结束,我需要一次分析一行,将(4或6)个单词设置为数组我可以暂时管理.数据格式:

392903840 a c b 293 32.90
382049804 a c 390
329084203 d e r 489 384.90
...

有没有一种方法,扫描仪可以一次读取1000行左右并提高效率,或者我应该使用哪种数据类型(最小化速度)？

旁注:试验时我试过:

java.io.BufferedReader stdin = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
while(in.ready()){
    separated = in.readLine().split(" ");
    ...
}

哪个效果很好,只是想知道哪一个效果最好,如果有任何方法,比如说,一次读取100行数据然后处理所有内容.寻求最佳解决方案的选择太多.

这是一个代码片段。我对内部缓冲的工作方式感到困惑。

  while(true)
  {
      cout << "Enter a character: ";
      cin.ignore(3, '\n');
      ch = cin.get();  // ch is char type
      cout << "char: ch: " << ch << endl;
  }

实际上cin.ignore(3, '\n')忽略前三个字符，然后获取下一个直接字符。到那一点就好了。因为，我把它保持在一个while循环中，我试图检查ignore()and的行为get()。例如，我检查的输出是

Enter a character: abcd
char: ch: d
Enter a character: efgh
char: ch: e
Enter a character: ijkl
char: ch: i
Enter a character: mnopq
char: ch: m
Enter a character: char: ch: q
Enter a character: 

只是为了检查缓冲，我故意给了 4 个字符而不是 1 …

我查看了at4j和7-Zip-JBinding(他们的javadoc和文档),但是他们似乎无法在没有解压缩的情况下读取(并从归档文件中获取InputStream)

有什么方法我缺少或找不到？

除了提取到临时文件夹以读取它之外的解决方案

我期待在at4j或7-Zip-JBinding中如何做到这一点的答案

换句话说,我想知道如何在at4j或7-Zip-JBinding中使用下面提到的函数

我知道java内置了一个getInputStream,我现在正在使用它

import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
/**
 * get input stream of current file
 * @param path path inside zip
 * @return InputStream
 */
public InputStream getInputStream(String path){
    try {
        ZipEntry entry = zipFile.getEntry(path);
        if(entry!=null){
            return zipFile.getInputStream(entry);
        }
        return new ByteArrayInputStream("Not Found".getBytes());
    } catch (Exception ex) {
        //handle exception
    }

    return null;
}

(^^ zipFile是一个ZipFile对象)

我尝试将字符串发送到我的InputStream：

String _source = "123";
InputStream in = new ByteArrayInputStream(_source.getBytes("UTF-8"));
tempLab2.readR(in);
            
String _source2 = "321";
in.read(_source2.getBytes());
_myClass.readR(in);

当我创建 newByteArrayInputStream并设置_source为参数时，一切正常。我的方法 readR 不等待任何\n或EOF字符并读取123.

请输入 R:

回复: 123

readR 方法：

public void readR(InputStream inpSteram) {
    Scanner tScanner = new Scanner(inpSteram);
    System.out.println("Please enter R:");
    _R = tScanner.nextDouble();
    System.out.println("R: " + _R);
}

但如果我发送_source2，in.read(_source2.getBytes())所以我Scanner正在等待，我只看到

请输入 R:

有任何想法吗？

我在这做错了什么？我收到错误,输入流中没有任何内容,但事实并非如此.文件在那里,标题正确.我想抓住我放在XML文件中的ip地址.是否有更好的方法来解析文件而不是dBuilder.parse(XMLReader.class.getResourceAsStream("C:\\Tools\\CLA\\test.xml"));？

我遇到了这个例外:

Caused by: java.lang.IllegalArgumentException: InputStream cannot be null
    at javax.xml.parsers.DocumentBuilder.parse(Unknown Source)
    at com.Intel.ameier.XMLparser.TryXML(XMLparser.java:17)

这是代码:

import java.io.IOException;
import org.xml.sax.*;
import org.w3c.dom.*;
import javax.xml.parsers.*;

public class XMLparser {

    protected void TryXML() throws ParserConfigurationException, SAXException, IOException{

        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();

        DocumentBuilder dBuilder = builderFactory.newDocumentBuilder();
        Document document = dBuilder.parse(XMLReader.class.getResourceAsStream("C:\\Tools\\test.xml"));
        document.normalize();

        NodeList rootNodes = document.getElementsByTagName("info");
        Node rootNode = rootNodes.item(0);
        Element rootElement = (Element)rootNode;
        NodeList compList = rootElement.getElementsByTagName("computer");
        for(int i = 0;i < compList.getLength(); i++){

            Node computer = compList.item(i);
            Element compElement = (Element)computer; …

在我的一生中，我一直无法找到与我想做的事情相匹配的问题，因此在这里我将解释我的用例。如果您知道某个主题已经涵盖了此问题的答案，请随时将我引向该主题。:)

我有一段代码可以定期（每20秒）将文件上传到Amazon S3。该文件是由另一个进程写入的日志文件，因此此功能实际上是尾随日志的一种方式，以便某人可以半实时读取其内容，而不必直接访问日志所在的计算机。 。

直到最近，我只是一直使用S3 PutObject方法（使用File作为输入）来执行此上传。但是在AWS开发工具包1.9中，这不再起作用，因为如果实际上传的内容大小大于上传开始时承诺的内容长度，则S3客户端会拒绝该请求。此方法在开始流传输数据之前先读取文件的大小，因此，鉴于此应用程序的性质，文件很可能在该点与流的末尾之间已增大。这意味着无论文件有多大，我现在都必须确保仅发送N个字节的数据。

我不需要以任何方式解释文件中的字节，因此我不关心编码。我可以逐字节传输它。基本上，我想要的是一种简单的方法，在该方法中，我可以读取文件的第N个字节，然后使文件终止读取，即使该点之后文件中有更多数据也是如此。（换句话说，将EOF插入流中的特定位置。）

例如，如果开始上载时我的文件长为10000字节，但是在上载期间增长到12000字节，则无论大小更改如何，我都希望以10000字节停止上载。（在随后的上传中，我然后将上传12000字节或更多。）

我尚未找到执行此操作的预制方法-到目前为止，我发现最好的方法似乎是IOUtils.copyLarge（InputStream，OutputStream，offset，length），可以告诉它复制最大的“长度”提供的OutputStream的字节数。但是，copyLarge和BlockObject一样都是阻塞方法（大概在InputStream上调用read（）的形式），因此看来我根本无法使它正常工作。

我还没有找到任何可以执行此操作的方法或预构建的流，因此让我认为我需要编写自己的实现来直接监视已读取的字节数。然后，这可能像BufferedInputStream一样工作，其中每批读取的字节数是缓冲区大小或要读取的剩余字节中的较小者。（例如，在缓冲区大小为3000字节的情况下，我将进行三批处理，每批处理3000字节，然后再批处理1000字节+ EOF。）

有人知道更好的方法吗？谢谢。

编辑为了澄清一下，我已经知道了几种替代方法，但都不是理想的：

（1）我可以在上传文件时锁定它。这样做会导致数据丢失或写入文件的过程中的操作问题。

（2）我可以在上传文件之前创建文件的本地副本。这可能是非常低效的，并且会占用大量不必要的磁盘空间（此文件可能会扩展到几GB的范围，并且正在运行的计算机可能缺少磁盘空间）。

编辑2：根据同事的建议，我的最终解决方案如下所示：

private void uploadLogFile(final File logFile) {
    if (logFile.exists()) {
        long byteLength = logFile.length();
        try (
            FileInputStream fileStream = new FileInputStream(logFile);
            InputStream limitStream = ByteStreams.limit(fileStream, byteLength);
        ) {
            ObjectMetadata md = new ObjectMetadata();
            md.setContentLength(byteLength);
            // Set other metadata as appropriate.
            PutObjectRequest req = new PutObjectRequest(bucket, key, limitStream, md);
            s3Client.putObject(req);
        } // plus exception handling
    }
}

LimitInputStream是我的同事建议的，显然不知道它已被弃用。ByteStreams.limit是当前的番石榴替代品，它可以满足我的要求。感谢大家。

我想使用 Mockito 来模拟 AmazonS3 并测试从中打开一个流，然后在我的代码读取它后验证该流是否已关闭。我还想从流中读取字节。像这样的东西：

    AmazonS3 client = mock(AmazonS3.class);
        when(tm.getAmazonS3Client()).thenReturn(client);
        S3Object response = mock(S3Object.class); 
        when(client.getObject(any(GetObjectRequest.class))).thenReturn(response);
        S3ObjectInputStream stream = mock(S3ObjectInputStream.class); 
        when(response.getObjectContent()).thenReturn(stream);

somehow mock the read method

MyObject me = new MyObject(client);
byte[] bra me.getBytes(File f, offset, length);
assertEquals(length, bra.length);
verify(stream).close();

它是安全的，从一试，与资源的语句返回一个输入流来处理流的结束，一旦调用者已经消耗了呢？

public static InputStream example() throws IOException {
    ...
    try (InputStream is = ...) {
        return is;
    }
}

我正在尝试获取一个PDDocument对象并将其传递给其他模块,InputStream而不将文档保存到文件系统.

现在,我读到PDStream并且有点了解这个的目的.因此,我尝试做这样的事情:

PDStream stream = new PDStream(document);

InputStream is = stream.createInputStream();

但是当我尝试将输入流加载到a中时PDDocument,我收到此错误:

Exception in thread "main" java.io.IOException: Error: End-of-File, expected line
    at org.apache.pdfbox.pdfparser.BaseParser.readLine(BaseParser.java:1111)
    at org.apache.pdfbox.pdfparser.COSParser.parseHeader(COSParser.java:1885)
    at org.apache.pdfbox.pdfparser.COSParser.parsePDFHeader(COSParser.java:1868)
    at org.apache.pdfbox.pdfparser.PDFParser.parse(PDFParser.java:245)
    at org.apache.pdfbox.pdmodel.PDDocument.load(PDDocument.java:1098)
    at org.apache.pdfbox.pdmodel.PDDocument.load(PDDocument.java:995)
    at app.DGDCreator.main(DGDCreator.java:35)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:143)

后来我发现结果文件大小为0kb ...

here is the code.

public static void main(String[] args) throws IOException {

    FileInputStream fis = null;

    fis = new FileInputStream(new File("D:\\za180s.ser"));
    // do something
    fis = new FileInputStream(new File("D:\\za185s.ser"));
    // do something
    fis = new FileInputStream(new File("D:\\za186s.ser"));
    // do something
    fis = new FileInputStream(new File("D:\\za187s.ser"));
    // do something
    fis.close();

}

the problem is : need i call fis.close() method after every "do something" or i just call fis.close() once after all.

ignore whether the close() position in finally and the …