标签: inputstream

我正在使用Java将文件上传到S3 - 这是我到目前为止所得到的:

AmazonS3 s3 = new AmazonS3Client(new BasicAWSCredentials("XX","YY"));

List<Bucket> buckets = s3.listBuckets();

s3.putObject(new PutObjectRequest(buckets.get(0).getName(), fileName, stream, new ObjectMetadata()));

正在上传文件,但在我未设置内容长度时会引发警告:

com.amazonaws.services.s3.AmazonS3Client putObject: No content length specified for stream > data.  Stream contents will be buffered in memory and could result in out of memory errors.

Run Code Online (Sandbox Code Playgroud)

这是我上传的文件,stream变量是一个InputStream,我可以从中得到这样的字节数组:IOUtils.toByteArray(stream).

所以,当我尝试设置内容长度和MD5(从这里取得)像这样:

// get MD5 base64 hash
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
messageDigest.reset();
messageDigest.update(IOUtils.toByteArray(stream));
byte[] resultByte = messageDigest.digest();
String hashtext = new String(Hex.encodeHex(resultByte));

ObjectMetadata meta = new ObjectMetadata(); …

java9中的更新:https://docs.oracle.com/javase/9​​/docs/api/java/io/InputStream.html#transferTo-java.io.OutputStream-

我看到了一些相似的,但不是我需要的线程.

我有一个服务器,它基本上从客户端,客户端A接收输入,并逐字节转发到另一个客户端,客户端B.

我想将客户端A的输入流与客户端B的输出流连接起来.这可能吗？有什么方法可以做到这一点？

此外,这些客户端正在发送彼此有时间敏感的消息,因此缓冲不会.我不想要500的缓冲区和客户端发送499个字节,然后我的服务器在转发500个字节时保持关闭,因为它没有收到填充缓冲区的最后一个字节.

现在,我正在解析每条消息以找到它的长度,然后读取长度字节,然后转发它们.我想(并测试)这比读取一个字节并反复转发一个字节更好,因为这将非常慢.我也不想使用缓冲区或计时器,因为我在上一段中说过 - 我不希望消息等待很长时间才能通过,因为缓冲区未满.

这样做的好方法是什么？

我在我的Android应用程序中使用OKHTTP客户端进行网络连接.

此示例显示如何上载二进制文件.我想知道如何使用OKHTTP客户端获取二进制文件下载的输入流.

以下是该示例的列表:

public class InputStreamRequestBody extends RequestBody {

    private InputStream inputStream;
    private MediaType mediaType;

    public static RequestBody create(final MediaType mediaType, 
            final InputStream inputStream) {
        return new InputStreamRequestBody(inputStream, mediaType);
    }

    private InputStreamRequestBody(InputStream inputStream, MediaType mediaType) {
        this.inputStream = inputStream;
        this.mediaType = mediaType;
    }

    @Override
    public MediaType contentType() {
        return mediaType;
    }

    @Override
    public long contentLength() {
        try {
            return inputStream.available();
        } catch (IOException e) {
            return 0;
        }
    }

    @Override
    public void writeTo(BufferedSink sink) throws IOException {
        Source source …

我对使用Java InputStreams时close()方法的用法有一些疑问.从我看到和从大多数开发人员那里读到的内容,你应该总是在不再需要的时候在InputStream上显式调用close().但是,今天我正在研究使用Java属性文件,我发现的每个例子都有这样的:

Properties props = new Properties();
try {
    props.load(new FileInputStream("message.properties"));
    //omitted.
} catch (Exception ex) {}

使用上面的示例,无法显式调用close(),因为InputStream在使用后无法访问.我已经看到了许多类似的InputStreams用法,尽管它似乎与大多数人对明确关闭的说法相矛盾.我通读了Oracle的JavaDocs,并没有提到Properties.load()方法是否关闭了InputStream.我想知道这是否普遍可以接受,或者是否更喜欢做更像以下的事情:

Properties props = new Properties();
InputStream fis = new FileInputStream("message.properties");
try {
    props.load(fis);
    //omitted.
} catch (Exception ex) {
    //omitted.
} finally {
    try {
        fis.close();
    } catch (IOException ioex) {
        //omitted.
    }
}

哪种方式更好和/或更有效？或者它真的重要吗？

我目前的情况是:我必须读取文件并将内容放入InputStream.之后我需要把它的内容InputStream放到一个字节数组中,这个数组需要(据我所知)的大小InputStream.有任何想法吗？

根据要求,我将显示我从上传文件创建的输入流

InputStream uploadedStream = null;
FileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);
java.util.List items = upload.parseRequest(request);      
java.util.Iterator iter = items.iterator();

while (iter.hasNext()) {
    FileItem item = (FileItem) iter.next();
    if (!item.isFormField()) {
        uploadedStream = item.getInputStream();
        //CHANGE uploadedStreambyte = item.get()
    }
}

该请求是一个HttpServletRequest对象,它是象FileItemFactory和ServletFileUpload是从Apache通用FileUpload包.

我正在阅读一堆由空格分隔的整数或使用标准中的换行符Scanner(System.in).

有没有更快的方法在Java中这样做？

我试图通过使用FileInputStream将文件读入数组,并且~800KB文件花了大约3秒来读入内存.然后我尝试了相同的代码,除了将FileInputStream包装到BufferedInputStream中,它花了大约76毫秒.为什么使用BufferedInputStream以字节逐字节读取文件,即使我仍在逐字节读取它？这是代码(代码的其余部分完全不相关).请注意,这是"快速"代码.如果你想要"慢"代码,你可以删除BufferedInputStream:

InputStream is = null;

    try {
        is = new BufferedInputStream(new FileInputStream(file));

        int[] fileArr = new int[(int) file.length()];

        for (int i = 0, temp = 0; (temp = is.read()) != -1; i++) {
            fileArr[i] = temp;
        }

BufferedInputStream的速度提高了30多倍.远不止于此.那么,为什么会这样,并且可以使这个代码更有效(不使用任何外部库)？

我想知道是否有任何想法的方法将多个InputStream链接到Java(或Scala)中的一个连续的InputStream中.

我需要它是解析我从FTP服务器通过网络加载的平面文件.我想要做的是获取文件[1..N],打开流然后将它们组合成一个流.所以当file1结束时,我想从file2开始读取,依此类推,直到我到达fileN的末尾.

我需要按特定的顺序读取这些文件,数据来自遗留系统,该系统在barches中生成文件,因此一个数据依赖于另一个文件中的数据,但我想将它们作为一个连续流来处理,以简化我的域逻辑接口.

我四处搜索并找到了PipedInputStream,但我并不认为这是我需要的.一个例子会有所帮助.

InputStream.available()在Java中做什么？我阅读了文档,但我还是无法解决.

医生说:

返回可以从此输入流中读取(或跳过)的字节数,而不会被此输入流的方法的下一个调用方阻塞.下一个调用者可能是同一个线程或另一个线程.

类InputStream的可用方法始终返回0.

阻止是什么意思？它只是意味着同步通话吗？

最重要的是,该available()方法的目的是什么？

我想知道a是否InputStream为空,但不使用该方法read().有没有办法知道它是否是空的而没有从中读取？