Как открыть и прочитать текстовый файл в Java

Управление текстовыми файлами - это навык, который хорошо послужит вам в вашей карьере программиста. В этом разделе вы узнаете, как создать, открыть и прочитать текстовый файл Java.

Под текстовым файлом мы имеем в виду файл с текстом - все просто! Вы можете создать текстовый файл в таких программах, как Блокнот на компьютере с Windows, TextEdit на Mac, Gedit в среде Linux/Gnome.

Первое, что мы сделаем, это откроем текстовый файл и прочитаем его содержимое.

Как прочитать текстовый файл

Для этой цели начните новый проект. Назовите пакет openandread, а класс ReadFile. Добавьте оператор импорта чуть ниже названия пакета и перед именем класса:

import java.io.IOException;

Ваше окно с кодом будет выглядеть так:

package openandread;
import java.io.IOException;

public class ReadFile {

    public static void main(String[] args) throws IOException {
         
    }  
}

Чтобы Java-программа работала корректно с нашими текстовыми файлами, добавьте следующее к методу main (текст на синем фоне):

public static void main(String[] args) throws IOException {

}

Мы говорим Java, что метод main вызовет ошибку IOException, и что ее необходимо устранить. Позже мы добавим блок try ... catch, чтобы отобразить соответствующее сообщение об ошибке для пользователя.

Чтобы открыть текстовый файл, давайте создадим новый класс. Итак выберите File > New File в меню NetBeans вверху. Создайте новый файл Java Class и дайте ему имя FileData. Когда ваш новый класс будет создан, добавьте следующие три оператора импорта:

import java.io.IOException;
import java.io.FileReader;
import java.io.BufferedReader;

Ваш новый класс должен выглядеть следующим образом:

Класс FileData

(Все три импорта подчеркнуты желтым цветом, потому что мы еще ничего с ними не сделали. Это функция NetBeans.)

Для того, чтобы прочитать текстовый файл Java, мы создадим новый объект из этого класса. Добавьте следующий конструктор в свой код вместе с приватным полем String с именем path_to_file:

public class FileData {
    
    private String path_to_file;
    
    public FileData (String path) {
        path_to_file = path;
    }
 
}

То, что мы здесь делаем, это передаем в метод имя переменной, содержащей путь к текстовому файлу, который будем читать, а затем присваиваем этой переменной новое имя, которое будем использовать в дальнейшем в нашем методе.

Теперь нам нужно создать метод, который возвращает все строки кода из текстового файла. Они будут храниться в массиве. Добавьте следующее объявление метода, который откроет файл:

Метод OpenAndRead

Не переживайте из-за красного подчеркивания: оно исчезнет, ​​как только мы добавим код. NetBeans добавляет подчеркивание, потому что у нас нет оператора return.

Обратите внимание, что метод настроен на возврат массива String:

public String[]

Массив будет содержать все строки из текстового файла.

Также обратите внимание, что мы добавили в конец заголовка метода throws IOException. Каждый метод, который работает над чтением текстовых файлов в Java, нуждается в подобном методе. Throw в переводе с английского означает «выбросить». Java выбросит ошибки, которые мы сможем увидеть в нашем методе main.

Для того, что прочитать символы из текстового файла используется FileReader. Он читает байты из текстового файла, а каждый байт является отдельным символом.

Вы можете читать целые строки текста, а не отдельные символы. Для этого нужно передать то, что находится в FileReader классу BufferedReader. BufferedReader имеет удобный метод, называемый ReadLine. Как следует из названия, он используется для чтения целых строк, а не отдельных символов. А вот BufferedReader сохраняет символы в памяти (в буфере), чтобы ими было легче манипулировать.

Давайте установим FileReader и BufferedReader:

public String[] OpenAndRead() throws IOException {
        
    FileReader x = new FileReader(path_to_file);
    BufferedReader varRead = new BufferedReader(x);
 
}

Здесь мы создаем два новых объекта: первый - это объект FileReader, который мы назвали x; второй - это объект BufferedReader с именем varRead.

FileReader открывает и считывает файл, исходя из пути к нему. Эту информацию мы сохраняем в переменной path_to_file. А дальше мы можем использовать ее.

В BufferedReader передается объект FileReader (в круглых скобках). Все символы файла затем сохранятся в памяти в ожидании манипуляции. Они сохранятся в переменной varRead.

Прежде чем мы сможем прочитать текст из нашего текстового файла, нам нужно настроить массив. Каждая позиция в массиве может содержать одну полную строку текста. Поэтому добавьте следующее в свой код:

int num = 3;
String[] lines = new String[num];

