जवाबों:
आप इसे और इसी तरह के कार्यों को संभालने के लिए Apache Commons IO का उपयोग कर सकते हैं ।
IOUtilsप्रकार एक को पढ़ने के लिए एक स्थिर विधि है InputStreamऔर एक वापसी byte[]।
InputStream is;
byte[] bytes = IOUtils.toByteArray(is);
आंतरिक रूप से यह एक बनाता है ByteArrayOutputStreamऔर बाइट्स को आउटपुट पर कॉपी करता है, फिर कॉल करता है toByteArray()। यह 4KiB के ब्लॉक में बाइट्स कॉपी करके बड़ी फ़ाइलों को संभालता है।
FastArrayListया उनके नरम और कमजोर संदर्भ मैप्स पर एक नज़र डालें और मुझे बताएं कि यह लाइब्रेरी कितनी अच्छी तरह से "अच्छी तरह से जांची गई" है। यह
InputStream is; byte[] filedata=ByteStreams.toByteArray(is);
आपको अपने से प्रत्येक बाइट को पढ़ने InputStreamऔर इसे लिखने की आवश्यकता है ByteArrayOutputStream।
फिर आप कॉल करके अंतर्निहित बाइट सरणी प्राप्त कर सकते हैं toByteArray():
InputStream is = ...
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int nRead;
byte[] data = new byte[16384];
while ((nRead = is.read(data, 0, data.length)) != -1) {
buffer.write(data, 0, nRead);
}
return buffer.toByteArray();
अंत में, बीस साल बाद, तीसरी पार्टी लाइब्रेरी की आवश्यकता के बिना एक सरल समाधान है, जावा 9 के लिए धन्यवाद :
InputStream is;
…
byte[] array = is.readAllBytes();
नोट भी सुविधा के तरीकों readNBytes(byte[] b, int off, int len)और transferTo(OutputStream)आवर्ती जरूरतों को संबोधित।
वेनिला जावा DataInputStreamऔर इसकी readFullyविधि का उपयोग करें (कम से कम जावा 1.4 के बाद से मौजूद है):
...
byte[] bytes = new byte[(int) file.length()];
DataInputStream dis = new DataInputStream(new FileInputStream(file));
dis.readFully(bytes);
...
इस पद्धति के कुछ अन्य स्वाद हैं, लेकिन मैं इस उपयोग के मामले के लिए हर समय उपयोग करता हूं।
DataInputStreamको प्राथमिक (Longs, Shorts, Chars ...) एक स्ट्रीम से पढ़ने के लिए उपयोग किया जाता है, इसलिए हम इस उपयोग को क्लास के दुरुपयोग के रूप में देख सकते हैं।
InputStream.read।
यदि आप Google अमरूद का उपयोग करते हैं , तो यह उतना ही सरल होगा:
byte[] bytes = ByteStreams.toByteArray(inputStream);ByteStreamsके साथ एनोटेट किया गया है@Beta
हमेशा की तरह, स्प्रिंग फ्रेमवर्क (3.2.2 के बाद से स्प्रिंग-कोर) आपके लिए कुछ है:StreamUtils.copyToByteArray()
public static byte[] getBytesFromInputStream(InputStream is) throws IOException {
ByteArrayOutputStream os = new ByteArrayOutputStream();
byte[] buffer = new byte[0xFFFF];
for (int len = is.read(buffer); len != -1; len = is.read(buffer)) {
os.write(buffer, 0, len);
}
return os.toByteArray();
}सुरक्षित समाधान (closeधाराओं कीक्षमता के साथसही ढंग से):
जावा 9+ संस्करण:
final byte[] bytes;
try (inputStream) {
bytes = inputStream.readAllBytes();
}जावा 8 संस्करण:
public static byte[] readAllBytes(InputStream inputStream) throws IOException {
final int bufLen = 4 * 0x400; // 4KB
byte[] buf = new byte[bufLen];
int readLen;
IOException exception = null;
try {
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
while ((readLen = inputStream.read(buf, 0, bufLen)) != -1)
outputStream.write(buf, 0, readLen);
return outputStream.toByteArray();
}
} catch (IOException e) {
exception = e;
throw e;
} finally {
if (exception == null) inputStream.close();
else try {
inputStream.close();
} catch (IOException e) {
exception.addSuppressed(e);
}
}
}कोटलिन संस्करण (जब जावा 9+ सुलभ नहीं है):
@Throws(IOException::class)
fun InputStream.readAllBytes(): ByteArray {
val bufLen = 4 * 0x400 // 4KB
val buf = ByteArray(bufLen)
var readLen: Int = 0
ByteArrayOutputStream().use { o ->
this.use { i ->
while (i.read(buf, 0, bufLen).also { readLen = it } != -1)
o.write(buf, 0, readLen)
}
return o.toByteArray()
}
}नेस्टेड से बचने के useलिए यहां देखें ।
क्या आपको वास्तव में छवि की आवश्यकता है byte[]? आप वास्तव में क्या उम्मीद करते हैं byte[]- एक छवि फ़ाइल की पूरी सामग्री, छवि फ़ाइल जो भी प्रारूप में है, या आरजीबी पिक्सेल मूल्यों में एन्कोडेड है?
अन्य उत्तर यहां आपको एक फ़ाइल को एक में पढ़ने का तरीका दिखाते हैं byte[]। आपकी byte[]फ़ाइल में सटीक सामग्री होगी, और आपको छवि डेटा के साथ कुछ भी करने की आवश्यकता होगी।
छवियों (पढ़ने और लिखने) के लिए जावा का मानक एपीआई इमेजियो एपीआई है, जिसे आप पैकेज में पा सकते हैं javax.imageio। आप कोड की केवल एक पंक्ति वाली फ़ाइल से किसी चित्र में पढ़ सकते हैं:
BufferedImage image = ImageIO.read(new File("image.jpg"));यह आपको एक BufferedImageनहीं, एक देगा byte[]। छवि डेटा प्राप्त करने के लिए, आप getRaster()पर कॉल कर सकते हैं BufferedImage। यह आपको एक Rasterऑब्जेक्ट देगा, जिसमें पिक्सेल डेटा तक पहुंचने के तरीके हैं (इसमें कई getPixel()/ getPixels()तरीके हैं)।
API दस्तावेज़ देखने के लिए javax.imageio.ImageIO, java.awt.image.BufferedImage, java.awt.image.Rasterआदि
ImageIO डिफ़ॉल्ट रूप से कई छवि प्रारूपों का समर्थन करता है: JPEG, PNG, BMP, WBMP और GIF। अधिक स्वरूपों के लिए समर्थन जोड़ना संभव है (आपको ImageIO सेवा प्रदाता इंटरफ़ेस को प्लग-इन लागू करना होगा)।
निम्नलिखित ट्यूटोरियल भी देखें: छवियों के साथ काम करना
मामले में कोई अभी भी एक निर्भरता के बिना एक समाधान की तलाश कर रहा है और यदि आपके पास एक फ़ाइल है ।
1) DataInputStream
byte[] data = new byte[(int) file.length()];
DataInputStream dis = new DataInputStream(new FileInputStream(file));
dis.readFully(data);
dis.close();2) बाइटएयरेऑटपुटस्ट्रीम
InputStream is = new FileInputStream(file);
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int nRead;
byte[] data = new byte[(int) file.length()];
while ((nRead = is.read(data, 0, data.length)) != -1) {
buffer.write(data, 0, nRead);
}3) रैंडमअफाइलफाइल
RandomAccessFile raf = new RandomAccessFile(file, "r");
byte[] data = new byte[(int) raf.length()];
raf.readFully(data);यदि आप Apache commons-io लाइब्रेरी का उपयोग नहीं करना चाहते हैं, तो यह स्निपेट sun.misc.IOUilsils से लिया गया है। यह बाइटबफर्स का उपयोग करते हुए आम कार्यान्वयन के रूप में लगभग दोगुना है:
public static byte[] readFully(InputStream is, int length, boolean readAll)
throws IOException {
byte[] output = {};
if (length == -1) length = Integer.MAX_VALUE;
int pos = 0;
while (pos < length) {
int bytesToRead;
if (pos >= output.length) { // Only expand when there's no room
bytesToRead = Math.min(length - pos, output.length + 1024);
if (output.length < pos + bytesToRead) {
output = Arrays.copyOf(output, pos + bytesToRead);
}
} else {
bytesToRead = output.length - pos;
}
int cc = is.read(output, pos, bytesToRead);
if (cc < 0) {
if (readAll && length != Integer.MAX_VALUE) {
throw new EOFException("Detect premature EOF");
} else {
if (output.length != pos) {
output = Arrays.copyOf(output, pos);
}
break;
}
}
pos += cc;
}
return output;
}@ एडम्सकी: आप पूरी तरह से बफर से बच सकते हैं।
Http://www.exampledepot.com/egs/java.io/File2ByteArray.html से कॉपी किया गया कोड (हां, यह बहुत ही क्रियात्मक है, लेकिन दूसरे समाधान के रूप में स्मृति के आधे आकार की आवश्यकता है।)
// Returns the contents of the file in a byte array.
public static byte[] getBytesFromFile(File file) throws IOException {
InputStream is = new FileInputStream(file);
// Get the size of the file
long length = file.length();
// You cannot create an array using a long type.
// It needs to be an int type.
// Before converting to an int type, check
// to ensure that file is not larger than Integer.MAX_VALUE.
if (length > Integer.MAX_VALUE) {
// File is too large
}
// Create the byte array to hold the data
byte[] bytes = new byte[(int)length];
// Read in the bytes
int offset = 0;
int numRead = 0;
while (offset < bytes.length
&& (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
offset += numRead;
}
// Ensure all the bytes have been read in
if (offset < bytes.length) {
throw new IOException("Could not completely read file "+file.getName());
}
// Close the input stream and return bytes
is.close();
return bytes;
}is.close()तो आपको जोड़ना चाहिए offset < bytes.lengthया InputStreamबंद नहीं होगा।
Input Stream is ...
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int next = in.read();
while (next > -1) {
bos.write(next);
next = in.read();
}
bos.flush();
byte[] result = bos.toByteArray();
bos.close();InputStreamएक में BufferedInputStreamहै कि कोड से पहले ओएस-कॉल को कम करने और काफी प्रदर्शन कमियां कम होता है, कि कोड को अभी भी एक से दूसरे बफर से अनावश्यक मैनुअल नकल काम करेंगे।
जावा 9 आपको अंत में एक अच्छा तरीका देगा:
InputStream in = ...;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
in.transferTo( bos );
byte[] bytes = bos.toByteArray();InputStram.readAllBytes()है?
मुझे पता है कि बहुत देर हो चुकी है लेकिन मुझे लगता है कि क्लीनर समाधान है जो अधिक पठनीय है ...
/**
* method converts {@link InputStream} Object into byte[] array.
*
* @param stream the {@link InputStream} Object.
* @return the byte[] array representation of received {@link InputStream} Object.
* @throws IOException if an error occurs.
*/
public static byte[] streamToByteArray(InputStream stream) throws IOException {
byte[] buffer = new byte[1024];
ByteArrayOutputStream os = new ByteArrayOutputStream();
int line = 0;
// read bytes from stream, and store them in buffer
while ((line = stream.read(buffer)) != -1) {
// Writes bytes from byte array (buffer) into output stream.
os.write(buffer, 0, line);
}
stream.close();
os.flush();
os.close();
return os.toByteArray();
}जावा 8 तरीका ( बफ़रड्रेडर और एडम बायन के लिए धन्यवाद )
private static byte[] readFully(InputStream input) throws IOException {
try (BufferedReader buffer = new BufferedReader(new InputStreamReader(input))) {
return buffer.lines().collect(Collectors.joining("\n")).getBytes(<charset_can_be_specified>);
}
}ध्यान दें कि यह समाधान गाड़ी वापसी ('\ r') मिटा देता है और अनुचित हो सकता है।
String। ओपी पूछ रहा है byte[]।
\rइतना नहीं है कि एक समस्या हो सकती है। यह विधि बाइट्स को वर्णों में वापस ले जाती है और फिर से वापस आती है (InputStreamReader के लिए डिफ़ॉल्ट वर्ण सेट का उपयोग करके)। कोई भी बाइट्स जो कि डिफ़ॉल्ट वर्ण एन्कोडिंग में मान्य नहीं हैं (जैसे, लिनक्स पर UTF-8 के लिए) भ्रष्ट हो जाएगा, संभवतः बाइट्स की संख्या भी बदल जाएगी।
मैंने कचरा डेटा लिखने के लिए फिक्स के साथ @ numan के उत्तर को संपादित करने की कोशिश की, लेकिन संपादन अस्वीकार कर दिया गया। हालांकि इस छोटे से कोड में कुछ भी शानदार नहीं है लेकिन मैं कोई और बेहतर जवाब नहीं देख सकता। यहाँ मेरे लिए सबसे ज्यादा मायने रखता है:
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buffer = new byte[1024]; // you can configure the buffer size
int length;
while ((length = in.read(buffer)) != -1) out.write(buffer, 0, length); //copy streams
in.close(); // call this in a finally block
byte[] result = out.toByteArray();btw बाइटआर्टऑउटपुटस्ट्रीम को बंद करने की आवश्यकता नहीं है। कोशिश / अंत में पठनीयता के लिए छोड़ा गया निर्माण
InputStream.available()प्रलेखन देखें :
यह महसूस करना विशेष रूप से महत्वपूर्ण है कि कंटेनर को आकार देने के लिए आपको इस पद्धति का उपयोग नहीं करना चाहिए और यह मान लेना चाहिए कि आप कंटेनर को आकार देने के लिए बिना स्ट्रीम की संपूर्णता को पढ़ सकते हैं। इस तरह के कॉल करने वालों को शायद वह सब कुछ लिखना चाहिए जो वे एक बाइटअरेओट्यूटस्ट्रीमस्ट्रीम पर पढ़ते हैं और इसे बाइट ऐरे में बदल देते हैं। वैकल्पिक रूप से, यदि आप किसी फ़ाइल से पढ़ रहे हैं, तो File.length फ़ाइल की वर्तमान लंबाई लौटाती है (हालांकि यह मानते हुए कि फ़ाइल की लंबाई बदल नहीं सकती है, गलत है, फ़ाइल पढ़ना स्वाभाविक रूप से दुर्लभ है)।
एक DataInputStream में लपेटें यदि वह किसी कारण से तालिका से बाहर है, तो बस उस पर हथौड़े को पढ़ने का उपयोग करें जब तक कि यह आपको -1 या आपके द्वारा मांगे गए पूरे ब्लॉक को न दे।
public int readFully(InputStream in, byte[] data) throws IOException {
int offset = 0;
int bytesRead;
boolean read = false;
while ((bytesRead = in.read(data, offset, data.length - offset)) != -1) {
read = true;
offset += bytesRead;
if (offset >= data.length) {
break;
}
}
return (read) ? offset : -1;
}एस 3 ऑब्जेक्ट को बाइटएयर्रे में परिवर्तित करते हुए हम कुछ एडब्ल्यूएस लेनदेन के लिए कुछ देरी देख रहे हैं।
नोट: S3 ऑब्जेक्ट पीडीएफ दस्तावेज़ है (अधिकतम आकार 3 एमबी है)।
हम S3 ऑब्जेक्ट को ByteArray में बदलने के लिए # 1 (org.apache.commons.io.IOUtils) विकल्प का उपयोग कर रहे हैं। हमने S3 पर ध्यान दिया है कि S3 ऑब्जेक्ट को बाइटएयर्रे में परिवर्तित करने के लिए IOUtils विधि प्रदान करें, हम आपसे निवेदन करते हैं कि देरी से बचने के लिए S3 ऑब्जेक्ट को बाइटअवर में परिवर्तित करने का सबसे अच्छा तरीका क्या है।
विकल्प 1:
import org.apache.commons.io.IOUtils;
is = s3object.getObjectContent();
content =IOUtils.toByteArray(is);विकल्प 2:
import com.amazonaws.util.IOUtils;
is = s3object.getObjectContent();
content =IOUtils.toByteArray(is);मुझे यह भी बताएं कि क्या हमारे पास s3 ऑब्जेक्ट को बाईट्रेयर में बदलने का कोई और बेहतर तरीका है
सर्वर द्वारा अनुरोध भेजने और प्रतिक्रिया की प्रतीक्षा करने के बाद, स्ट्रीम के माध्यम से सही बाइट सरणी प्राप्त करने के लिए अन्य मामला।
/**
* Begin setup TCP connection to PC app
* to open integrate connection between mobile app and pc app (or mobile app)
*/
mSocket = new Socket(IP, port);
// mSocket.setSoTimeout(30000);
DataOutputStream mDos = new DataOutputStream(mSocket.getOutputStream());
String str = "MobileRequest#" + params[0] + "#<EOF>";
mDos.write(str.getBytes());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
/* Since data are accepted as byte, all of them will be collected in the
following byte array which initialised with accepted data length. */
DataInputStream mDis = new DataInputStream(mSocket.getInputStream());
byte[] data = new byte[mDis.available()];
// Collecting data into byte array
for (int i = 0; i < data.length; i++)
data[i] = mDis.readByte();
// Converting collected data in byte array into String.
String RESPONSE = new String(data);यदि आप ByteArrayOutputStream का उपयोग करते हैं तो आप एक अतिरिक्त प्रतिलिपि बना रहे हैं। यदि आप इसे पढ़ना शुरू करने से पहले स्ट्रीम की लंबाई जानते हैं (जैसे InputStream वास्तव में एक FileInputStream है, और आप फ़ाइल पर file.length () कॉल कर सकते हैं, या InputStream एक zipfile प्रविष्टि InputStream है, और आप zipEntry को कॉल कर सकते हैं। लंबाई ()), तो बाइट में सीधे लिखना बेहतर है [] सरणी - यह आधी मेमोरी का उपयोग करता है, और समय बचाता है।
// Read the file contents into a byte[] array
byte[] buf = new byte[inputStreamLength];
int bytesRead = Math.max(0, inputStream.read(buf));
// If needed: for safety, truncate the array if the file may somehow get
// truncated during the read operation
byte[] contents = bytesRead == inputStreamLength ? buf
: Arrays.copyOf(buf, bytesRead);एनबी अंतिम पंक्ति से संबंधित फ़ाइलों को काट रहा है, जबकि स्ट्रीम पढ़ी जा रही है, अगर आपको उस संभावना को संभालने की आवश्यकता है, लेकिन यदि स्ट्रीम पढ़ने के दौरान फ़ाइल लंबी हो जाती है , तो बाइट में सामग्री [] सरणी लंबी नहीं होगी। नई फ़ाइल सामग्री को शामिल करने के लिए, सरणी को केवल पुरानी लंबाई के इनपुटस्ट्रीम लैंथ से काट दिया जाएगा ।
मैं इसका उपयोग करता हूं।
public static byte[] toByteArray(InputStream is) throws IOException {
ByteArrayOutputStream output = new ByteArrayOutputStream();
try {
byte[] b = new byte[4096];
int n = 0;
while ((n = is.read(b)) != -1) {
output.write(b, 0, n);
}
return output.toByteArray();
} finally {
output.close();
}
}यह मेरा कॉपी-पेस्ट संस्करण है:
@SuppressWarnings("empty-statement")
public static byte[] inputStreamToByte(InputStream is) throws IOException {
if (is == null) {
return null;
}
// Define a size if you have an idea of it.
ByteArrayOutputStream r = new ByteArrayOutputStream(2048);
byte[] read = new byte[512]; // Your buffer size.
for (int i; -1 != (i = is.read(read)); r.write(read, 0, i));
is.close();
return r.toByteArray();
}जावा 7 और बाद में:
import sun.misc.IOUtils;
...
InputStream in = ...;
byte[] buf = IOUtils.readFully(in, -1, false);sun.misc.IOUtils"जावा 7" नहीं है। यह एक मालिकाना, कार्यान्वयन विशिष्ट वर्ग है जो अन्य JRE कार्यान्वयन में मौजूद नहीं हो सकता है और अगले रिलीज में से किसी एक चेतावनी के बिना गायब हो सकता है।
यहाँ एक अनुकूलित संस्करण है, जो डेटा बाइट्स की नकल से यथासंभव बचने की कोशिश करता है:
private static byte[] loadStream (InputStream stream) throws IOException {
int available = stream.available();
int expectedSize = available > 0 ? available : -1;
return loadStream(stream, expectedSize);
}
private static byte[] loadStream (InputStream stream, int expectedSize) throws IOException {
int basicBufferSize = 0x4000;
int initialBufferSize = (expectedSize >= 0) ? expectedSize : basicBufferSize;
byte[] buf = new byte[initialBufferSize];
int pos = 0;
while (true) {
if (pos == buf.length) {
int readAhead = -1;
if (pos == expectedSize) {
readAhead = stream.read(); // test whether EOF is at expectedSize
if (readAhead == -1) {
return buf;
}
}
int newBufferSize = Math.max(2 * buf.length, basicBufferSize);
buf = Arrays.copyOf(buf, newBufferSize);
if (readAhead != -1) {
buf[pos++] = (byte)readAhead;
}
}
int len = stream.read(buf, pos, buf.length - pos);
if (len < 0) {
return Arrays.copyOf(buf, pos);
}
pos += len;
}
}कोटलिन में समाधान (जावा में भी काम करेगा, निश्चित रूप से), जिसमें आप आकार जानते हैं या नहीं, दोनों मामले शामिल हैं:
fun InputStream.readBytesWithSize(size: Long): ByteArray? {
return when {
size < 0L -> this.readBytes()
size == 0L -> ByteArray(0)
size > Int.MAX_VALUE -> null
else -> {
val sizeInt = size.toInt()
val result = ByteArray(sizeInt)
readBytesIntoByteArray(result, sizeInt)
result
}
}
}
fun InputStream.readBytesIntoByteArray(byteArray: ByteArray,bytesToRead:Int=byteArray.size) {
var offset = 0
while (true) {
val read = this.read(byteArray, offset, bytesToRead - offset)
if (read == -1)
break
offset += read
if (offset >= bytesToRead)
break
}
}यदि आप आकार जानते हैं, तो यह आपको अन्य समाधानों की तुलना में उपयोग की जाने वाली मेमोरी को दोगुना करने पर बचाता है (थोड़े समय में, लेकिन फिर भी उपयोगी हो सकता है)। ऐसा इसलिए है क्योंकि आपको संपूर्ण स्ट्रीम को अंत तक पढ़ना है, और फिर इसे बाइट सरणी (ArrayList के समान) में परिवर्तित करें जिसे आप केवल एक सरणी में परिवर्तित करते हैं)।
इसलिए, यदि आप Android पर हैं, उदाहरण के लिए, और आपको कुछ उड़ी संभालनी है, तो आप इसका उपयोग करके आकार प्राप्त करने का प्रयास कर सकते हैं:
fun getStreamLengthFromUri(context: Context, uri: Uri): Long {
context.contentResolver.query(uri, arrayOf(MediaStore.MediaColumns.SIZE), null, null, null)?.use {
if (!it.moveToNext())
return@use
val fileSize = it.getLong(it.getColumnIndex(MediaStore.MediaColumns.SIZE))
if (fileSize > 0)
return fileSize
}
//if you wish, you can also get the file-path from the uri here, and then try to get its size, using this: https://stackoverflow.com/a/61835665/878126
FileUtilEx.getFilePathFromUri(context, uri, false)?.use {
val file = it.file
val fileSize = file.length()
if (fileSize > 0)
return fileSize
}
context.contentResolver.openInputStream(uri)?.use { inputStream ->
if (inputStream is FileInputStream)
return inputStream.channel.size()
else {
var bytesCount = 0L
while (true) {
val available = inputStream.available()
if (available == 0)
break
val skip = inputStream.skip(available.toLong())
if (skip < 0)
break
bytesCount += skip
}
if (bytesCount > 0L)
return bytesCount
}
}
return -1L
}/*InputStream class_InputStream = null;
I am reading class from DB
class_InputStream = rs.getBinaryStream(1);
Your Input stream could be from any source
*/
int thisLine;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
while ((thisLine = class_InputStream.read()) != -1) {
bos.write(thisLine);
}
bos.flush();
byte [] yourBytes = bos.toByteArray();
/*Don't forget in the finally block to close ByteArrayOutputStream & InputStream
In my case the IS is from resultset so just closing the rs will do it*/
if (bos != null){
bos.close();
}