Source Code Cross Referenced for DataOutputStream.java in  » 6.0-JDK-Core » io-nio » java » io » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Home
Java Source Code / Java Documentation
1.6.0 JDK Core
2.6.0 JDK Modules
3.6.0 JDK Modules com.sun
4.6.0 JDK Modules com.sun.java
5.6.0 JDK Modules sun
6.6.0 JDK Platform
7.Ajax
8.Apache Harmony Java SE
9.Aspect oriented
10.Authentication Authorization
11.Blogger System
12.Build
13.Byte Code
14.Cache
15.Chart
16.Chat
17.Code Analyzer
18.Collaboration
19.Content Management System
20.Database Client
21.Database DBMS
22.Database JDBC Connection Pool
23.Database ORM
24.Development
25.EJB Server
26.ERP CRM Financial
27.ESB
28.Forum
29.Game
30.GIS
31.Graphic 3D
32.Graphic Library
33.Groupware
34.HTML Parser
35.IDE
36.IDE Eclipse
37.IDE Netbeans
38.Installer
39.Internationalization Localization
40.Inversion of Control
41.Issue Tracking
42.J2EE
43.J2ME
44.JBoss
45.JMS
46.JMX
47.Library
48.Mail Clients
49.Music
50.Net
51.Parser
52.PDF
53.Portal
54.Profiler
55.Project Management
56.Report
57.RSS RDF
58.Rule Engine
59.Science
60.Scripting
61.Search Engine
62.Security
63.Sevlet Container
64.Source Control
65.Swing Library
66.Template Engine
67.Test Coverage
68.Testing
69.UML
70.Web Crawler
71.Web Framework
72.Web Mail
73.Web Server
74.Web Services
75.Web Services apache cxf 2.2.6
76.Web Services AXIS2
77.Wiki Engine
78.Workflow Engines
79.XML
80.XML UI
Java Source Code / Java Documentation » 6.0 JDK Core » io nio » java.io 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