Сейчас мы установили количество строк в текстовом файле равным 3. Очевидно, что текстовые файлы могут содержать любое количество строк, и мы обычно не знаем, сколько их. Поэтому вскоре мы это изменим. Мы напишем отдельный метод, который получает количество строк в текстовом файле.

Дальше мы устанавливаем массив строк. Количество позиций в массиве (его размер) устанавливается равным количеству строк. Мы поместили эту переменную в квадратные скобки.

Чтобы поместить все строки текста из файла в каждую позицию в массиве, нам нужен цикл. Цикл получит каждую строку текста и поместит их в массив. Добавьте следующее в код:

int i;
for (i = 0; i < num; i++) {
    lines[i] = varRead.readLine();
}

Ваше окно с кодом должно выглядеть так:

public String[] OpenAndRead() throws IOException {

    FileReader x = new FileReader(path_to_file);
    BufferedReader varRead = new BufferedReader(x);
        
    int num = 3;
    String[] lines = new String[num];
        
    int i;
    for (i = 0; i < num; i++) {
        lines[i] = varRead.readLine();
    }

}

Цикл for идет от 0 до меньше, чем количества строк. (Помните, позиции массива начинаются с 0. Три строки будут сохранены в позициях 0, 1 и 2.)

Здесь мы обращаемся к строкам текста и сохраняем их в массив:

lines[i] = varRead.readLine();

После знака равенства мы имеем это:

varRead.readLine();

Объект varRead, который мы установили, читает все символы из текстового файла, которые находятся в памяти (в буфере). Мы можем использовать метод readLine, чтобы прочитать полную строку текстового файла из буфера. После того, как строка прочитана, мы сохраняем ее в позиции массива:

lines[i]

Переменная с именем i будет увеличиваться каждый раз согласно условиям цикла, проходя через весь массив, хранящий наш текст.

Осталось добавить в метод следующее:

varRead.close();
return lines;

Метод close очищает временный буфер памяти с именем varRead. Возвращаемая строка возвращает весь массив. Обратите внимание, что для этого массива квадратные скобки не требуются.

Когда вы закончите написание кода этого метода, все эти уродливые подчеркивания должны исчезнуть. Ваш метод должен выглядеть следующим образом:

public String[] OpenAndRead() throws IOException {

    FileReader x = new FileReader(path_to_file);
    BufferedReader varRead = new BufferedReader(x);
        
    int num = 3;
    String[] lines = new String[num];
        
    int i;
    for (i = 0; i < num; i++) {
        lines[i] = varRead.readLine();
    }
        
    varRead.close();
    return lines;
}

Однако все еще существует проблема количества строк. Мы указали жесткое 3. Нам нужно прочитать весь текстовый файл и посчитать, сколько в нем строк. Поэтому добавьте следующий метод в класс FileData:

int numStrings() throws IOException {

    FileReader text = new FileReader(path_to_file);
    BufferedReader y = new BufferedReader(text);
        
    String one;
    int num = 0;
        
    while ((one = y.readLine()) != null) {
        num++;
    }
    y.close();
        
    return num;
}

Новый метод называется numStrings и настроен на возврат целочисленного значения. Это количество строк в текстовом файле. Обратите внимание, что этот метод в заголовке также имеет IOException.

В этом коде устанавливается другой FileReader и другой BufferedReader. Чтобы поставить в цикл наш текст, мы написали:

while ((one = y.readLine()) != null) {
    num++;
}

Цикл while выглядит немного грязно. Но он просто говорит «прочитайте каждую строку текста и остановитесь, когда не будет достигнуто нулевое значение». (Если Java прочитала весь текстовый файл, и больше не осталось строк, вернется значение null.) В фигурных скобках мы увеличиваем счетчик с именем num.

В конце кода мы очищаем буфер памяти с именем y и возвращаем количество строк.

Чтобы вызвать этот новый метод в действие, измените методе OpenAndRead это:

int num = 3; 

На это:

int num = numStrings();

Таким образом, вместо жесткого указания количества строк, мы можем вызвать наш новый метод и получить количество строк в любом текстовом файле.

Хорошо, пришло время запустить новый класс и посмотреть, открывает ли он текстовый файл и сможет ли он прочитать его.

Вернитесь к классу ReadFile, классу с методом main. Установите строковую переменную для хранения имени текстового файла:

package openandread;
import java.io.IOException;

public class ReadFile {

    public static void main(String[] args) throws IOException {

        String new_path = "D:/test.txt";

    }  
}

На этом этапе вам нужно создать текстовый файл где-нибудь на компьютере. Мы создали его в блокноте на компьютере с Windows:

Текстовый файл

Имя текстового файла - test.txt. Создайте аналогичный у себя. Обратите внимание, куда вы его сохраняете, чтоб указать правильный путь к нему:

