Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Licensed to the Apache Software Foundation (ASF) under one or more
3
   * contributor license agreements.  See the NOTICE file distributed with
4
   * this work for additional information regarding copyright ownership.
5
   * The ASF licenses this file to You under the Apache License, Version 2.0
6
   * (the "License"); you may not use this file except in compliance with
7
   * the License.  You may obtain a copy of the License at
8
   * 
9
   *      http://www.apache.org/licenses/LICENSE-2.0
10
  * 
11
  * Unless required by applicable law or agreed to in writing, software
12
  * distributed under the License is distributed on an "AS IS" BASIS,
13
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
  * See the License for the specific language governing permissions and
15
  * limitations under the License.
16
  */
17
 package org.apache.commons.io.output;
18
  
24
 import java.util.List;

This class implements an output stream in which the data is written into a byte array. The buffer automatically grows as data is written to it.

The data can be retrieved using toByteArray() and toString().

Closing a ByteArrayOutputStream has no effect. The methods in this class can be called after the stream has been closed without generating an IOException.

This is an alternative implementation of the java.io.ByteArrayOutputStream class. The original implementation only allocates 32 bytes at the beginning. As this class is designed for heavy duty it starts at 1024 bytes. In contrast to the original it doesn't reallocate the whole memory block but allocates additional buffers. This way no buffers need to be garbage collected and the contents don't have to be copied to the new buffer. This class is designed to behave exactly like the original. The only exception is the deprecated toString(int) method that has been ignored.

Author(s):
Jeremias Maerki
Holger Hoffstatte
Version:
$Id: ByteArrayOutputStream.java 610010 2008-01-08 14:50:59Z niallp $
50
 
