标签: inputstream

我是Java开发的新手,所以请耐心等待.另外,我希望我不是tl的博士;博士 :).

我正在使用HttpClient通过Http(duh!)发出请求,并且我已经让它为一个接收URL作为查询字符串参数的简单servlet工作.我意识到我的代码可以使用一些重构,所以我决定自己做HttpResponseHandler,清理代码,使其可重用并改进异常处理.

我目前有这样的事情:

public class HttpResponseHandler implements ResponseHandler<InputStream>{

    public InputStream handleResponse(HttpResponse response)
            throws ClientProtocolException, IOException {

        int statusCode = response.getStatusLine().getStatusCode();
        InputStream in = null;

        if (statusCode != HttpStatus.SC_OK) {
            throw new HttpResponseException(statusCode, null);
        } else {
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                in = entity.getContent();
                // This works
                // for (int i;(i = in.read()) >= 0;) System.out.print((char)i); 
            }
        }
        return in;
    }
}

在我提出实际请求的方法中:

HttpClient httpclient = new DefaultHttpClient();
HttpGet httpget …

我有一个BufferedInputStream没有正确标记.这是我的代码:

public static void main(String[] args) throws Exception {
    byte[] b = "HelloWorld!".getBytes();
    BufferedInputStream bin = new BufferedInputStream(new ByteArrayInputStream(b));
    bin.mark(3);
    while (true){
        byte[] buf = new byte[4096];
        int n = bin.read(buf);
        if (n == -1) break;
        System.out.println(n);
        System.out.println(new String(buf, 0, n));
    }
}

这是输出:

11
HelloWorld!

我希望它输出

3
Hel
8
loWorld!

我也尝试使用纯粹的ByteArrayInputStream作为代码bin,但它也没有用.

从InputStream读取时,有没有办法在读取达到一定大小时取消读取并忽略流的其余部分,确保资源完全释放？

到目前为止,我刚刚完成阅读,但理想情况下我想停止阅读并继续前进.我该如何安全地做到这一点？

这是我到目前为止:

ByteArrayOutputStream buffer = new ByteArrayOutputStream();

int nRead;
byte[] byteData = new byte[16384];

while ((nRead = inputStream.read(byteData, 0, byteData.length)) != -1){

    if(buffer.size() <= MAX_FILE_SIZE){
        buffer.write(byteData, 0, nRead);
    }

}

if(buffer.size() <= MAX_FILE_SIZE){
    buffer.flush();
    mData = buffer.toByteArray();
}

inputStream.close();

谢谢

我需要编写将从InputStream中重新获取数据的应用程序.简而言之:我的应用程序将首先连接到蓝牙设备.连接后,我的应用程序将连续从InputStream重新加载数据.我的意思是设备将发送20 milisec的数据,应用程序将收到这个数据工作24小时甚至更多.现在我以这种方式阅读这些数据:

while((bytesReceived = is.read(buffer))>-1) {
  //things to do with data
}

此循环在流中时接收数据,在输入流接近时停止.我的问题是我认为这不是最佳解决方案.在is.read(缓冲区)接收数据后,它会阻塞等待下一个消耗大量处理器的数据.您是否知道更好的方法来读取消耗最少处理器功耗的数据.谢谢你的帮助.

BTW.我在Android上用Java编写应用程序.

我不明白为什么以下代码似乎跳过第一个输入字符.

import java.io.*;
import java.util.Arrays;

public class Input
{
    public static void main (String args[])
    {
        try {
            echo(System.in);
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

    static void echo(InputStream stream) throws IOException
    {
        byte[] input = new byte[10];

        char[] inputChar = new char[10];
        int current;
        while ((current = stream.read()) > 0){
            stream.read(input);

            int i = 0;
            while (input[i] != 0) {
                inputChar[i] = (char)input[i];
                if (i < 9) {
                    i++;
                }
                else {
                    break;
                }
            }   
            System.out.println(Arrays.toString(inputChar));
        }
    } …

我们无法实例化java.io.FilterInputStream,因为它没有公共构造函数,我们甚至不需要不扩展它.

他们为什么不把它作为抽象类呢？

现在我似乎没有得到那些流(输入/输出)和普通writer和reader甚至scanner和formatter... 之间的区别.

而为何InputStream有这样大量的子类DataInputStream,并BufferedInputStream和所有的混乱(与同为OutputStream当然的)...

最后一件事,如果缓冲区是那么好(所以我读)并且效率高,为什么任何人都会使用任何其他输入/输出方式(为什么它们甚至被制作？)

我知道InputStream应该关闭.但我有点怀疑在哪里以及如何做到这一点.

根据IOUtils.closeQuietly上的文档:

无条件地关闭InputStream.等效于InputStream.close(),但将忽略任何异常.这通常用在finally块中.

我的try/catch代码中不需要块,所以我没有finally块.在我的方法中返回之前关闭InputStream是否可以,或者我应该采取不同的做法？多个服务将使用此方法InputStream从文件加载.

public InputStream read(String filename) {
    InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(filename);

    if (inputStream == null) {
      // Throw some exception
    }

    IOUtils.closeQuietly(inputStream);

    return inputStream;
}

我要求由于之前的实现使用了InputStream,我不能用了BufferedReader.

我的测试台使用了a BufferedReader和while循环,如下所示:

while ((line = br.readLine()) != null)

但是br现在必须是InputStream(并且将被重命名).是否有任何方式以这种方式阅读InputStream,或者我是否必须一次读取字节并搜索\n？

给定一个字符串：

String xml = "<test/>";

如何将其转换为InputStreamGroovy中的？

目前，我使用：

IOUtils.toInputStream(xml, StandardCharsets.UTF_8)

它可以工作，但是我正在Groovy中寻找一种更短且无依赖的方法。

我当然知道Java的答案，但是它涉及到丑陋的创建ByteArrayInputStream。我正在寻找解决该问题的GDK方法。