String new_path = "D:/test.txt";

Если бы мы создали папку с именем MyFiles для хранения этого файла, путь был бы «D: /MyFiles/test.txt». Измените путь к файлу, если это необходимо.

Следующее, что нужно сделать, - это создать новый объект из нашего класса FileData. Затем мы сможем вызвать метод, который откроет и прочитает наш текстовый файл в Java. Мы сделаем это в блоке try ... catch.

Добавьте следующий код под переменной String:

try {
    FileData new_file = new ReadFile(new_path);
    String[] aryStrings = new_file.OpenAndRead();

}
catch (IOException a) {
    System.out.println(a.getMessage());
}

Не забудьте все фигурные скобки для блока try ... catch. Вам нужна одна пара для части try и другая - для части catch. Для пробной части у нас есть это:

FileData new_file = new ReadFile(new_path);
String[] aryStrings = new_file.OpenAndRead();

Первая строка устанавливает новый объект FileData с именем new_file. В круглых скобках FileData мы добавили переменную new_path. Этого достаточно, чтобы передать конструктору путь к файлу, который ему нужен.

Вторая строка кода устанавливает массив String с именем aryStrings. После знака равенства мы вызвали метод OpenAndRead нашего класса FileData. Если он успешно открывает текстовый файл, то массив текстовых строк будет передан новому массиву aryStrings.

Однако, если что-то пойдет не так, появится ошибка, которую мы поместили в части catch блока try ... catch:

catch (IOException a) {
    System.out.println(a.getMessage());
}

После слова catch в круглых скобках у нас есть это:

IOException a

Для этого исключения мы устанавливаем переменную с именем a, которая имеет тип IOException. У объекта IOException есть собственные методы, которые вы можете использовать. Одним из таких методов является getMessage. Это даст пользователю некоторую информацию о том, что пошло не так.

Прежде чем мы увидим пример сообщения об ошибке, давайте пройдемся по всем строкам текстового файла, распечатав каждую. Добавьте следующий код цикла в try блока try ... catch:

int i;
for (i = 0; i < aryStrings.length; i++) {
    System.out.println(aryStrings[i]);
}

Ваше окно с кодом должно теперь выглядеть так:

package openandread;
import java.io.IOException;

public class ReadFile {

    public static void main(String[] args) throws IOException {

        String new_path = "D:/test.txt";
        
        try {
            ReadFile new_file = new FileData(new_path);
            String[] aryStrings = new_file.OpenAndRead();
            
            int i;
            for (i = 0; i < aryStrings.length; i++) {
                System.out.println(aryStrings[i]);
            }
        }
        catch (IOException a) {
            System.out.println(a.getMessage());
        }   
    }  
}

Когда программа будет запущена, в окне «Вывод» будет напечатано следующее:

Прочитать файл вывод

Как видите, с помощью Java мы прочитали каждую строку из нашего текстового файла.

Чтобы проверить часть кода, проверяющую ошибки, измените имя вашего текстового файла на тот, который, как вы знаете, не был создан. Затем запустите этот код. В окне «Вывод» ниже вы можете видеть, что наш текстовый файл был изменен на test2, и его не удалось найти:

Прочитать файл вывод с ошибкой

При желании вы можете добавить собственное сообщение об ошибке в блок catch:

catch (IOException e) {
    System.out.println("Извини, друг, не могу это сделать!");
}   

Прочитать файл вывод своей ошибки

Как прочитать текстовый файл с русскими буквами в Java

Если вас интересует, как прочитать текстовый файл на русском языке, то:

  1. Нужно добавить еще несколько import:
    import java.io.InputStreamReader;
    import java.io.Reader;
    import java.io.FileInputStream;
    
  2. В методе numStrings замените строку:
    FileReader text = new FileReader(path_to_file);
    

    На эту:

    Reader text = new InputStreamReader(new FileInputStream(path_to_file), "Cp1251");
    
  3. В методе OpenAndRead замените строку:
    FileReader x = new FileReader(path_to_file);
    

    На эту:

    Reader x = new InputStreamReader(new FileInputStream(path_to_file), "Cp1251");
    

Cp1251 – это кодировка, в которой выполнен текстовый файл. Мы конвертируем символы кириллицы с помощью InputStreamReader и FileInputStream.

Окно «Вывод» будет следующим:

Прочитать файл вывод кириллица

В следующем уроке вы узнаете, как сделать запись в уже существующий текстовый файл или создать новый, используя код Java.

Дата обновления: 01.09.2019

  • Текущий 0.00/5
  • 1
  • 2
  • 3
  • 4
  • 5

/Рейтинг: 0.0/5 (0 голос(ов) всего)

Добавить комментарий (без регистрации)