Как прочитать содержимое файла java

Класс 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:

while((i=fin.read())!=-1)
Когда в потоке больше нет данных для чтения, метод возвращает число -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.
while((count=fin.read(buffer))!=-1)
Поскольку количество считанных байтов/размер файла могут быть меньше 256 байт, то реальное количество считанных байт сохраняем в переменную count. Затем выводим считанное количество данных на консоль в цикле for.
for(int i=0; i
Совместим оба класса и выполним чтение из одного и запись в другой файл:
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 предназначены прежде всего для записи двоичных файлов, то есть для записи и чтения байтов. И хотя они также могут использоваться для работы с текстовыми файлами, но все же для этой задачи больше подходят другие классы.
Как прочитать содержимое файла java
Для работы с файлами можно использовать методы из библиотеки java.nio.file. Библиотека предоставляет классы Path и Paths для работы с путями файлов, а также класс Files для манипулирования с файловой системой.
Сначала нужно сформировать путь к файлу с помощью класса Paths, например используя метод Paths.get(). Получившийся объект нужно использовать в методах класса Files.
Пример чтения файла:
import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; // Получаем путь к нужному файлу Path writeFilePath = Paths.get("/tmp/file.txt"); // Читаем файл String content = Files.readString(path); // Выводим содержимое System.out.println(content); 
Чтение и вывод на экран содержимое файла
Если вам требуется вывести текст файла в консоль, то лучше выводить его построчно через BufferedReader.
import java.io.*; public class FileRead < public static void main(String[] args) throws IOException< BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); File f = new File("/root/2/Files.txt"); BufferedReader fin = new BufferedReader(new FileReader(f)); String name; String line; System.out.println("Print File "+f.getName()+"? y/n"); name = br.readLine(); if(name.equals("y")) while ((line = fin.readLine()) != null) System.out.println(line); >> 
Отслеживать

ответ дан 22 мая 2013 в 7:46

1,065 8 8 серебряных знаков 23 23 бронзовых знака

Спасибо, всё прекрасно работает!

22 мая 2013 в 7:56

Как мне доставляет принцип блочного копирования в программировании. Прелесно!

27 мая 2013 в 7:39
FileInputStream file = new FileInputStream("file.txt"); Byte[] infile; file.read(infile[]); System.out.print(infile[]); 
Отслеживать

ответ дан 20 мая 2013 в 8:49

5,109 11 11 золотых знаков 49 49 серебряных знаков 97 97 бронзовых знаков

Вот вот так работает?

20 мая 2013 в 8:57

Нет не будет потому вы читаете как массив байтов 🙂

20 мая 2013 в 9:10
Нет, при компиляции prints.java:10: '.class' expected fin.read(infile[]); ^ prints.java:11: '.class' expected System.out.println(infile[]); ^ 2 errors Содержимое файла String наверно.
20 мая 2013 в 9:11
Если не System.out.println(fin.read()); а System.out.println(fin); то выводится java.io.FileInputStream@a90653
20 мая 2013 в 9:17
@Barmaley дык вроде любой текст это и есть массив байтов. "Текст" - это байты, отвечающие за "Т", "е", "к", "с" и "т"
20 мая 2013 в 9:25

файлы
java


   Важное на Мете 
Связанные
Похожие
Подписаться на ленту
Лента вопроса
Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.
Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.11.15.1019
Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.
Чтение текстовых файлов в Java
Проблема, с которой часто сталкиваются новички в Java, заключается в чтении данных из текстовых файлов. Допустим, есть файл, содержащий ASCII данные, и необходимо прочитать эти данные в программе. В Java существует несколько способов сделать это, каждый со своими особенностями.
BufferedReader и FileReader
Один из самых простых способов — использовать сочетание BufferedReader и FileReader . FileReader открывает поток для чтения из файла, а BufferedReader считывает текст из этого потока. Это позволяет читать данные построчно, что удобно для большинства текстовых файлов.
BufferedReader reader = new BufferedReader(new FileReader("file.txt")); String line; while ((line = reader.readLine()) != null) < System.out.println(line); >reader.close();
Scanner
Scanner — еще один класс в Java, который может быть использован для чтения файлов. Он удобен для чтения данных различных типов, таких как int, long, float и так далее, и может быть полезен, если файл содержит сложную структуру.
Scanner scanner = new Scanner(new File("file.txt")); while (scanner.hasNextLine()) < System.out.println(scanner.nextLine()); >scanner.close();
Files и Paths (Java 7 и выше)
В Java 7 и выше можно использовать классы Files и Paths для упрощения чтения файлов. Метод Files.readAllLines считывает все строки из файла в список, что может быть удобно, если файл не слишком большой.
List<String> lines = Files.readAllLines(Paths.get("file.txt")); for (String line : lines)
Заключение
Это лишь некоторые из возможных способов чтения текстовых файлов в Java. Выбор метода зависит от конкретной задачи и требований к программе.
Читать:
Что такое galaxy store в телефоне самсунг