001        /*
002         * Copyright 1994-2004 Sun Microsystems, Inc.  All Rights Reserved.
003         * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004         *
005         * This code is free software; you can redistribute it and/or modify it
006         * under the terms of the GNU General Public License version 2 only, as
007         * published by the Free Software Foundation.  Sun designates this
008         * particular file as subject to the "Classpath" exception as provided
009         * by Sun in the LICENSE file that accompanied this code.
010         *
011         * This code is distributed in the hope that it will be useful, but WITHOUT
012         * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013         * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
014         * version 2 for more details (a copy is included in the LICENSE file that
015         * accompanied this code).
016         *
017         * You should have received a copy of the GNU General Public License version
018         * 2 along with this work; if not, write to the Free Software Foundation,
019         * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020         *
021         * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022         * CA 95054 USA or visit www.sun.com if you need additional information or
023         * have any questions.
024         */
025
026        package java.io;
027
028        /**
029         * A data output stream lets an application write primitive Java data 
030         * types to an output stream in a portable way. An application can 
031         * then use a data input stream to read the data back in. 
032         *
033         * @author  unascribed
034         * @version 1.50, 05/05/07
035         * @see     java.io.DataInputStream
036         * @since   JDK1.0
037         */
038        public class DataOutputStream extends FilterOutputStream implements 
039                DataOutput {
040            /**
041             * The number of bytes written to the data output stream so far. 
042             * If this counter overflows, it will be wrapped to Integer.MAX_VALUE.
043             */
044            protected int written;
045
046            /**
047             * bytearr is initialized on demand by writeUTF
048             */
049            private byte[] bytearr = null;
050
051            /**
052             * Creates a new data output stream to write data to the specified 
053             * underlying output stream. The counter <code>written</code> is 
054             * set to zero.
055             *
056             * @param   out   the underlying output stream, to be saved for later 
057             *                use.
058             * @see     java.io.FilterOutputStream#out
059             */
060            public DataOutputStream(OutputStream out) {
061                super (out);
062            }
063
064            /**
065             * Increases the written counter by the specified value
066             * until it reaches Integer.MAX_VALUE.
067             */
068            private void incCount(int value) {
069                int temp = written + value;
070                if (temp < 0) {
071                    temp = Integer.MAX_VALUE;
072                }
073                written = temp;
074            }
075
076            /**
077             * Writes the specified byte (the low eight bits of the argument 
078             * <code>b</code>) to the underlying output stream. If no exception 
079             * is thrown, the counter <code>written</code> is incremented by 
080             * <code>1</code>.
081             * <p>
082             * Implements the <code>write</code> method of <code>OutputStream</code>.
083             *
084             * @param      b   the <code>byte</code> to be written.
085             * @exception  IOException  if an I/O error occurs.
086             * @see        java.io.FilterOutputStream#out
087             */
088            public synchronized void write(int b) throws IOException {
089                out.write(b);
090                incCount(1);
091            }
092
093            /**
094             * Writes <code>len</code> bytes from the specified byte array 
095             * starting at offset <code>off</code> to the underlying output stream. 
096             * If no exception is thrown, the counter <code>written</code> is 
097             * incremented by <code>len</code>.
098             *
099             * @param      b     the data.
100             * @param      off   the start offset in the data.
101             * @param      len   the number of bytes to write.
102             * @exception  IOException  if an I/O error occurs.
103             * @see        java.io.FilterOutputStream#out
104             */
105            public synchronized void write(byte b[], int off, int len)
106                    throws IOException {
107                out.write(b, off, len);
108                incCount(len);
109            }
110
111            /**
112             * Flushes this data output stream. This forces any buffered output 
113             * bytes to be written out to the stream. 
114             * <p>
115             * The <code>flush</code> method of <code>DataOutputStream</code>
116             * calls the <code>flush</code> method of its underlying output stream.
117             *
118             * @exception  IOException  if an I/O error occurs.
119             * @see        java.io.FilterOutputStream#out
120             * @see        java.io.OutputStream#flush()
121             */
122            public void flush() throws IOException {
123                out.flush();
124            }
125
126            /**
127             * Writes a <code>boolean</code> to the underlying output stream as 
128             * a 1-byte value. The value <code>true</code> is written out as the 
129             * value <code>(byte)1</code>; the value <code>false</code> is 
130             * written out as the value <code>(byte)0</code>. If no exception is 
131             * thrown, the counter <code>written</code> is incremented by 
132             * <code>1</code>.
133             *
134             * @param      v   a <code>boolean</code> value to be written.
135             * @exception  IOException  if an I/O error occurs.
136             * @see        java.io.FilterOutputStream#out
137             */
138            public final void writeBoolean(boolean v) throws IOException {
139                out.write(v ? 1 : 0);
140                incCount(1);
141            }
142
143            /**
144             * Writes out a <code>byte</code> to the underlying output stream as 
145             * a 1-byte value. If no exception is thrown, the counter 
146             * <code>written</code> is incremented by <code>1</code>.
147             *
148             * @param      v   a <code>byte</code> value to be written.
149             * @exception  IOException  if an I/O error occurs.
150             * @see        java.io.FilterOutputStream#out
151             */
152            public final void writeByte(int v) throws IOException {
153                out.write(v);
154                incCount(1);
155            }
156
157            /**
158             * Writes a <code>short</code> to the underlying output stream as two
159             * bytes, high byte first. If no exception is thrown, the counter 
160             * <code>written</code> is incremented by <code>2</code>.
161             *
162             * @param      v   a <code>short</code> to be written.
163             * @exception  IOException  if an I/O error occurs.
164             * @see        java.io.FilterOutputStream#out
165             */
166            public final void writeShort(int v) throws IOException {
167                out.write((v >>> 8) & 0xFF);
168                out.write((v >>> 0) & 0xFF);
169                incCount(2);
170            }
171
172            /**
173             * Writes a <code>char</code> to the underlying output stream as a 
174             * 2-byte value, high byte first. If no exception is thrown, the 
175             * counter <code>written</code> is incremented by <code>2</code>.
176             *
177             * @param      v   a <code>char</code> value to be written.
178             * @exception  IOException  if an I/O error occurs.
179             * @see        java.io.FilterOutputStream#out
180             */
181            public final void writeChar(int v) throws IOException {
182                out.write((v >>> 8) & 0xFF);
183                out.write((v >>> 0) & 0xFF);
184                incCount(2);
185            }
186
187            /**
188             * Writes an <code>int</code> to the underlying output stream as four
189             * bytes, high byte first. If no exception is thrown, the counter 
190             * <code>written</code> is incremented by <code>4</code>.
191             *
192             * @param      v   an <code>int</code> to be written.
193             * @exception  IOException  if an I/O error occurs.
194             * @see        java.io.FilterOutputStream#out
195             */
196            public final void writeInt(int v) throws IOException {
197                out.write((v >>> 24) & 0xFF);
198                out.write((v >>> 16) & 0xFF);
199                out.write((v >>> 8) & 0xFF);
200                out.write((v >>> 0) & 0xFF);
201                incCount(4);
202            }
203
204            private byte writeBuffer[] = new byte[8];
205
206            /**
207             * Writes a <code>long</code> to the underlying output stream as eight
208             * bytes, high byte first. In no exception is thrown, the counter 
209             * <code>written</code> is incremented by <code>8</code>.
210             *
211             * @param      v   a <code>long</code> to be written.
212             * @exception  IOException  if an I/O error occurs.
213             * @see        java.io.FilterOutputStream#out
214             */
215            public final void writeLong(long v) throws IOException {
216                writeBuffer[0] = (byte) (v >>> 56);
217                writeBuffer[1] = (byte) (v >>> 48);
218                writeBuffer[2] = (byte) (v >>> 40);
219                writeBuffer[3] = (byte) (v >>> 32);
220                writeBuffer[4] = (byte) (v >>> 24);
221                writeBuffer[5] = (byte) (v >>> 16);
222                writeBuffer[6] = (byte) (v >>> 8);
223                writeBuffer[7] = (byte) (v >>> 0);
224                out.write(writeBuffer, 0, 8);
225                incCount(8);
226            }
227
228            /**
229             * Converts the float argument to an <code>int</code> using the 
230             * <code>floatToIntBits</code> method in class <code>Float</code>, 
231             * and then writes that <code>int</code> value to the underlying 
232             * output stream as a 4-byte quantity, high byte first. If no 
233             * exception is thrown, the counter <code>written</code> is 
234             * incremented by <code>4</code>.
235             *
236             * @param      v   a <code>float</code> value to be written.
237             * @exception  IOException  if an I/O error occurs.
238             * @see        java.io.FilterOutputStream#out
239             * @see        java.lang.Float#floatToIntBits(float)
240             */
241            public final void writeFloat(float v) throws IOException {
242                writeInt(Float.floatToIntBits(v));
243            }
244
245            /**
246             * Converts the double argument to a <code>long</code> using the 
247             * <code>doubleToLongBits</code> method in class <code>Double</code>, 
248             * and then writes that <code>long</code> value to the underlying 
249             * output stream as an 8-byte quantity, high byte first. If no 
250             * exception is thrown, the counter <code>written</code> is 
251             * incremented by <code>8</code>.
252             *
253             * @param      v   a <code>double</code> value to be written.
254             * @exception  IOException  if an I/O error occurs.
255             * @see        java.io.FilterOutputStream#out
256             * @see        java.lang.Double#doubleToLongBits(double)
257             */
258            public final void writeDouble(double v) throws IOException {
259                writeLong(Double.doubleToLongBits(v));
260            }
261
262            /**
263             * Writes out the string to the underlying output stream as a 
264             * sequence of bytes. Each character in the string is written out, in 
265             * sequence, by discarding its high eight bits. If no exception is 
266             * thrown, the counter <code>written</code> is incremented by the 
267             * length of <code>s</code>.
268             *
269             * @param      s   a string of bytes to be written.
270             * @exception  IOException  if an I/O error occurs.
271             * @see        java.io.FilterOutputStream#out
272             */
273            public final void writeBytes(String s) throws IOException {
274                int len = s.length();
275                for (int i = 0; i < len; i++) {
276                    out.write((byte) s.charAt(i));
277                }
278                incCount(len);
279            }
280
281            /**
282             * Writes a string to the underlying output stream as a sequence of 
283             * characters. Each character is written to the data output stream as 
284             * if by the <code>writeChar</code> method. If no exception is 
285             * thrown, the counter <code>written</code> is incremented by twice 
286             * the length of <code>s</code>.
287             *
288             * @param      s   a <code>String</code> value to be written.
289             * @exception  IOException  if an I/O error occurs.
290             * @see        java.io.DataOutputStream#writeChar(int)
291             * @see        java.io.FilterOutputStream#out
292             */
293            public final void writeChars(String s) throws IOException {
294                int len = s.length();
295                for (int i = 0; i < len; i++) {
296                    int v = s.charAt(i);
297                    out.write((v >>> 8) & 0xFF);
298                    out.write((v >>> 0) & 0xFF);
299                }
300                incCount(len * 2);
301            }
302
303            /**
304             * Writes a string to the underlying output stream using
305             * <a href="DataInput.html#modified-utf-8">modified UTF-8</a>
306             * encoding in a machine-independent manner. 
307             * <p>
308             * First, two bytes are written to the output stream as if by the 
309             * <code>writeShort</code> method giving the number of bytes to 
310             * follow. This value is the number of bytes actually written out, 
311             * not the length of the string. Following the length, each character 
312             * of the string is output, in sequence, using the modified UTF-8 encoding
313             * for the character. If no exception is thrown, the counter 
314             * <code>written</code> is incremented by the total number of 
315             * bytes written to the output stream. This will be at least two 
316             * plus the length of <code>str</code>, and at most two plus 
317             * thrice the length of <code>str</code>.
318             *
319             * @param      str   a string to be written.
320             * @exception  IOException  if an I/O error occurs.
321             */
322            public final void writeUTF(String str) throws IOException {
323                writeUTF(str, this );
324            }
325
326            /**
327             * Writes a string to the specified DataOutput using
328             * <a href="DataInput.html#modified-utf-8">modified UTF-8</a>
329             * encoding in a machine-independent manner. 
330             * <p>
331             * First, two bytes are written to out as if by the <code>writeShort</code>
332             * method giving the number of bytes to follow. This value is the number of
333             * bytes actually written out, not the length of the string. Following the
334             * length, each character of the string is output, in sequence, using the
335             * modified UTF-8 encoding for the character. If no exception is thrown, the
336             * counter <code>written</code> is incremented by the total number of 
337             * bytes written to the output stream. This will be at least two 
338             * plus the length of <code>str</code>, and at most two plus 
339             * thrice the length of <code>str</code>.
340             *
341             * @param      str   a string to be written.
342             * @param      out   destination to write to
343             * @return     The number of bytes written out.
344             * @exception  IOException  if an I/O error occurs.
345             */
346            static int writeUTF(String str, DataOutput out) throws IOException {
347                int strlen = str.length();
348                int utflen = 0;
349                int c, count = 0;
350
351                /* use charAt instead of copying String to char array */
352                for (int i = 0; i < strlen; i++) {
353                    c = str.charAt(i);
354                    if ((c >= 0x0001) && (c <= 0x007F)) {
355                        utflen++;
356                    } else if (c > 0x07FF) {
357                        utflen += 3;
358                    } else {
359                        utflen += 2;
360                    }
361                }
362
363                if (utflen > 65535)
364                    throw new UTFDataFormatException(
365                            "encoded string too long: " + utflen + " bytes");
366
367                byte[] bytearr = null;
368                if (out instanceof  DataOutputStream) {
369                    DataOutputStream dos = (DataOutputStream) out;
370                    if (dos.bytearr == null
371                            || (dos.bytearr.length < (utflen + 2)))
372                        dos.bytearr = new byte[(utflen * 2) + 2];
373                    bytearr = dos.bytearr;
374                } else {
375                    bytearr = new byte[utflen + 2];
376                }
377
378                bytearr[count++] = (byte) ((utflen >>> 8) & 0xFF);
379                bytearr[count++] = (byte) ((utflen >>> 0) & 0xFF);
380
381                int i = 0;
382                for (i = 0; i < strlen; i++) {
383                    c = str.charAt(i);
384                    if (!((c >= 0x0001) && (c <= 0x007F)))
385                        break;
386                    bytearr[count++] = (byte) c;
387                }
388
389                for (; i < strlen; i++) {
390                    c = str.charAt(i);
391                    if ((c >= 0x0001) && (c <= 0x007F)) {
392                        bytearr[count++] = (byte) c;
393
394                    } else if (c > 0x07FF) {
395                        bytearr[count++] = (byte) (0xE0 | ((c >> 12) & 0x0F));
396                        bytearr[count++] = (byte) (0x80 | ((c >> 6) & 0x3F));
397                        bytearr[count++] = (byte) (0x80 | ((c >> 0) & 0x3F));
398                    } else {
399                        bytearr[count++] = (byte) (0xC0 | ((c >> 6) & 0x1F));
400                        bytearr[count++] = (byte) (0x80 | ((c >> 0) & 0x3F));
401                    }
402                }
403                out.write(bytearr, 0, utflen + 2);
404                return utflen + 2;
405            }
406
407            /**
408             * Returns the current value of the counter <code>written</code>, 
409             * the number of bytes written to this data output stream so far.
410             * If the counter overflows, it will be wrapped to Integer.MAX_VALUE.
411             *
412             * @return  the value of the <code>written</code> field.
413             * @see     java.io.DataOutputStream#written
414             */
415            public final int size() {
416                return written;
417            }
418        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.