Прочитать файл массив байт java
Я один понят условия задачи «поверхностное копирование» буквально, (Напиши программу, которая будет считывать с клавиатуры пути к двум директориям и копировать файлы из одной директории в другую (только файлы, директории игнорируй). и стал копировать файлы из первой во вторую и из второй в первую?
Синтаксический сахар var не работает с потоками почему то , подскажите что не так ? И метод of почему то подчеркивается красным
Метод writeString(Path path, String str) предназначен для записи строки в файл, указанный в объекте Path. При вызове этого метода Java создает файл, если он еще не существует, и записывает в него указанную строку. Если файл уже существует, содержимое файла будет заменено на указанную строку. Процесс работы метода writeString выглядит следующим образом: Определяется путь к файлу, который нужно создать или перезаписать, с помощью объекта Path. Создается объект Charset с кодировкой по умолчанию, если не указано другое. Строка, которую нужно записать в файл, преобразуется в последовательность байтов с помощью выбранной кодировки. Создается объект OutputStream для записи байтов в файл. Записываются байты в файл. OutputStream закрывается, чтобы сохранить данные в файле. Вот пример использования метода writeString:
import java.nio.file.Files; import java.nio.file.Path; import java.nio.charset.StandardCharsets; import java.io.IOException; public class Example < public static void main(String[] args) < String content = "Hello, world!"; Path file = Path.of("example.txt"); try < Files.writeString(file, content, StandardCharsets.UTF_8); >catch (IOException e) < e.printStackTrace(); >> > Этот код создаст файл «example.txt» в текущем каталоге и запишет в него строку «Hello, world!» в кодировке UTF-8. Если файл уже существует, содержимое файла будет заменено на эту строку.
Read File to Byte[] in Java
In Java, reading a file to byte array may be needed in various situations. For example, passing the information through the network and other APIs for further processing.
Let’s learn about a few ways of reading data from files into a byte array in Java.
1. Using Files.readAllBytes()
The Files.readAllBytes() is the best method for using Java 7, 8 and above. It reads all bytes from a file and closes the file. The file is also closed on an I/O error or another runtime exception is thrown.
This method read all bytes into memory in a single statement so do not use it to read large files, else you may face OutOfMemoryError.
Path path = Paths.get("C:/temp/test.txt"); byte[] data = Files.readAllBytes(path);Use FileInputStream for reading the content of a file when you already have the InputStream reference. Don’t forget to close the stream once the reading is done; else use try-with-resources block.
File file = new File("C:/temp/test.txt"); byte[] bytes = new byte[(int) file.length()]; try(FileInputStream fis = new FileInputStream(file)) 3. Using Apache Commons IO
Another good way to read data into a byte array is in the apache commons IO library. It provides several useful classes for dealing with IO operations.
In the following example, we are using the FileUtils class to read the file content into byte array. The file is always closed either success or read error.
byte[] bytes = FileUtils.readFileToByteArray(file);A similar class is IOUtils which can be used in the same way.
byte[] bytes = IOUtils.toByteArray(new FileInputStream(file));Another good way to read data into a byte array is in Google Guava library.
The following example uses the com.google.common.io.Files class to read the file content into a byte array.
byte[] bytes3 = com.google.common.io.Files.toByteArray(file);Прочитать файл массив байт java
Для работы с массивами байтов — их чтения и записи используются классы ByteArrayInputStream и ByteArrayOutputStream.
Чтение массива байтов и класс ByteArrayInputStream
Класс ByteArrayInputStream представляет входной поток, использующий в качестве источника данных массив байтов. Он имеет следующие конструкторы:
ByteArrayInputStream(byte[] buf) ByteArrayInputStream(byte[] buf, int offset, int length)
В качестве параметров конструкторы используют массив байтов buf , из которого производится считывание, смещение относительно начала массива offset и количество считываемых символов length .
Считаем массив байтов и выведем его на экран:
import java.io.*; public class Program < public static void main(String[] args) < byte[] array1 = new byte[]; ByteArrayInputStream byteStream1 = new ByteArrayInputStream(array1); int b; while((b=byteStream1.read())!=-1) < System.out.println(b); >String text = "Hello world!"; byte[] array2 = text.getBytes(); // считываем 5 символов ByteArrayInputStream byteStream2 = new ByteArrayInputStream(array2, 0, 5); int c; while((c=byteStream2.read())!=-1) < System.out.println((char)c); >> >
В отличие от других классов потоков для закрытия объекта ByteArrayInputStream не требуется вызывать метод close .
Запись массива байт и класс ByteArrayOutputStream
Класс ByteArrayOutputStream представляет поток вывода, использующий массив байтов в качестве места вывода.
Чтобы создать объект данного класса, мы можем использовать один из его конструкторов:
ByteArrayOutputStream() ByteArrayOutputStream(int size)
Первая версия создает массив для хранения байтов длиной в 32 байта, а вторая версия создает массив длиной size .
Рассмотрим применение класса:
import java.io.*; public class Program < public static void main(String[] args) < ByteArrayOutputStream baos = new ByteArrayOutputStream(); String text = "Hello Wolrd!"; byte[] buffer = text.getBytes(); try< baos.write(buffer); >catch(Exception ex) < System.out.println(ex.getMessage()); >// превращаем массив байтов в строку System.out.println(baos.toString()); // получаем массив байтов и выводим по символьно byte[] array = baos.toByteArray(); for(byte b: array) < System.out.print((char)b); >System.out.println(); > >
Как и в других потоках вывода в классе ByteArrayOutputStream определен метод write , который записывает в поток некоторые данные. В данном случае мы записываем в поток массив байтов. Этот массив байтов записывается в объекте ByteArrayOutputStream в защищенное поле buf , которое представляет также массив байтов ( protected byte[] buf ).
Так как метод write может сгенерировать исключение, то вызов этого метода помещается в блок try..catch.
Используя методы toString() и toByteArray() , можно получить массив байтов buf в виде текста или непосредственно в виде массива байт.
С помощью метода writeTo мы можем вывести массив байт в другой поток. Данный метод в качестве параметра принимает объект OutputStream , в который производится запись массива байт:
ByteArrayOutputStream baos = new ByteArrayOutputStream(); String text = «Hello Wolrd!»; byte[] buffer = text.getBytes(); try < baos.write(buffer); >catch(Exception ex) < System.out.println(ex.getMessage()); >try(FileOutputStream fos = new FileOutputStream(«hello.txt»)) < baos.writeTo(fos); >catch(IOException e)
После выполнения этой программы в папке с программой появится файл hello.txt, который будет содержать строку «Hello Wolrd!».
И в заключении также надо сказать, что как и для объектов ByteArrayInputStream, для ByteArrayOutputStream не надо явным образом закрывать поток с помощью метода close .
Прочитать файл массив байт java
Запись файлов и класс FileOutputStream
Класс FileOutputStream предназначен для записи байтов в файл. Он является производным от класса OutputStream, поэтому наследует всю его функциональность.
Через конструктор класса FileOutputStream задается файл, в который производится запись. Класс поддерживает несколько конструкторов:
FileOutputStream(String filePath) FileOutputStream(File fileObj) FileOutputStream(String filePath, boolean append) FileOutputStream(File fileObj, boolean append)
Файл задается либо через строковый путь, либо через объект File. Второй параметр — append задает способ записи: eсли он равен true, то данные дозаписываются в конец файла, а при false — файл полностью перезаписывается
Например, запишем в файл строку:
import java.io.*; public class Program < public static void main(String[] args) < String text = "Hello world!"; // строка для записи try(FileOutputStream fos=new FileOutputStream("notes.txt")) < // перевод строки в байты byte[] buffer = text.getBytes(); fos.write(buffer, 0, buffer.length); System.out.println("The file has been written"); >catch(IOException ex) < System.out.println(ex.getMessage()); >> > Для создания объекта FileOutputStream используется конструктор, принимающий в качестве параметра путь к файлу для записи. Если такого файла нет, то он автоматически создается при записи. Так как здесь записываем строку, то ее надо сначала перевести в массив байтов. И с помощью метода write строка записывается в файл.
Для автоматического закрытия файла и освобождения ресурса объект FileOutputStream создается с помощью конструктции try. catch.
При этом необязательно записывать весь массив байтов. Используя перегрузку метода write() , можно записать и одиночный байт:
fos.write(buffer[0]); // запись первого байта
Чтение файлов и класс FileInputStream
Для считывания данных из файла предназначен класс FileInputStream , который является наследником класса InputStream и поэтому реализует все его методы.
Для создания объекта FileInputStream мы можем использовать ряд конструкторов. Наиболее используемая версия конструктора в качестве параметра принимает путь к считываемому файлу:
FileInputStream(String fileName) throws FileNotFoundException
Если файл не может быть открыт, например, по указанному пути такого файла не существует, то генерируется исключение FileNotFoundException .
Считаем данные из ранее записанного файла и выведем на консоль:
import java.io.*; public class Program < public static void main(String[] args) < try(FileInputStream fin=new FileInputStream("notes.txt")) < int i; while((i=fin.read())!=-1)< System.out.print((char)i); >> catch(IOException ex) < System.out.println(ex.getMessage()); >> > В данном случае мы считываем каждый отдельный байт в переменную i:
Когда в потоке больше нет данных для чтения, метод возвращает число -1.
Затем каждый считанный байт конвертируется в объект типа char и выводится на консоль.
Подобным образом можно считать данные в массив байтов и затем производить с ним манипуляции:
import java.io.*; public class Program < public static void main(String[] args) < try(FileInputStream fin=new FileInputStream("notes.txt")) < byte[] buffer = new byte[256]; System.out.println("File data:"); int count; while((count=fin.read(buffer))!=-1)< for(int i=0; i> > catch(IOException ex) < System.out.println(ex.getMessage()); >> > В данном случае с помощью метода read() считываем данные в массив buffer длиной 256 байтов. Метод возвращает количество считанных байтов.
Поскольк файл может быть больше 256 байтов, то считываем в цикле while до конца файла. Когда больше не останется файлов для считывания, то метод возвратит -1.
Поскольку количество считанных байтов/размер файла могут быть меньше 256 байт, то реальное количество считанных байт сохраняем в переменную count. Затем выводим считанное количество данных на консоль в цикле for.
Совместим оба класса и выполним чтение из одного и запись в другой файл:
import java.io.*; public class Program < public static void main(String[] args) < try(FileInputStream fin=new FileInputStream("notes.txt"); FileOutputStream fos=new FileOutputStream("notes_new.txt")) < byte[] buffer = new byte[256]; int count; // считываем буфер while((count=fin.read(buffer))!=-1)< // записываем из буфера в файл fos.write(buffer, 0, count); >System.out.println("File has been written"); > catch(IOException ex) < System.out.println(ex.getMessage()); >> > Классы FileInputStream и FileOutputStream предназначены прежде всего для записи двоичных файлов, то есть для записи и чтения байтов. И хотя они также могут использоваться для работы с текстовыми файлами, но все же для этой задачи больше подходят другие классы.