Несколько способов чтения файлов в Java 1. Прочитайте содержимое файла несколькими способами.
1. Чтение содержимого файла побайтово.
2. Чтение содержимого файла по символам
3. Прочитайте содержимое файла построчно.
4. Произвольное чтение содержимого файла
*/
импортировать java.io.BufferedReader;
импортировать java.io.File;
импортировать java.io.FileInputStream;
импортировать java.io.FileReader;
импортировать java.io.IOException;
импортировать java.io.InputStream;
импортировать java.io.InputStreamReader;
импортировать java.io.RandomAccessFile;
импортировать java.io.Reader;
общественный класс ReadFromFile {
/**
* Чтение файлов в байтах, часто используется для чтения двоичных файлов, таких как изображения, звуки, изображения и т. д.
* @param fileName Имя файла.
*/
public static void readFileByBytes(String fileName){
Файл файл = новый файл (имя файла);
Входной поток в = ноль;
пытаться {
System.out.println("Читать содержимое файла в байтах, по одному байту:");
//Читаем по одному байту за раз
в = новый FileInputStream (файл);
интервал темпбайт;
while((tempbyte=in.read()) != -1){
System.out.write(темпбайт);
}
в.закрыть();
} catch (IOException e) {
е.printStackTrace();
возвращаться;
}
пытаться {
System.out.println("Читать содержимое файла в байтах, по несколько байтов за раз:");
//Читаем несколько байтов за раз
байт[] tempbytes = новый байт[100];
INT byteread = 0;
в = новый FileInputStream (имя_файла);
ReadFromFile.showAvailableBytes(in);
//Читаем несколько байтов в массив байтов, byteread — это количество байтов, прочитанных за один раз
while ((byteread = in.read(tempbytes)) != -1){
System.out.write(tempbytes, 0, byteread);
}
} catch (Исключение e1) {
e1.printStackTrace();
} окончательно {
если (в != null){
пытаться {
в.закрыть();
} поймать (IOException e1) {
}
}
}
}
/**
* Чтение файлов в символьных единицах, часто используемых для чтения текста, чисел и других типов файлов.
* @param fileName имя файла
*/
public static void readFileByChars(String fileName){
Файл файл = новый файл (имя файла);
Читатель читатель = ноль;
пытаться {
System.out.println("Читать содержимое файла в символьных единицах, по одному байту:");
//Читаем по одному символу за раз
читатель = новый InputStreamReader (новый FileInputStream (файл));
интервал темпчар;
while ((tempchar = read.read()) != -1){
//Для Windows, когда два символа rn вместе, они представляют собой новую строку.
//Но если эти два символа будут отображаться отдельно, строки будут изменены дважды.
//Поэтому щит r или щит n. В противном случае будет много пустых строк.
if (((char)tempchar) != 'r'){
System.out.print((char)tempchar);
}
}
читатель.закрыть();
} catch (Исключение е) {
е.printStackTrace();
}
пытаться {
System.out.println("Читать содержимое файла в символьных единицах, по несколько байтов за раз:");
//Читаем несколько символов одновременно
char[] tempchars = новый char[30];
INT charread = 0;
читатель = новый InputStreamReader (новый FileInputStream (имя файла));
//Читаем несколько символов в массив символов, charread — это количество символов, считываемых за раз
while ((charread = reader.read(tempchars))!=-1){
//Аналогично защищаем r от отображения
if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){
System.out.print(tempchars);
}еще{
for (int i=0; i<charread; i++){
if(tempchars[i] == 'r'){
продолжать;
}еще{
System.out.print(tempchars[i]);
}
}
}
}
} catch (Исключение e1) {
e1.printStackTrace();
}окончательно {
если (читатель != ноль){
пытаться {
читатель.закрыть();
} поймать (IOException e1) {
}
}
}
}
/**
* Чтение файлов в построчных единицах, часто используется для чтения файлов в линейном формате.
* @param fileName имя файла
*/
public static void readFileByLines(String fileName){
Файл файл = новый файл (имя файла);
Читатель BufferedReader = null;
пытаться {
System.out.println("Читать содержимое файла построчно, читая по всей строке за раз:");
читатель = новый BufferedReader (новый FileReader (файл));
Строка tempString = ноль;
int линия = 1;
//Читаем по одной строке, пока в конце файла не будет прочитано значение null
while ((tempString = readLine()) != null){
//отображение номера строки
System.out.println("line " + line + ": " + tempString);
линия++;
}
читатель.закрыть();
} catch (IOException e) {
е.printStackTrace();
} окончательно {
если (читатель != ноль){
пытаться {
читатель.закрыть();
} поймать (IOException e1) {
}
}
}
}
/**
* Случайное чтение содержимого файла
* @param fileName имя файла
*/
public static void readFileByRandomAccess(String fileName){
RandomAccessFile СлучайныйФайл = ноль;
пытаться {
System.out.println("Прочитать случайное содержимое файла:");
//Открываем поток файлов с произвольным доступом в режиме только для чтения
RandomFile = новый RandomAccessFile (имя_файла, «r»);
//Длина файла, количество байт
длинный fileLength = случайный файл.длина();
//Читаем начальную позицию файла
int BeginIndex = (fileLength > 4)? 4: 0;
//Перемещаем начальную позицию читаемого файла в позицию BeginIndex.
СлучайныйФайл.seek(beginIndex);
байт[] байты = новый байт[10];
INT byteread = 0;
//Чтение 10 байт за раз. Если содержимое файла меньше 10 байт, читаем оставшиеся байты.
//Назначаем количество байтов, прочитанных за раз, для byteread
while ((byteread = randomFile.read(bytes)) != -1){
System.out.write(байты, 0, байтовое чтение);
}
} catch (IOException e){
е.printStackTrace();
} окончательно {
если (randomFile!= ноль){
пытаться {
СлучайныйФайл.закрыть();
} поймать (IOException e1) {
}
}
}
}
/**
* Отображение количества байт, оставшихся во входном потоке.
* @param в
*/
частная статическая сила showAvailableBytes (InputStream in) {
пытаться {
System.out.println("Количество байтов в текущем входном потоке байтов:" + in.available());
} catch (IOException e) {
е.printStackTrace();
}
}
public static void main(String[] args) {
Строка fileName = "C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(имя_файла);
ReadFromFile.readFileByChars(имя_файла);
ReadFromFile.readFileByLines(имя_файла);
ReadFromFile.readFileByRandomAccess(имя_файла);
}
}
2. Добавьте содержимое в конец файла.
импортировать java.io.FileWriter;
импортировать java.io.IOException;
импортировать java.io.RandomAccessFile;
/**
* Добавить содержимое в конец файла
*/
общественный класс AppendToFile {
/**
*Метод добавления файлов: используйте RandomAccessFile.
* @param fileName имя файла
* @param content дополнительный контент
*/
public static void AppendMethodA (String fileName,
Строковое содержимое){
пытаться {
// Открытие потока файлов с произвольным доступом в режиме чтения и записи
RandomAccessFile randomFile = новый RandomAccessFile (имя_файла, «rw»);
//Длина файла, количество байт
длинный fileLength = случайный файл.длина();
//Перемещаем указатель файла записи в конец файла.
RandomFile.seek(fileLength);
СлучайныйФайл.writeBytes(содержимое);
СлучайныйФайл.закрыть();
} catch (IOException e){
е.printStackTrace();
}
}
/**
* Метод B для добавления файлов: используйте FileWriter.
* @param имя_файла
* @param контент
*/
public static void AppendMethodB (String fileName, String Content) {
пытаться {
//Открытие файла записи. Второй параметр конструктора true означает запись файла в форме добавления.
FileWriter Writer = новый FileWriter (fileName, true);
писатель.писать (содержание);
писатель.закрыть();
} catch (IOException e) {
е.printStackTrace();
}
}
public static void main(String[] args) {
Строка fileName = "C:/temp/newTemp.txt";
String content = "новое добавление!";
//Добавляем файлы по методу А
AppendToFile.appendMethodA(имя_файла, содержимое);
AppendToFile.appendMethodA(fileName, "append end. n");
//Показать содержимое файла
ReadFromFile.readFileByLines(имя_файла);
//Добавляем файлы по методу Б
AppendToFile.appendMethodB(имя_файла, содержимое);
AppendToFile.appendMethodB(fileName, «добавление end. n»);
//Показать содержимое файла
ReadFromFile.readFileByLines(имя_файла);
}
}