Как в джаве считать из файла массив. Чтение и запись текстовых файлов. FileReader и FileWriter
Пакет java.io содержит почти каждый класс, который может потребоваться Вам для совершения ввода и вывода в Java. Все данные потоки представлены потоком ввода и адресом вывода. Поток в пакете java.io осуществляет поддержку различных данных, таких как примитивы, объекты, локализованные символы и т.д.
Потоки
Потоки в Java определяются в качестве последовательности данных. Существует два типа потоков:
- InPutStream – поток ввода используется для считывания данных с источника.
- OutPutStream – поток вывода используется для записи данных по месту назначения.
Java предоставляет сильную, но гибкую поддержку в отношении ввода/вывода, связанных с файлами и сетями, однако в данном руководстве рассмотрены лишь базовые функции, связанные с потоками и вводом/выводом. Рассмотрим далее по порядку наиболее распространенные примеры.
Байтовый поток
Потоки байтов в Java используются для осуществления ввода и вывода 8-битных байтов. Не смотря на множество классов, связанных с потоками байтов, наиболее распространено использование следующих классов: FileInputStream и FileOutputStream. Ниже рассмотрен пример, иллюстрирующий использование данных двух классов для копирования из одного файла в другой.
Примечание по примеру:
Пример
import java.io.*; public class FileCopy { public static void main(String args) throws IOException { FileInputStream fileIn = null; FileOutputStream fileOut = null; try { fileIn = new FileInputStream("file.txt"); fileOut = new FileOutputStream("copied_file.txt"); int a; // Копирование содержимого файла file.txt while ((a = fileIn.read()) != -1) { fileOut.write(a); // Чтение содержимого файла file.txt и запись в файл copied_file.txt } }finally { if (fileIn != null) { fileIn.close(); } if (fileOut != null) { fileOut.close(); } } } }Содержимое файла file.txt
В качестве следующего шага необходимо скомпилировать java-программу и выполнить ее, что позволит создать файл copied_file.txt с тем же содержимым, что имеется в file.txt. Таким образом, разместим обозначенный код в файле FileCopy.java и выполним следующее действие:
Символьные потоки
Потоки байтов в Java позволяют произвести ввод и вывод 8-битных байтов, в то время как потоки символов используются для ввода и вывода 16-битного юникода. Не смотря на множество классов, связанных с потоками символов, наиболее распространено использование следующих классов: FileReader и FileWriter. Не смотря на тот факт, что внутренний FileReader использует FileInputStream, и FileWriter использует FileOutputStream, основное различие состоит в том, что FileReader производит считывание двух байтов в конкретный момент времени, в то время как FileWriter производит запись двух байтов за то же время.
Мы можем переформулировать представленный выше пример, в котором два данных класса используются для копирования файла ввода (с символами юникода) в файл вывода.
Примечание по примеру: чтобы скопировать файл, необходимо в папке проекта создать файл file.txt с любым или пустым содержимым.
Пример
import java.io.*; public class FileCopy { public static void main(String args) throws IOException { FileReader fileIn = null; FileWriter fileOut = null; try { fileIn = new FileReader("file.txt"); fileOut = new FileWriter("copied_file.txt"); int a; while ((a = fileIn.read()) != -1) { fileOut.write(a); } } finally { if (fileIn != null) { fileIn.close(); } if (fileOut != null) { fileOut.close(); } } } }Теперь рассмотрим файл file.txt со следующим содержимым:
Содержимое файла file.txt
В качестве следующего шага необходимо скомпилировать программу и выполнить ее, что позволит создать файл copied_file.txt с тем же содержимым, что имеется в file.txt. Таким образом, разместим обозначенный код в файле FileCopy.java и выполним следующее действие:
$javac FileCopy.java $java FileCopy
Стандартные потоки
Все языки программирования обеспечивают поддержку стандартного ввода/вывода, где программа пользователя может произвести ввод посредством клавиатуры и осуществить вывод на экран компьютера. Если вы знакомы с языками программирования C либо C++, вам должны быть известны три стандартных устройства STDIN, STDOUT и STDERR. Аналогичным образом, Java предоставляет следующие три стандартных потока:
- Стандартный ввод – используется для перевода данных в программу пользователя, клавиатура обычно используется в качестве стандартного потока ввода, представленного в виде System.in.
- Стандартный вывод – производится для вывода данных, полученных в программе пользователя, и обычно экран компьютера используется в качестве стандартного потока вывода, представленного в виде System.out.
- Стандартная ошибка – используется для вывода данных об ошибке, полученной в программе пользователя, чаще всего экран компьютера служит в качестве стандартного потока сообщений об ошибках, представленного в виде System.err.
Ниже представлена простая программа, которая создает InputStreamReader для чтения стандартного потока ввода, до введения пользователем "q":
Пример
import java.io.*; public class ReadConsole { public static void main(String args) throws IOException { InputStreamReader inStRe = null; try { inStRe = new InputStreamReader(System.in); System.out.println("Введите символы, символ "q" для выхода."); char a; do { a = (char) inStRe.read(); System.out.print(a); } while(a != "q"); }finally { if (inStRe != null) { inStRe.close(); } } } }Разместим представленный выше код в файле ReadConsole.java и попробуем скомпилировать и выполнить его согласно тому, как это представлено в следующей программе. Данная программа продолжает чтение и вывод одного и того же символа до нажатия "q":
$javac ReadConsole.java $java ReadConsole Введите символы, "q" для выхода..su q q
Чтение и запись файла
Как было указано выше, поток представляет собой последовательность данных. InputStream используется для считывания данных с источника, OutputStream служит для записи данных по месту назначения.
Ниже представлена иерархия классов для управления потоками Ввода и Вывода.
В данном уроке нам предстоит рассмотреть два важных потока: FileInputStream и FileOutputStream.
Поток FileInputStream – чтение из файла
Поток FileInputStream – это поток, который используется в Java для чтения данных из файла. Объекты могут быть созданы при использовании ключевого слова new, доступны несколько типов конструкторов.
Представленный конструктор использует имя файла в качестве потока с целью создания объекта входного потока для считывания файла:
InputStream a = new FileInputStream("D:/myprogramm/java/test");
Представленный ниже конструктор использует объектный файл с целью создания объекта входного потока для чтения файла. Сперва мы создаем объектный файл при использовании метода File() следующим образом:
File a = new File("D:/myprogramm/java/test"); InputStream a = new FileInputStream(a);
Теперь, получив объект InputStream, следует ознакомиться со следующим перечнем вспомогательных методов, которые могут быть использованы для считывания потока либо выполнения иных операций в потоке.
| № | Метод и описание |
| 1 | public void close() throws IOException{}
Данный метод в Java закрывает выходной файловый поток. Освобождает какие-либо системные ресурсы, связанные с файлом. Выдает IOException. |
| 2 | protected void finalize()throws IOException {}
Данный метод выполняет очистку соединения с файлом. Позволяет удостовериться в вызове закрытого метода данного выходного файлового потока при отсутствии каких-либо ссылок на данный поток. Выдает IOException. |
| 3 | public int read(int r)throws IOException{}
Данный метод осуществляет в Java считывание заданных байтов данных из InputStream. Возврат данных типа int. Возврат следующего байта данных, в конце файла будет произведен возврат к -1. |
| 4 | public int read(byte r) throws IOException{}
Данный метод производит считывание байтов r.length из входного потока в массив. Возврат общего числа считанных байтов. В конце файла будет произведен возврат к -1. |
| 5 | public int available() throws IOException{}
Выдает число байтов, которые могут быть считаны из входного файлового потока. Возврат данных типа int. |
Существуют также другие доступные входные потоки, более детальные сведения о которых представлены по следующим ссылкам (ссылки временно неактивны):
Поток FileOutputStream – создание и запись файла
Поток FileOutputStream – это поток, который используется в Java для создания файла и последующей записи в него. Поток создаст файл в случае его отсутствия перед его открытием для вывода.
Представленный конструктор использует имя файла в качестве строки с целью создания объекта входного потока для записи файла в Java:
OutputStream a = new FileOutputStream("D:/myprogramm/java/test")
Представленный ниже конструктор использует объектный файл с целью создания объекта выходного потока для записи файла. Сперва мы создаем объектный файл при использовании метода File() следующим образом:
File a = new File("D:/myprogramm/java/test"); OutputStream a = new FileOutputStream(a);
Теперь, получив объект OutputStream, следует ознакомиться со следующим перечнем вспомогательных методов, которые могут быть использованы для записи потока либо выполнения иных операций в потоке.
Существуют также другие доступные выходные потоки, более детальные сведения о которых представлены по следующим ссылкам (ссылки временно неактивны):
Пример
В следующем примере представлены InputStream и OutputStream – потоки для чтения, создания и записи файла:
Import java.io.*; public class File { public static void main(String args) { try { char c = {"a","b","c"}; OutputStream output = new FileOutputStream("file.txt"); // Создание текстового файла for(int i = 0; i
Представленный выше java-код создаст файл file.txt и пропишет заданные символы в формате char. То же самое будет выводиться на экран стандартного вывода.
Навигация по файловой системе и вводу/выводу
Существует ряд других классов, которые нам предстоит рассмотреть с целью ознакомления с основами навигации в файловой системе и вводу/выводу.
- File Class
- FileReader Class
- FileWriter Class
Каталоги в Java
В Java каталог представлен Файлом, который может содержать список других файлов и каталогов. Используя объект File, вы можете создать каталог, прокрутить список файлов, представленных в каталоге. Для получения более детальных сведений, ознакомьтесь с перечнем всех методов, которые могут быть вызваны из объекта File, будучи связанными с каталогами.
Создание каталогов
Существуют два служебных метода File, которые могут быть использованы для создания каталогов:
- Метод mkdir() позволяет создать папку в Java, возвращая значение true при успехе операции, и false в случае сбоя. Сбой свидетельствует о том, что путь указанный в объекте File уже существует, либо что каталог не может быть создан в связи с тем, что полный путь еще не существует.
- Метод mkdirs() создает каталог и все вышестоящие каталоги.
В следующем примере представлено создание папки "/java/proglang/newdir":
Пример
import java.io.File; public class CreateDirectory { public static void main(String args) { String nameDir = "/java/proglang/newdir"; File a = new File(nameDir); // Создание на диске папки и всех вышестоящих каталогов a.mkdirs(); } }Скомпилируйте и выполните следующий код для создания каталога "/java/proglang/newdir".
Примечание? Java автоматически формирует разделители пути в UNIX и Windows с учетом соглашений. При использовании косой черты (/) при работе с Java в системе Windows, производится корректное разрешение пути.
Список файлов в папке
Метод list(), представленный объектом File, может быть использован для предоставления перечня всех файлов и каталогов, имеющихся в заданной папке, в следующем виде:
Пример
import java.io.File; public class ReadDirectory { public static void main(String args) { File pathDir = null; String pathsFilesAndDir; try { // Создание нового объекта file pathDir = new File("/NetBeans 8.2/Projects/ReadDirectory/ReadDirectory/"); // Обязательно должен существовать указанный каталог на диске, иначе программа выдаст ошибку // Массив файлов и папок pathsFilesAndDir = pathDir.list(); for(String path:pathsFilesAndDir) { // Вывод списка файлов и каталогов System.out.println(path); } }catch(Exception e) { // Если произошла ошибка e.printStackTrace(); } } }Вследствие этого будет получен следующий результат, основанный на каталогах и файлах, доступных в вашем каталоге /NetBeans 8.2/Projects/ReadDirectory/ReadDirectory/:
Build build.xml manifest.mf nbproject src ReadDirectory
Считать содержимое файла в Java непросто, необходимо использовать большое количество шаблонного кода, с которым мы уже сталкивались в предыдущем примере в статье считывание текстовых файлов . Нам приходилось делать «обертки» для многих вещей, например, помещать FileInputStream внутри BufferedReader, задавать циклы со странными условиями выхода и т.д. Начиная с JDK 7, ситуация значительно улучшилась. JDK предоставляет множество полезных классов, например Files и Paths, предназначенных для работы с файлами и путями к ним. В этой статье вы узнаете, как считать информацию из файла с помощью одной строки кода. Безусловно, ваш продакшн-код будет выглядеть иначе, особенно если вы считываете в память несколько гигабайт данных и при этом хотите учитывать кодировку. Если кодировка не выбрана, то используется кодировка платформы, заданная по умолчанию . Короче говоря, вам понадобится чуть больше кода, но для быстрого и грубого считывания файла этого способа будет достаточно. Кстати, если код будет содержать и обработку исключений, то он займет несколько строк. В готовом рабочем приложении вам нужно будет учитывать ситуацию, когда файл отсутствует, например, отображая пользователю сообщение об ошибке, отправляя метрики, сохраняя в журнал ошибку и т.д., но в любом случае в нем будет гораздо меньше шаблонного кода, чем в привычных для вас случаях.
Java 8 упростила жизнь разработчиков с помощью своего нового набора методов, которые используют преимущества API потоков (stream API). Кроме того, в класс File s было добавлено несколько новых методов, всегда использующих UTF-8, вместо произвольной кодировки платформы, например, Files.readAllLines(). Этот метод считывает все строки из файла. Байты из файла расшифровываются в символы с помощью кодировки UTF-8. Метод является эквивалентным методу Java 7 Files.readAllLines(path, StandardCharsets.UTF_8). Кстати, ВСЕГДА явно указывайте кодировку символов при конвертировании массива байтов в строку String . Всегда явно указывайте кодировку, даже если ваш считываемый файл в текущий момент содержит только английский язык.
Считывание файла одной строкой кода в Java 7 и 8
Перед вами пример нашей программы на Java, демонстрирующей, как полностью считать файл всего одной строчкой кода. В нашем примере используется новый класс Files, появившийся в JDK 1.7, класс java.nio.file.Files содержит множество полезных методов для работы с файлами в Java, например, проверка, является ли файл скрытым , или доступен ли он только для чтения. Вы можете использовать команду Files.readAllBytes(Путь), чтобы полностью считать файл в память. Этот метод возвращает массив байтов, который может быть передан в конструктор String для создания из него строки String. Также метод позволяет гарантировать, что файл будет закрыт надлежащим образом после считывания всех байтов, или в случае возникновения ошибки ввода-вывода либо любого другого необработанного исключения, что означает, что вам не нужно , то есть, не нужно будет писать шаблонный код. Следует отметить, что данный метод не подходит для считывания больших файлов, поскольку, если в Heap будет недостаточно свободного места, у вас может закончиться память. Также вам следует явно указывать кодировку символов при конвертировании массива байтов в строку String во избежание неприятных сюрпризов или ошибки парсинга.
Если же вы хотите считать файл, как строку String, вы можете использовать другой метод, который называется readAllLines(Path path, Charset cs). Этот метод похож на предыдущий, т.е. он тоже закрывает файлы после считывания или в случае возникновения ошибки, но вместо массива байтов он возвращает строку, которая конвертируется из байтов с помощью указанного набора символов. Кроме того, в Java 8 была добавлена еще одна перегруженная версия этого метода, которая не требует параметра Charset (кодировка), и использует UTF-8 для конвертации байтов в String.
Приятности на этом не заканчиваются. Если вы хотите считать файл построчно , то можете воспользоваться методом Files.lines(), возвращающим поток со строками, считанными из файла, в которых байты конвертируются в символы с помощью кодировки UTF-8. Используя метод forEach(), вы можете вывести все строки файла в консоль с помощью всего одной строчки Java-кода, что продемонстрировано в третьем фрагменте кода.
import java.io.IOException; import import java.nio.file.Files; import java.nio.file.Paths; import java.util.List; /** * Simple Java program to read a text file into String in Java. * You can use this one liner code for quickly reading file and displaying * as String. * @author Javin Paul */ public class Java78FileReadingExample { public static void main(String args) throws IOException { System.out .println(new String(Files.readAllBytes (Paths.get ("data_old.txt" )))); System.out .println(new String(Files.readAllBytes (Paths.get ("info.xml" )))); // Java 8 Example - Uses UTF-8 character encoding List
Вы можете сделать код еще короче, используя статический импорт в Java , как показано ниже:
import static java.lang.System.out ; import static java.nio.file.Files.readAllBytes ; import static java.nio.file.Paths.get; /** * Java Class to read a file in one line */ public class FileIntoString { public static void main(String args) throws Exception { out .println(new String(readAllBytes (get ("data_old.txt" )))); } }Если вы используете Java 8, вы также можете воспользоваться Stream API, дающим возможность писать более лаконичный и производительный код, что показано в следующем примере. Здесь метод lines() возвращает Stream of String (поток строк), который конвертируется из байтов, считанных из файла, в символы с помощью кодировки UTF-8. Это равносильно вызову метода Files.lines(path, StandardCharsets.UTF_8) в Java 7.
package test; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Paths; /** * Java Program to demonstrate how to read File in Java 8 using Stream. * @author Javin Paul */ public class Java8FileReader { public static void main(String args) throws IOException { // В Java 8 вы можете использовать Streams и для дальнейшей оптимизации Files.lines (Paths.get ("manifest.mf" ), StandardCharsets.UTF_8 ).forEach(System.out ::println); } }Вот и все, что вам нужно знать, чтобы считать текст или бинарный файл с помощью одной строчки кода в Java 7. Как видите, новые инструменты File API в JDK 7 и Stream API в Java 8 значительно упростили задачу по считыванию данных из файлов в Java. Этот позволило полностью избавиться от шаблонного кода, что привело к гораздо более понятному и лаконичному коду. Кстати, если вы пишете продакшн-код, который выполняет считывание информации из файла, то не забудьте обратить внимание на следующие моменты:
- Файл может быть слишком большим для помещения в память, поэтому перед считыванием внимательно изучайте его размер и учитывайте ситуации, когда не сможете считать файл.
- Сохраняйте в журнале все сообщения о причинах невозможности считывания файла или об ошибках, возникших в процессе считывания.
- Всегда указывайте кодировку символов, считывая байты в символы.
- Помните, файл может и отсутствовать, так что эту ситуацию тоже нужно учесть.
Каждое приложение, программа имеют возможности записи чего-либо в файл. В данном уроке я продемонстрирую как можно записать какие-то данные в файл, а потом считать их оттуда.
Какие проблемы мы будем решать в этом уроке?
Подготовительные работы
Создадим простой проект, не обязательно Maven проект, так как нам не потребуется не каких дополнительных библиотек.
После того как вы создали проект, создайте класс WorkInFile.java и напишите туда стандартную конструкцию main:
Public static void main(String args){ //тут будем вызывать наши методы }
Теперь создадим класс который будет иметь методы для работы с файлами, а назовем его FileWorker.java все методы в нем которые не есть private будут для того чтобы мы получали к ним доступ без экземпляра этого класса.
Как записывать в файл?
В классе FileWorker.java создадим который будет осуществлять запись в файл и назовем этот метод write (String text ; String nameFile ):
Public static void write(String fileName, String text) { //Определяем файл File file = new File(fileName); try { //проверяем, что если файл не существует то создаем его if(!file.exists()){ file.createNewFile(); } //PrintWriter обеспечит возможности записи в файл PrintWriter out = new PrintWriter(file.getAbsoluteFile()); try { //Записываем текст у файл out.print(text); } finally { //После чего мы должны закрыть файл //Иначе файл не запишется out.close(); } } catch(IOException e) { throw new RuntimeException(e); } }
Обратите особое внимание на то, что после записи каких либо данных в файл мы должны его закрыть, только после этого действия данные запишутся в файл.
Private static String text = "This new text \nThis new text2\nThis new text3\nThis new text4\n"; private static String fileName = "C://blog/a.txt"; public static void main(String args) throws FileNotFoundException { //Запись в файл FileWorker.write(fileName, text); }
После чего мы получим новый файл «a.txt » со следующим содержимым:
This new text This new text2 This new text3 This new text4
2. Как читать файл?
Теперь в классе FileWorker создадим метод для чтения файла, также статический:
Public static String read(String fileName) throws FileNotFoundException { //Этот спец. объект для построения строки StringBuilder sb = new StringBuilder(); exists(fileName); try { //Объект для чтения файла в буфер BufferedReader in = new BufferedReader(new FileReader(file.getAbsoluteFile())); try { //В цикле построчно считываем файл String s; while ((s = in.readLine()) != null) { sb.append(s); sb.append("\n"); } } finally { //Также не забываем закрыть файл in.close(); } } catch(IOException e) { throw new RuntimeException(e); } //Возвращаем полученный текст с файла return sb.toString(); }
StringBuilder — в чем разница между обычным String? В том что когда вы в StringBuilder добавляете текст он не пересоздается, а String пересоздает себя.
Также если файла нет то метод выкинет Exception.
Для проверки на существование файла создадим метод, так как нам еще потребуется эта проверка в следующих методах:
Private static void exists(String fileName) throws FileNotFoundException { File file = new File(fileName); if (!file.exists()){ throw new FileNotFoundException(file.getName()); } }
Теперь проверим его:
Private static String text = "This new text \nThis new text2\nThis new text3\nThis new text4\n"; private static String fileName = "C://blog/a.txt"; public static void main(String args) throws FileNotFoundException { //Попытка прочитать несуществующий файл FileWorker.read("no_file.txt"); //Чтение файла String textFromFile = FileWorker.read(fileName); System.out.println(textFromFile); }
В первом случае когда файл не существует мы получим это:
Exception in thread "main" java.io.FileNotFoundException: no_file.txt at com.devcolibri.tools.FileWorker.read(FileWorker.java:31)
Во втором случае, мы получим содержимое файла в виде строки. (для этого закомментируйте первый случай )
3. Как обновить файл?
Как такого Update для файлов нет, но способ обновить его есть, для этого можно его перезаписать.
Давайте создадим метод update в классе FileWorker:
Public static void update(String nameFile, String newText) throws FileNotFoundException { exists(fileName); StringBuilder sb = new StringBuilder(); String oldFile = read(nameFile); sb.append(oldFile); sb.append(newText); write(nameFile, sb.toString()); }
Тут мы считываем старый файл в StringBuilder после чего добавляем к нему новый текст и записываем опять. Обратите внимание что для этого мы используем наши методы.
В результате обновления файла:
Private static String text = "This new text \nThis new text2\nThis new text3\nThis new text4\n"; private static String fileName = "C://blog/a.txt"; public static void main(String args) throws FileNotFoundException { //Обновление файла FileWorker.update(fileName, "This new text"); }
мы получим следующее содержание файла «a.txt «:
This new text This new text2 This new text3 This new text4 This new text
4. Как удалить файл?
В тот же наш утилитный класс FileWorker добавим метод delete, он будет очень простым так как у объекта File уже есть метод delete ():
Public static void delete(String nameFile) throws FileNotFoundException { exists(nameFile); new File(nameFile).delete(); }
Проверяем:
Private static String fileName = "C://blog/a.txt"; public static void main(String args) throws FileNotFoundException { //Удаление файла FileWorker.delete(fileName); }
После чего файл будет удален.
Правила перепечатки сайта www.сайт
Уважаемый посетитель проекта!
В этом документе, Вы можете узнать на каких условиях Вы сможете использовать материалы, сайта www..д. и т.п.
Вам разрешается свободно использовать в своих целях любой документ при соблюдении следующих условий:
Содержание урока или статьи при перепечатке не должно подвергаться модификациям и переделке. Все уроки и статьи, размещенные на сайте, должны перепечатываться как есть. Вы не имеете права урезать, исправлять или иным образам коверкать републикуемый документ. Но если это жизненно важно, Вы можете обратиться к администратору проекта www.. Без письменного согласия администратора, модифицировать документ запрещается!!!
В конце перепечатываемого документа Вы обязаны вставить ссылку на сайт www.сайт.
Ссылка на сайт , обязательно должна быть работоспособной (при нажатии человек должен выходить на сайт автора). Если Вы перепечатали какой-либо документ, обязательно проверьте ссылку на работоспособность.
Хотя с помощью ранее рассмотренных классов можно записывать текст в файлы, однако все же их возможностей для полноценной работы с текстовыми файлами недостаточно. И для этой цели служат совсем другие классы, которые являются наследниками абстрактных классов Reader и Writer .
Запись файлов. Класс FileWriter
Класс FileWriter является производным от класса Writer. Он используется для записи текстовых файлов.
Чтобы создать объект FileWriter, можно использовать один из следующих конструкторов:
FileWriter(File file) FileWriter(File file, boolean append) FileWriter(FileDescriptor fd) FileWriter(String fileName) FileWriter(String fileName, boolean append)
Так, в конструктор передается либо путь к файлу в виде строки, либо объект File, который ссылается на конкретный текстовый файл. Параметр append указывает, должны ли данные дозаписываться в конец файла (если параметр равен true), либо файл должен перезаписываться.
Запишем в файл какой-нибудь текст:
Import java.io.*; public class FilesApp { public static void main(String args) { try(FileWriter writer = new FileWriter("C:\\SomeDir\\notes3.txt", false)) { // запись всей строки String text = "Мама мыла раму, раму мыла мама"; writer.write(text); // запись по символам writer.append("\n"); writer.append("E"); writer.flush(); } catch(IOException ex){ System.out.println(ex.getMessage()); } } }
В конструкторе использовался параметр append со значением false - то есть файл будет перезаписываться. Затем с помощью методов, определенных в базовом классе Writer производится запись данных.
Чтение файлов. Класс FileReader
Класс FileReader наследуется от абстрактного класса Reader и предоставляет функциональность для чтения текстовых файлов.
Для создания объекта FileReader мы можем использовать один из его конструкторов:
FileReader(String fileName) FileReader(File file) FileReader(FileDescriptor fd)
А используя методы, определенные в базом классе Reader, произвести чтение файла:
Import java.io.*; public class FilesApp { public static void main(String args) { try(FileReader reader = new FileReader("C:\\SomeDir\\notes3.txt")) { // читаем посимвольно int c; while((c=reader.read())!=-1){ System.out.print((char)c); } } catch(IOException ex){ System.out.println(ex.getMessage()); } } }
Java имеет множество инструментов для работы с файлами, поскольку они служат хранилищем данных во многих программах. Особенно часто доступ к файлам требуется в Java Android. Все классы для работы с файлами расположены в пакете java.io, где также хранятся классы для работы с потоками ввода и вывода. Строго говоря, в Java работа с файлами происходит преимущественно через байтовые и символьные потоки ввода-вывода. Исключением в данном случае является класс File. С него и начнем.
Класс File Java - работа с файлами
Класс File взаимодействует непосредственно с файлами и файловой системой. Экземпляр данного класса используется, прежде всего, для доступа к и перемещения по иерархии подкаталогов. В нем не определены способы извлечения и сохранения данных в файл, но с помощью этого класса можно получить множество сведений о самом файле: дата, время, права доступа и путь к каталогу. По сути, класс File является объектной интерпретацией файла или каталога в Java.
Чтобы создать экземпляр класса File, используют один из его конструкторов: File(String путь к папке, String имя файла).
Рассмотрим основные методы данного класса, позволяющие получать сведения о файле или каталоге:
- getName() - возвращает имя файла;
- exists() - возвращает логическое значение true, если файл существует, или false в обратном случае;
- isFile() - определяет, указывает ли объект на файл, возвращая соответствующее логическое значение;
- isDirectory() - возвращает true, если это папка;
- canWrite() - возвращает true, если файл доступен для записи;
- canRead() - возвращает true, если файл доступен для чтения;
- setReadOnly() - делает файл доступным только для чтения;
- length() - возвращает размер файла в байтах;
- renameTo(File новое имя) - переименовывает текущий файл в соответствии с переданным аргументом. Возвращает true, если операция успешна;
- delete() - удаляет файл или папку (если она пуста), на который указывает вызывающий объект;
- list() - извлекает список имен объектов, хранящихся в данном каталоге, в виде массива строк (применим исключительно к каталогам).
Таким образом, с помощью класса File обеспечивается в Java работа с файлами и папками.
Работа с файлами посредством классов FileInputStream и FileOutputStream
Ранее мы упоминали, что в Java работа с файлами осуществляется преимущественно посредством потоков ввода-вывода. Байтовые потоки для работы с файлами представлены в виде классов FileInputStream и FileOutputStream. Эти классы являются наследниками базовых InputStream и OutputStream соответственно, поэтому методы этих классов доступны для работы с файлами.
Рассмотрим сначала FileInputStream. Конструкторы данного класса представлены на рисунке ниже:
Первый конструктор принимает в качестве аргумента путь к целевому файлу в виде строки, а второй - в виде объектного представления. Хотя первый конструктор используется чаще, во втором случае есть возможность изучить свойства файла доступными в классе File методами. При создании экземпляра класса FileInputStream открывает поток ввода для чтения файла.
Конструкторы класса FileOutputStream показаны ниже:
Ситуация похожа на FileInputStream, но он также может принимать логическое значение “append”, которое при true говорит о том, что данные, записываемые в целевой файл будут дописываться к уже имеющимся, а при false - будет идти полная перезапись файла, т.е. старые данные не сохранятся.
Давайте разберем пример с использованием этих классов:
Поток ввода FileInputStream читает данные из файла file1.txt побайтово при помощи метода read(). Каждый прочитанный байт сохраняется в переменную в целочисленном виде. Далее в теле эта переменная передается в качестве аргумента методу write экземпляра FileOutputStream, который записывает принятый байт в файл file2.txt. В конце оба потока в обязательном порядке закрываются при помощи метода close.
Классы FileReader и FileWriter
Если вам заведомо известно, что при работе с файлами вы будете иметь дело с текстом, то вместо байтовых потоков имеет смысл использовать символьные. Данные потоки представлены классами FileReader и FileWriter в Java. Работа с файлами при помощи этих классов происходит примерно так же, как и в предыдущем случае. Они являются потомками классов Reader и Writer соответственно, в которых определены основные методы для ввода и вывода данных.
Конструкторы классов FileReader и FileWriter представлены на рисунке ниже:
Согласитесь, отличий в семантике по сравнению с байтовыми потоками практически нет. Суть в том, что данные классы предназначены специально для работы с символами в Юникоде, чего не могут делать байтовые потоки. Вот таким образом организована в Java работа с файлами. Пример использования данных классов приведен ниже:
Как видите, отличий не наблюдается. Стоит отметить, что хотя потоки символьные, метод read возвращает, а метод write принимает целочисленное значение. Хотя сигнатура метода write предполагает прием аргумента типа int, записывается в поток только младшие 16 бит, поскольку символы в Java представляются именно таким количеством бит.
Заключение
Итак, мы разобрали основные классы для работы с файлами в Java. Стоит отметить, что если вы собираетесь разрабатывать ПО под Java Android, можете смело использовать данный инструментарий.