file类
File类是Java中用于操作文件和目录的类。它提供了一系列的方法来创建、删除、重命名、复制、移动文件和目录,以及获取文件和目录的属性信息等操作。
下面是它的构造方法:
File(File parent, String child)
从父抽象路径名和子路径名字符串创建新的 File实例。
File(String pathname)
通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File(String parent, String child)
从父路径名字符串和子路径名字符串创建新的 File实例。
File(URI uri)
通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。
这是file类的常用方法:
- 创建文件或目录:使用File类的 createNewFile() 方法创建文件,使用 mkdir() 方法创建目录。
- 删除文件或目录:使用File类的 delete() 方法删除文件或目录。
- 重命名文件或目录:使用File类的 renameTo() 方法将文件或目录重命名。
- 复制文件或目录:可以使用File类结合输入输出流来复制文件或目录。
- 移动文件或目录:使用File类的 renameTo() 方法将文件或目录移动到目标位置。
- 获取文件或目录的属性信息:可以使用File类的方法获取文件或目录的名称、路径、大小、修改时间等属性信息。
import java.io.File;
import java.io.IOException;
public class FileExample {
public static void main(String[] args) {
try {
// 创建文件
File file = new File("example.txt");
boolean created = file.createNewFile();
if (created) {
System.out.println("文件创建成功!");
}
// 创建目录
File dir = new File("exampleDir");
boolean createdDir = dir.mkdir();
if (createdDir) {
System.out.println("目录创建成功!");
}
// 重命名文件
File newFile = new File("newExample.txt");
boolean renamed = file.renameTo(newFile);
if (renamed) {
System.out.println("文件重命名成功!");
}
// 删除文件
boolean deleted = newFile.delete();
if (deleted) {
System.out.println("文件删除成功!");
}
// 删除目录
boolean deletedDir = dir.delete();
if (deletedDir) {
System.out.println("目录删除成功!");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
注意:请注意,File类只是用于操作文件和目录的类,它并不涉及文件的内容读写操作。
字符流与字节流
在Java的IO流中,有不同类型的流用于处理不同的数据来源和目标。这些流可以分为字节流和字符流。
对于字节流来说
- InputStream和OutputStream是字节流的抽象类。它们用于处理字节数据。
- FileInputStream和FileOutputStream是用于读取和写入文件的字节流。它们可以用来读取和写入任意类型的文件。
FileInputStream和FileOutputStream类
FileInputStream:从文件系统中的文件获取输入字节。 什么文件可用取决于主机环境。
FileInputStream用于读取诸如图像数据的原始字节流。
这是它的构造方法:
FileInputStream(File file)
通过打开与实际文件的连接创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。
FileInputStream(FileDescriptor fdObj)
创建 FileInputStream通过使用文件描述符 fdObj ,其表示在文件系统中的现有连接到一个实际的文件。
FileInputStream(String name)
通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
FileInputStream类用于从文件中读取字节数据。它继承自InputStream类,并提供了一些额外的方法用于读取文件内容。使用FileInputStream,你可以打开一个文件并按字节顺序读取文件中的数据。以下是一些常用的方法:
- read() : 从流中读取一个字节的数据,并返回读取的字节值。当读取到文件末尾时,返回-1。
- read(byte[] buffer) : 从流中读取最多buffer.length个字节的数据,并存储到指定的字节数组buffer中。返回实际读取的字节数。
- close() : 关闭流,释放相关资源。
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("example.txt")) {
int data;
while ((data = fis.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
FileOutputStream类用于向文件中写入字节数据。它继承自OutputStream类,并提供了一些额外的方法用于写入文件内容。
这是他的构造方法:
FileOutputStream(File file)
创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(File file, boolean append)
创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(FileDescriptor fdObj)
创建文件输出流以写入指定的文件描述符,表示与文件系统中实际文件的现有连接。
FileOutputStream(String name)
创建文件输出流以指定的名称写入文件。
FileOutputStream(String name, boolean append)
创建文件输出流以指定的名称写入文件。
这是它的一些常用方法:
使用FileOutputStream,你可以打开一个文件并按字节顺序写入数据。以下是一些常用的方法:
- write(int b) : 将指定的字节写入流中。
- write(byte[] buffer) : 将指定的字节数组buffer中的数据写入流中。
- close() : 关闭流,释放相关资源。
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamExample {
public static void main(String[] args) {
try (FileOutputStream fos = new FileOutputStream("example.txt")) {
String data = "Hello, World!";
fos.write(data.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
}
ByteArrayInputStream
ByteArrayInputStream类是一个输入流,它从字节数组中读取数据。它继承自InputStream类,并提供了一些方法来读取字节数据,如read()、read(byte[] b)等。可以使用ByteArrayInputStream类来读取字节数组中的数据,而无需从外部文件或网络获取。
这是他的构造方法:
ByteArrayInputStream(byte[] buf)
创建一个 ByteArrayInputStream ,使其使用 buf作为其缓冲区数组。
ByteArrayInputStream(byte[] buf, int offset, int length)
创建 ByteArrayInputStream使用 buf作为其缓冲器阵列。
ByteArrayoutputStream
ByteArrayOutputStream类是一个输出流,它将数据写入到字节数组中。它继承自OutputStream类,并提供了一些方法来写入字节数据,如write(int b)、write(byte[] b)等。可以使用ByteArrayOutputStream类将数据写入到字节数组中,而无需将其写入到外部文件或网络。
这是他的构造方法:
ByteArrayOutputStream()
创建一个新的字节数组输出流。
ByteArrayOutputStream(int size)
创建一个新的字节数组输出流,具有指定大小的缓冲区容量(以字节为单位)。
这两个类通常一起使用,可以将数据从一个字节数组传递给另一个字节数组,或者将数据从字节数组读取到内存中。例如,可以使用ByteArrayOutputStream将数据写入到字节数组中,然后使用ByteArrayInputStream从字节数组中读取数据。
以下是一个简单的示例代码,演示了如何使用ByteArrayInputStream和ByteArrayOutputStream类:
byte[] data = { 1, 2, 3, 4, 5 };
// 使用ByteArrayOutputStream将数据写入字节数组
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
outputStream.write(data, 0, data.length);
// 获取写入的字节数组
byte[] writtenData = outputStream.toByteArray();
// 使用ByteArrayInputStream从字节数组中读取数据
ByteArrayInputStream inputStream = new ByteArrayInputStream(writtenData);
int byteRead;
while ((byteRead = inputStream.read()) != -1) {
System.out.println(byteRead);
}
// 关闭输入流和输出流
inputStream.close();
outputStream.close();
在上面的示例中,首先将数据写入到ByteArrayOutputStream中,然后通过调用 toByteArray() 方法获取写入的字节数组。接下来,使用ByteArrayInputStream从字节数组中读取数据,并打印每个字节的值。
BufferedReader
BufferedReader类用于从输入流中读取文本数据。它继承自Reader类,并提供了一些额外的方法来读取字符、行或整个文件。通过使用缓冲区,BufferedReader可以一次读取多个字符,减少了对底层输入流的访问次数,从而提高了读取效率。
这是它的构造方法:
BufferedReader(Reader in)
创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz)
创建使用指定大小的输入缓冲区的缓冲字符输入流。
BufferedWrite
BufferedWriter类用于向输出流中写入文本数据。它继承自Writer类,并提供了一些额外的方法来写入字符、字符串或字符数组。通过使用缓冲区,BufferedWriter可以一次写入多个字符,减少了对底层输出流的访问次数,从而提高了写入效率.
这是它的构造方法:
BufferedWriter(Writer out)
创建使用默认大小的输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz)
创建一个新的缓冲字符输出流,使用给定大小的输出缓冲区。
下面是一些常用方法的用例:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Main {
public static void main(String[] args) {
// 文件读取示例
try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
// 文件写入示例
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
writer.write("Hello, world!");
writer.newLine();
writer.write("This is a test.");
} catch (IOException e) {
e.printStackTrace();
}
}
}
InputStreamReader
InputStreamReader和OutputStreamWrite是Java中的两个类,用于在字节流和字符流之间进行转换。它们提供了将字节流转换为字符流和将字符流转换为字节流的功能。
这是它的构造方法:
InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, Charset cs)
创建一个使用给定字符集的InputStreamReader。
InputStreamReader(InputStream in, CharsetDecoder dec)
创建一个使用给定字符集解码器的InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
创建一个使用命名字符集的InputStreamReader。
OutputStreamWrite
OutputStreamWriter是将字符流转换为字节流的桥梁。它继承自Writer类,并接受一个字节输出流作为参数。通过指定的字符编码,OutputStreamWriter可以将字符流中的字符按照指定的字符编码转换为字节。
这是它的构造方法:
OutputStreamWriter(OutputStream out)
创建一个使用默认字符编码的OutputStreamWriter。
OutputStreamWriter(OutputStream out, Charset cs)
创建一个使用给定字符集的OutputStreamWriter。
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
创建一个使用给定字符集编码器的OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName)
创建一个使用命名字符集的OutputStreamWriter。
下面是他们之间的相互转换:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class Main {
public static void main(String[] args) {
// 将字节流转换为字符流示例
try (FileInputStream fis = new FileInputStream("input.txt");
InputStreamReader isr = new InputStreamReader(fis, "UTF-8")) {
int c;
while ((c = isr.read()) != -1) {
System.out.print((char) c);
}
} catch (IOException e) {
e.printStackTrace();
}
// 将字符流转换为字节流示例
try (FileOutputStream fos = new FileOutputStream("output.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8")) {
osw.write("Hello, world!");
osw.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
ObjectInputStream
ObjectInputStream和ObjectOutputStream是Java中的两个类,用于实现对象的序列化和反序列化
ObjectInputStream类用于从字节流中读取对象。它提供了一些方法来读取不同类型的数据和对象,与ObjectOutputStream对应。
这是它的构造方法:
protected ObjectInputStream()
为完全重新实现ObjectInputStream的子类提供一种方法,不必分配刚刚被ObjectInputStream实现使用的私有数据。
ObjectInputStream(InputStream in)
创建从指定的InputStream读取的ObjectInputStream。
ObjectOutputStream
ObjectOutputStream类用于将对象转换为字节流,以便可以将其存储在文件中或通过网络进行传输。它提供了一些方法来写入不同类型的数据和对象,包括基本类型、数组和自定义对象。
这是他的构造方法:
protected ObjectOutputStream()
为完全重新实现ObjectOutputStream的子类提供一种方法,不必分配刚刚被ObjectOutputStream实现使用的私有数据。
ObjectOutputStream(OutputStream out)
创建一个写入指定的OutputStream的ObjectOutputStream。
下面是他们的具体使用方法的用例:
import java.io.*;
public class SerializationExample {
public static void main(String[] args) {
// 创建一个对象
Person person = new Person("John", 25);
// 将对象序列化到文件
try {
FileOutputStream fileOut = new FileOutputStream("person.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(person);
out.close();
fileOut.close();
System.out.println("对象已序列化");
} catch (IOException e) {
e.printStackTrace();
}
// 从文件中反序列化对象
try {
FileInputStream fileIn = new FileInputStream("person.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
Person deserializedPerson = (Person) in.readObject();
in.close();
fileIn.close();
System.out.println("对象已反序列化");
System.out.println("Name: " + deserializedPerson.getName());
System.out.println("Age: " + deserializedPerson.getAge());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class Person implements Serializable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
使用这两个类,你可以将一个对象序列化为字节流,并将其存储在文件中。然后,你可以使用ObjectInputStream将字节流反序列化为对象,以便在需要时重新创建对象。
注意:
1.不可序列化的对象的子类可以是可序列化的
2.不进行序列化就无法进行反序列化
3.transient 关键字以及static关键字 修饰成员变量时,该变量不能够被序列化