51
 public class ByteArrayOutputStream extends OutputStream {

    
A singleton empty byte array.
53
 
54
     private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

    
The list of buffers, which grows and never reduces.
56
 
57
     private List buffers = new ArrayList();
    
The index of the current buffer.
58
 
59
     private int currentBufferIndex;
    
The total count of bytes in all the filled buffers.
60
 
61
     private int filledBufferSum;
    
The current buffer.
62
 
63
     private byte[] currentBuffer;
    
The total count of bytes written.
64
 
65
     private int count;

    
Creates a new byte array output stream. The buffer capacity is initially 1024 bytes, though its size increases if necessary. 
70
 
71
     public ByteArrayOutputStream() {
72
         this(1024);
73
     }

    
Creates a new byte array output stream, with a buffer capacity of the specified size, in bytes.

Parameters:
size the initial size
Throws:
java.lang.IllegalArgumentException if size is negative
81
 
82
     public ByteArrayOutputStream(int size) {
83
         if (size < 0) {
84
             throw new IllegalArgumentException(
85
                 "Negative initial size: " + size);
86
         }
87
         needNewBuffer(size);
88
     }

    
Return the appropriate byte[] buffer specified by index.

Parameters:
index the index of the buffer required
Returns:
the buffer
96
 
97
     private byte[] getBuffer(int index) {
98
         return (byte[]) .get(index);
99
     }

    
Makes a new buffer available either by allocating a new one or re-cycling an existing one.

Parameters:
newcount the size of the buffer if one is created
107
    private void needNewBuffer(int newcount) {
108
        if ( < .size() - 1) {
109
            //Recycling old buffer
110
             += .;
111
            
112
            ++;
113
             = getBuffer();
114
        } else {
115
            //Creating new buffer
116
            int newBufferSize;
117
            if ( == null) {
118
                newBufferSize = newcount;
119
                 = 0;
120
            } else {
121
                newBufferSize = Math.max(
122
                    . << 1, 
123
                    newcount - );
124
                 += .;
125
            }
126
            
127
            ++;
128
             = new byte[newBufferSize];
129
            .add();
130
        }
131
    }

    
Write the bytes to byte array.

Parameters:
b the bytes to write
off The start offset
len The number of bytes to write
139
    public void write(byte[] b, int off, int len) {
140
        if ((off < 0) 
141
                || (off > b.length) 
142
                || (len < 0) 
143
                || ((off + len) > b.length) 
144
                || ((off + len) < 0)) {
145
            throw new IndexOutOfBoundsException();
146
        } else if (len == 0) {
147
            return;
148
        }
149
        synchronized (this) {
150
            int newcount =  + len;
151
            int remaining = len;
152
            int inBufferPos =  - ;
153
            while (remaining > 0) {
154
                int part = Math.min(remaining, . - inBufferPos);
155
                System.arraycopy(b, off + len - remaining, , inBufferPos, part);
156
                remaining -= part;
157
                if (remaining > 0) {
158
                    needNewBuffer(newcount);
159
                    inBufferPos = 0;
160
                }
161
            }
162
             = newcount;
163
        }
164
    }

    
Write a byte to byte array.

Parameters:
b the byte to write
170
    public synchronized void write(int b) {
171
        int inBufferPos =  - ;
172
        if (inBufferPos == .) {
173
            needNewBuffer( + 1);
174
            inBufferPos = 0;
175
        }
176
        [inBufferPos] = (byte) b;
177
        ++;
178
    }

    
Writes the entire contents of the specified input stream to this byte stream. Bytes from the input stream are read directly into the internal buffers of this streams.

Parameters:
in the input stream to read from
Returns:
total number of bytes read from the input stream (and written to this stream)
Throws:
java.io.IOException if an I/O error occurs while reading the input stream
Since:
Commons IO 1.4
191
    public synchronized int write(InputStream in) throws IOException {
192
        int readCount = 0;
193
        int inBufferPos =  - ;
194
        int n = in.read(, inBufferPos, . - inBufferPos);
195
        while (n != -1) {
196
            readCount += n;
197
            inBufferPos += n;
198
             += n;
199
            if (inBufferPos == .) {
200
                needNewBuffer(.);
201
                inBufferPos = 0;
202
            }
203
            n = in.read(, inBufferPos, . - inBufferPos);
204
        }
205
        return readCount;
206
    }

    
Return the current size of the byte array.

Returns:
the current size of the byte array
212
    public synchronized int size() {
213
        return ;
214
    }

    
Closing a ByteArrayOutputStream has no effect. The methods in this class can be called after the stream has been closed without generating an IOException.

Throws:
java.io.IOException never (this method should not declare this exception but it has to now due to backwards compatability)
224
    public void close() throws IOException {
225
        //nop
226
    }

    

See also:
java.io.ByteArrayOutputStream.reset()
231
    public synchronized void reset() {
232
         = 0;
233
         = 0;
234
         = 0;
236
    }

    
Writes the entire contents of this byte stream to the specified output stream.

Parameters:
out the output stream to write to
Throws:
java.io.IOException if an I/O error occurs, such as if the stream is closed
See also:
java.io.ByteArrayOutputStream.writeTo(java.io.OutputStream)
246
    public synchronized void writeTo(OutputStream out) throws IOException {
247
        int remaining = ;
248
        for (int i = 0; i < .size(); i++) {
249
            byte[] buf = getBuffer(i);
250
            int c = Math.min(buf.length, remaining);
251
            out.write(buf, 0, c);
252
            remaining -= c;
253
            if (remaining == 0) {
254
                break;
255
            }
256
        }
257
    }

    
Gets the curent contents of this byte stream as a byte array. The result is independent of this stream.

Returns:
the current contents of this output stream, as a byte array
See also:
java.io.ByteArrayOutputStream.toByteArray()
266
    public synchronized byte[] toByteArray() {
267
        int remaining = ;
268
        if (remaining == 0) {
269
            return ; 
270
        }
271
        byte newbuf[] = new byte[remaining];
272
        int pos = 0;
273
        for (int i = 0; i < .size(); i++) {
274
            byte[] buf = getBuffer(i);
275
            int c = Math.min(buf.length, remaining);
276
            System.arraycopy(buf, 0, newbuf, pos, c);
277
            pos += c;
278
            remaining -= c;
279
            if (remaining == 0) {
280
                break;
281
            }
282
        }
283
        return newbuf;
284
    }

    
Gets the curent contents of this byte stream as a string.

Returns:
the contents of the byte array as a String
See also:
java.io.ByteArrayOutputStream.toString()
291
    public String toString() {
292
        return new String(toByteArray());
293
    }

    
Gets the curent contents of this byte stream as a string using the specified encoding.

Parameters:
enc the name of the character encoding
Returns:
the string converted from the byte array
Throws:
java.io.UnsupportedEncodingException if the encoding is not supported
See also:
java.io.ByteArrayOutputStream.toString(java.lang.String)
304
    public String toString(String enc) throws UnsupportedEncodingException {
305
        return new String(toByteArray(), enc);
306
    }
New to GrepCode? Check out our FAQ X