Java基础回顾系列-第七天-高级编程之IO

2024-09-08 15:32
文章标签 java 基础 系列 编程 回顾 高级 io 第七天

本文主要是介绍Java基础回顾系列-第七天-高级编程之IO，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Java基础回顾系列-第七天-高级编程之IO

    • 文件操作
    • 字节流与字符流
      • OutputStream字节输出流
        • FileOutputStream
      • InputStream字节输入流
        • FileInputStream
      • Writer字符输出流
        • FileWriter
      • Reader字符输入流
      • 字节流与字符流的区别
      • 转换流
        • InputStreamReader
        • OutputStreamWriter
      • 文件复制
    • 字符编码
    • 内存操作流(使用较少)
      • ByteArrayInputStream
      • ByteArrayOutputStream
      • 示例
    • 管道流
    • RandomAccessFile随机读取
    • 输入与输出支持
      • 打印流(重要)
        • PrintStream
        • PrintWriter(更推荐)
      • System类对IO的支持
      • BufferedReader缓冲输入流
      • Scanner扫描流
      • BufferedReader与Scanner比较
    • 对象序列化
      • 序列化和反序列化的概念
      • JDK类库中的序列化API
        • Serializable序列化标记
        • ObjectOutputStream对象输出流
        • ObjectInputStream对象输入流
        • transient关键字-手动指定序列化过程

文件操作

// Serializable:可序列化
// Comparable:可以进行排序
public class File extends Object implements Serializable, Comparable<File> {// 通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。public File​(String pathname) {}// 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。public File​(String parent, String child) {}// 系统分隔符 "d:" + File.separator +".aaa.txt"; public static final String separator = "" + separatorChar;
}

//1.创建文件夹   
//import java.io.*;   
File myFolderPath = new File(str1);   
try {   if (!myFolderPath.exists()) {   myFolderPath.mkdir();   }   
}   
catch (Exception e) {   System.out.println("新建目录操作出错");   e.printStackTrace();   
}    //2.创建文件   
//import java.io.*;   
File myFilePath = new File(str1);   
try {   if (!myFilePath.exists()) {   myFilePath.createNewFile();   }   FileWriter resultFile = new FileWriter(myFilePath);   PrintWriter myFile = new PrintWriter(resultFile);   myFile.println(str2);   resultFile.close();   
}   
catch (Exception e) {   System.out.println("新建文件操作出错");   e.printStackTrace();   
}    //3.删除文件   
//import java.io.*;   
File myDelFile = new File(str1);   
try {   myDelFile.delete();   
}   
catch (Exception e) {   System.out.println("删除文件操作出错");   e.printStackTrace();   
}    //4.删除文件夹   
//import java.io.*;   
File delFolderPath = new File(str1);   
try {   delFolderPath.delete(); //删除空文件夹   
}   
catch (Exception e) {   System.out.println("删除文件夹操作出错");   e.printStackTrace();   
}    //5.删除一个文件下夹所有的文件夹   
//import java.io.*;   
File delfile=new File(str1);   
File[] files=delfile.listFiles();   
for(int i=0;i<files.length;i++){   if(files[i].isDirectory()){   files[i].delete();   }   
}     //6.清空文件夹   
//import java.io.*;   
File delfilefolder=new File(str1);   
try {   if (!delfilefolder.exists()) {   delfilefolder.delete();   }   delfilefolder.mkdir();   
}   
catch (Exception e) {   System.out.println("清空目录操作出错");   e.printStackTrace();   
}    //7.读取文件   
//import java.io.*;   
// 逐行读取数据   
FileReader fr = new FileReader(str1);   
BufferedReader br = new BufferedReader(fr);   
String str2 = br.readLine();   
while (str2 != null) {   str3   str2 = br.readLine();   
}   
br.close();   
fr.close();    //8.写入文件   
//import java.io.*;   
// 将数据写入文件   
try {   FileWriter fw = new FileWriter(str1);   fw.write(str2);   fw.flush();   fw.close();    
} catch (IOException e) {   e.printStackTrace();   
}   //9.写入随机文件   
//import java.io.*;   
try {   RandomAcessFile logFile=new RandomAcessFile(str1,"rw");   long lg=logFile.length();   logFile.seek(str2);   logFile.writeByte(str3);   
}catch(IOException ioe){   System.out.println("无法写入文件："+ioe.getMessage());   
}    //10.读取文件属性   
//import java.io.*;   
// 文件属性的取得   
File f = new File(str1);   
if (af.exists()) {   System.out.println(f.getName() + "的属性如下： 文件长度为：" + f.length());   System.out.println(f.isFile() ? "是文件" : "不是文件");   System.out.println(f.isDirectory() ? "是目录" : "不是目录");   System.out.println(f.canRead() ? "可读取" : "不");   System.out.println(f.canWrite() ? "是隐藏文件" : "");   System.out.println("文件夹的最后修改日期为：" + new Date(f.lastModified()));   } else {   System.out.println(f.getName() + "的属性如下：");   System.out.println(f.isFile() ? "是文件" : "不是文件");   System.out.println(f.isDirectory() ? "是目录" : "不是目录");   System.out.println(f.canRead() ? "可读取" : "不");   System.out.println(f.canWrite() ? "是隐藏文件" : "");   System.out.println("文件的最后修改日期为：" + new Date(f.lastModified()));   
}   
if(f.canRead()){   str2   
}   
if(f.canWrite()){   str3   
}   //11.写入属性   
//import java.io.*;   
File filereadonly=new File(str1);   
try {   boolean b=filereadonly.setReadOnly();   
}   
catch (Exception e) {   System.out.println("拒绝写访问："+e.printStackTrace());   
}    //12.枚举一个文件夹中的所有文件   
//import java.io.*;   
//import java.util.*;   
LinkedList<String> folderList = new LinkedList<String>();   
folderList.add(str1);   
while (folderList.size() > 0) {   File file = new File(folderList.peek());   folderList.removeLast();   File[] files = file.listFiles();   ArrayList<File> fileList = new ArrayList<File>();   for (int i = 0; i < files.length; i++) {   if (files[i].isDirectory()) {   folderList.add(files[i].getPath());   } else {   fileList.add(files[i]);   }   }   for (File f : fileList) {   str2=f.getAbsoluteFile();   str3   }   
}   //13.复制文件夹    
//import java.io.*;   
//import java.util.*;   
LinkedList<String> folderList = new LinkedList<String>();   
folderList.add(str1);   
LinkedList<String> folderList2 = new LinkedList<String>();   
folderList2.add(str2+ str1.substring(str1.lastIndexOf("\\")));   
while (folderList.size() > 0) {   (new File(folderList2.peek())).mkdirs(); // 如果文件夹不存在 则建立新文件夹   File folders = new File(folderList.peek());   String[] file = folders.list();   File temp = null;   try {   for (int i = 0; i < file.length; i++) {   if (folderList.peek().endsWith(File.separator)) {   temp = new File(folderList.peek() + File.separator   + file[i]);   } else {   temp = new File(folderList.peek() + File.separator + file[i]);   }   if (temp.isFile()) {   FileInputStream input = new FileInputStream(temp);   FileOutputStream output = new FileOutputStream(   folderList2.peek() + File.separator + (temp.getName()).toString());   byte[] b = new byte[5120];   int len;   while ((len = input.read(b)) != -1) {   output.write(b, 0, len);   }   output.flush();   output.close();   input.close();   }   if (temp.isDirectory()) {// 如果是子文件夹   for (File f : temp.listFiles()) {   if (f.isDirectory()) {   folderList.add(f.getPath());   folderList2.add(folderList2.peek()   + File.separator + f.getName());   }   }   }   }   } catch (Exception e) {   //System.out.println("复制整个文件夹内容操作出错");   e.printStackTrace();   }   folderList.removeFirst();   folderList2.removeFirst();   
}   //14.复制一个文件夹下所有的文件夹到另一个文件夹下   
//import java.io.*;   
//import java.util.*;   
File copyfolders=new File(str1);   
File[] copyfoldersList=copyfolders.listFiles();   
for(int k=0;k<copyfoldersList.length;k++){   if(copyfoldersList[k].isDirectory()){   ArrayList<String>folderList=new ArrayList<String>();   folderList.add(copyfoldersList[k].getPath());   ArrayList<String>folderList2=new ArrayList<String>();   folderList2.add(str2+"/"+copyfoldersList[k].getName());   for(int j=0;j<folderList.length;j++){   (new File(folderList2.get(j))).mkdirs(); //如果文件夹不存在 则建立新文件夹   File folders=new File(folderList.get(j));   String[] file=folders.list();   File temp=null;   try {   for (int i = 0; i < file.length; i++) {   if(folderList.get(j).endsWith(File.separator)){   temp=new File(folderList.get(j)+"/"+file[i]);   } else {   temp=new File(folderList.get(j)+"/"+File.separator+file[i]);   }   FileInputStream input = new FileInputStream(temp);   if(temp.isFile()){   FileInputStream input = new FileInputStream(temp);   FileOutputStream output = new FileOutputStream(folderList2.get(j) + "/" + (temp.getName()).toString());   byte[] b = new byte[5120];   int len;   while ( (len = input.read(b)) != -1) {   output.write(b, 0, len);   }   output.flush();   output.close();   input.close();   }   if(temp.isDirectory()){//如果是子文件夹   folderList.add(folderList.get(j)+"/"+file[i]);   folderList2.add(folderList2.get(j)+"/"+file[i]);   }   }   }   catch (Exception e) {   System.out.println("复制整个文件夹内容操作出错");   e.printStackTrace();   }   }   }   
}   //15.移动文件夹   
//import java.io.*;   
//import java.util.*;   
LinkedList<String> folderList = new LinkedList<String>();   
folderList.add(str1);   
LinkedList<String> folderList2 = new LinkedList<String>();   
folderList2.add(str2 + str1.substring(str1.lastIndexOf("\\")));   
while (folderList.size() > 0) {   (new File(folderList2.peek())).mkdirs(); // 如果文件夹不存在 则建立新文件夹   File folders = new File(folderList.peek());   String[] file = folders.list();   File temp = null;   try {   for (int i = 0; i < file.length; i++) {   if (folderList.peek().endsWith(File.separator)) {   temp = new File(folderList.peek() + File.separator + file[i]);   } else {   temp = new File(folderList.peek() + File.separator + file[i]);   }   if (temp.isFile()) {   FileInputStream input = new FileInputStream(temp);   FileOutputStream output = new FileOutputStream(   folderList2.peek() + File.separator + (temp.getName()).toString());   byte[] b = new byte[5120];   int len;   while ((len = input.read(b)) != -1) {   output.write(b, 0, len);   }   output.flush();   output.close();   input.close();   if (!temp.delete())   System.out.println("删除单个文件操作出错!");   }   if (temp.isDirectory()) {// 如果是子文件夹   for (File f : temp.listFiles()) {   if (f.isDirectory()) {   folderList.add(f.getPath());   folderList2.add(folderList2.peek() + File.separator + f.getName());   }   }   }   }   } catch (Exception e) {   // System.out.println("复制整个文件夹内容操作出错");   e.printStackTrace();   }   folderList.removeFirst();   folderList2.removeFirst();   
}   
File f = new File(str1);   
if (!f.delete()) {   for (File file : f.listFiles()) {   if (file.list().length == 0) {   System.out.println(file.getPath());   file.delete();   }   }   
}   
//16.移动一个文件夹下所有的文件夹到另一个目录下   
//import java.io.*;   
//import java.util.*;   
File movefolders=new File(str1);   
File[] movefoldersList=movefolders.listFiles();   
for(int k=0;k<movefoldersList.length;k++){   if(movefoldersList[k].isDirectory()){   ArrayList<String>folderList=new ArrayList<String>();   folderList.add(movefoldersList[k].getPath());   ArrayList<String>folderList2=new ArrayList<String>();   folderList2.add(str2+"/"+movefoldersList[k].getName());   for(int j=0;j<folderList.length;j++){   (new File(folderList2.get(j))).mkdirs(); //如果文件夹不存在 则建立新文件夹   File folders=new File(folderList.get(j));   String[] file=folders.list();   File temp=null;   try {   for (int i = 0; i < file.length; i++) {   if(folderList.get(j).endsWith(File.separator)){   temp=new File(folderList.get(j)+"/"+file[i]);   }   else{   temp=new File(folderList.get(j)+"/"+File.separator+file[i]);   }   FileInputStream input = new FileInputStream(temp);   if(temp.isFile()){   FileInputStream input = new FileInputStream(temp);   FileOutputStream output = new FileOutputStream(folderList2.get(j) + "/" + (temp.getName()).toString());   byte[] b = new byte[5120];   int len;   while ( (len = input.read(b)) != -1) {   output.write(b, 0, len);   }   output.flush();   output.close();   input.close();   temp.delete();   }   if(temp.isDirectory()){//如果是子文件夹   folderList.add(folderList.get(j)+"/"+file[i]);   folderList2.add(folderList2.get(j)+"/"+file[i]);   }   }   }   catch (Exception e) {   System.out.println("复制整个文件夹内容操作出错");   e.printStackTrace();   }   }   movefoldersList[k].delete();   }   
}   //17.以一个文件夹的框架在另一个目录创建文件夹和空文件   
//import java.io.*;   
//import java.util.*;   
boolean b=false;//不创建空文件   
ArrayList<String>folderList=new ArrayList<String>();   
folderList.add(str1);   
ArrayList<String>folderList2=new ArrayList<String>();   
folderList2.add(str2);   
for(int j=0;j<folderList.length;j++){   (new File(folderList2.get(j))).mkdirs(); //如果文件夹不存在 则建立新文件夹   File folders=new File(folderList.get(j));   String[] file=folders.list();   File temp=null;   try {   for (int i = 0; i < file.length; i++) {   if(folderList.get(j).endsWith(File.separator)){   temp=new File(folderList.get(j)+"/"+file[i]);   }   else{   temp=new File(folderList.get(j)+"/"+File.separator+file[i]);   }   FileInputStream input = new FileInputStream(temp);   if(temp.isFile()){   if (b) temp.createNewFile();   }   if(temp.isDirectory()){//如果是子文件夹   folderList.add(folderList.get(j)+"/"+file[i]);   folderList2.add(folderList2.get(j)+"/"+file[i]);   }   }   }   catch (Exception e) {   System.out.println("复制整个文件夹内容操作出错");   e.printStackTrace();   }   
}   //18.复制文件   
//import java.io.*;   int bytesum = 0;   int byteread = 0;   File oldfile = new File(str1);   try {   if (oldfile.exists()) { //文件存在时   FileInputStream inStream = new FileInputStream(oldfile); //读入原文件   FileOutputStream fs = new FileOutputStream(new File(str2,oldfile.getName()));   byte[] buffer = new byte[5120];   int length;   while ( (byteread = inStream.read(buffer)) != -1) {   bytesum += byteread; //字节数 文件大小   System.out.println(bytesum);   fs.write(buffer, 0, byteread);   }   inStream.close();   }   }   catch (Exception e) {   System.out.println("复制单个文件操作出错");   e.printStackTrace();   }    //19.复制一个文件夹下所有的文件到另一个目录   
//import java.io.*;   
File copyfiles=new File(str1);   
File[] files=copyfiles.listFiles();   
for(int i=0;i<files.length;i++){   if(!files[i].isDirectory()){   int bytesum = 0;   int byteread = 0;   try {   InputStream inStream = new FileInputStream(files[i]); //读入原文件   FileOutputStream fs = new FileOutputStream(new File(str2,files[i].getName());   byte[] buffer = new byte[5120];   int length;   while ( (byteread = inStream.read(buffer)) != -1) {   bytesum += byteread; //字节数 文件大小   System.out.println(bytesum);   fs.write(buffer, 0, byteread);   }   inStream.close();   } catch (Exception e) {   System.out.println("复制单个文件操作出错");   e.printStackTrace();   }   }   
}    //提取扩展名   
String str2=str1.substring(str1.lastIndexOf(".")+1);// 重命名
public boolean renameTo​(File dest);

字节流与字符流

一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。
下图是一个描述输入流和输出流的类层次图。
在这里插入图片描述
在这里插入图片描述
字节流：InputStream OutputStream
字符流：Writer Reader

OutputStream字节输出流

结构：

// Closeable: 可自动关闭
// Flushable: 刷新
public abstract class OutputStream extends Object implements Closeable, Flushable {// 关闭此文件输出流并释放与此流有关的所有系统资源。抛出IOException异常。public void close() throws IOException// 刷新此输出流并强制写出任何缓冲的输出字节public void flush() throws IOException// 输出单个字节数据public abstract void write​(int b) throws IOException// 输出一组字节数据public void write​(byte[] b) throws IOException// 输出部分字节数据public void write​(byte[] b, int off, int len) throws IOException
}
FileOutputStream
public FileOutputStream​(File file) throws FileNotFoundException
// append：追加方式
public FileOutputStream​(File file, boolean append) throws FileNotFoundException
public FileOutputStream​(String name) throws FileNotFoundException
public FileOutputStream​(String name, boolean append) throws FileNotFoundException

package javase.util;import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;public class JavaAPIDemo {public static void main(String[] args) {File file = new File("d:" + File.separator + "a.txt");// 使用了AutoCloseable，自动关闭释放try (OutputStream outputStream = new FileOutputStream(file)) {outputStream.write("写入文件成功".getBytes());}catch (IOException e) {e.printStackTrace();}}
}

InputStream字节输入流

结构：

// Closeable: 可自动关闭
public abstract class InputStream extends Object implements Closeable {// 读取单个字节数据public abstract int read() throws IOException// 读取一组字节数据public int read​(byte[] b) throws IOException// 读取一组字节部分数据public int read​(byte[] b, int off, int len) throws IOException// 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。public void close() throws IOException
}
FileInputStream
public FileInputStream​(File file) throws FileNotFoundException
public FileInputStream​(String name) throws FileNotFoundException
package javase.util;import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;public class JavaAPIDemo {public static void main(String[] args) {File file = new File("d:" + File.separator + "a.txt");// 使用了AutoCloseable，自动关闭释放try (InputStream inputStream = new FileInputStream(file)) {// 输入流中的总字节数int available = inputStream.available();byte[] bt = new byte[1024];// 读取一组字节数据，返回读取到的字节数int read = inputStream.read(bt);// 将读取到的字节转换为字符串System.out.println(new String(bt, 0, read));}catch (IOException e) {e.printStackTrace();}}
}

Writer字符输出流

结构：

// Appendable: 可追加
// Closeable: 可自动关闭
// Flushable: 刷新
public abstract class Writer extends Object implements Appendable, Closeable, Flushable {public Writer append​(char c) throws IOExceptionpublic Writer append​(CharSequence csq) throws IOExceptionpublic Writer append​(CharSequence csq, int start, int end) throws IOExceptionpublic void write​(char[] cbuf) throws IOExceptionpublic void write​(String str) throws IOExceptionpublic void write​(String str, int off, int len) throws IOException
}
FileWriter
package javase.util;import java.io.*;public class JavaAPIDemo {public static void main(String[] args) throws IOException {File file = new File("d:" + File.separator + "a.txt");if (! file.exists()) {file.createNewFile();}// 自动关闭try (Writer writer = new FileWriter(file)) {// 可以利用字符串完成writer.write("数据写入成功");}catch (IOException e) {e.printStackTrace();}}
}

Reader字符输入流

// Readable:
// Closeable: 可自动关闭
public abstract class Reader extends Object implements Readable, Closeable {、// 判断此流是否可以读取public boolean ready() throws IOException// 读取public int read() throws IOException// 读取一组字符流public int read​(char[] cbuf) throws IOExceptionpublic abstract int read​(char[] cbuf, int off, int len) throws IOExceptionpublic int read​(CharBuffer target) throws IOException// 重置流public void reset() throws IOException// 跳过指定字符public long skip​(long n) throws IOException
}

package javase.util;import java.io.*;public class JavaAPIDemo {public static void main(String[] args) throws IOException {File file = new File("d:" + File.separator + "a.txt");// 自动关闭try (Reader reader = new FileReader(file)) {char[] cbuf = new char[1024];int read = reader.read(cbuf);System.out.println(new String(cbuf, 0, read));}catch (IOException e) {e.printStackTrace();}}
}

字节流与字符流的区别

参考博文：字节流与字符流的区别

转换流

可以实现字节流和字符流操作的功能转换。

  • InputStreamReader 类包含了一个底层输入流，可以从中读取原始字节。它根据指定的编码方式，将这些字节转换为Unicode字符。
  • OutputStreamWriter 从运行的程序中接收Unicode字符，然后使用指定的编码方式将这些字符转换为字节，再将这些字节写入底层输出流中。
InputStreamReader
public class InputStreamReader extends Reader {// 构造函数public InputStreamReader​(InputStream in) throws UnsupportedEncodingException// 构造函数，指定字符集public InputStreamReader​(InputStream in, String charsetName) throws UnsupportedEncodingException
}
OutputStreamWriter
public class OutputStreamWriter extends Writer {// 构造函数public OutputStreamWriter​(OutputStream out)public OutputStreamWriter​(OutputStream out, String charsetName) throws UnsupportedEncodingException
}

文件复制

package javase.util;import java.io.*;/*** 文件复制*/
public class JavaAPIDemo {public static void main(String[] args) throws IOException {// 需要复制的源文件String srcFile = "d:" + File.separator + "a.txt";// 需复制的目标文件String desFile = "d:" + File.separator + "b.txt";// 实现方式一：
//		byte[] data = new byte[1024];
//		// 自动关闭
//		try (InputStream inputStream = new FileInputStream(srcFile);OutputStream outputStream = new FileOutputStream(desFile)){
//			int len;
//			while ((len = inputStream.read(data)) != -1) {
//				outputStream.write(data, 0, len);
//			}
//		}// 实现方式二：JDK1.9之后// 自动关闭try (InputStream inputStream = new FileInputStream(srcFile);OutputStream outputStream = new FileOutputStream(desFile)){inputStream.transferTo(outputStream);}}
}

字符编码

GBK/GB2312： 国标编码，可以描述中文信息，其中GBK只描述简体中文；而GB2312可以描述简体中文以及繁体中文。
ISO8859-1： 国际通用编码，可以描述所有的字母信息，如果是象形文字则需要进行编码处理。
UNICODE编码： 采用十六进制的方式存储，可以描述所有的文字信息。缺陷：范围太大。
UTF编码： 象形文字部分采用十六进制编码，而普通的字母采用ISO8859-1编码，它的优势在于适合快速传输，节约带宽，也就成为了开发中首选的编码。主要使用UTF-8编码。

内存操作流(使用较少)

  • 字节内存操作流：ByteArrayInputStream、ByteArrayOutputStream
  • 字符内存操作流：CharArrayReader、CharArrayWriter

ByteArrayInputStream

public class ByteArrayInputStream extends InputStream {// 构造函数：将一组字节保存到内存流public ByteArrayInputStream​(byte[] buf)
}

ByteArrayOutputStream

public class ByteArrayOutputStream extends OutputStream {public byte[] toByteArray()public String toString()
}

示例

package javase.util;import java.io.*;public class JavaAPIDemo {public static void main(String[] args) throws IOException {String string = "ABCDEF";InputStream inputStream = new ByteArrayInputStream(string.getBytes());ByteArrayOutputStream outputStream = new ByteArrayOutputStream();// 单个字节读取int read;while ((read = inputStream.read()) != -1) {System.out.println("read = " + Character.toString(read));outputStream.write(Character.valueOf((char)read));}System.out.println("outputStream = " + outputStream);byte[] bytes = outputStream.toByteArray();System.out.println(new String(bytes));inputStream.close();outputStream.close();}
}

管道流

  • 字节管道流：PipedInputStream、PipedOutputStream
  • 字符管道流：PipedReader、PipedWriter

重要的连接：

PipedOutputStream：public void connect​(PipedInputStream snk) throws IOException
PipedWriter：public void connect​(PipedReader snk) throws IOException

RandomAccessFile随机读取

我们平常创建流对象关联文件,开始读文件或者写文件都是从头开始的,不能从中间开始,如果是开多线程下载一个文件我们之前学过的FileWriter或者FileReader等等都无法完成,而当前介绍的RandomAccessFile他就可以解决这个问题,因为它可以指定位置读,指定位置写的一个类,通常开发过程中,多用于多线程下载一个大文件。
RandomAccessFile的一个重要使用场景就是网络请求中的多线程下载及断点续传。
既可以读也可以写
可以指定位置读写

构造方法：其中参数 mode 的值可选 “r”：可读，“w” ：可写，“rw”：可读性；

  • public RandomAccessFile​(File file, String mode) throws FileNotFoundException
  • public RandomAccessFile​(String name, String mode) throws FileNotFoundException

一共有4种模式：

  • “r”: 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。
  • “rw”: 打开以便读取和写入。
  • “rws”: 打开以便读取和写入。相对于 “rw”，“rws” 还要求对“文件的内容”或“元数据”的每个更新都同步写入到基础存储设备。
  • “rwd” : 打开以便读取和写入，相对于 “rw”，“rwd” 还要求对“文件的内容”的每个更新都同步写入到基础存储设备。

输入与输出支持

打印流(重要)

PrintStream
public class PrintStream extends FilterOutputStream implements Appendable, Closeable {public PrintStream​(OutputStream out)public PrintStream​(File file) throws FileNotFoundExceptionpublic PrintStream​(String fileName) throws FileNotFoundException
}
PrintWriter(更推荐)
public class PrintWriter extends Writer {public PrintWriter​(OutputStream out)public PrintWriter​(OutputStream out, boolean autoFlush)public PrintWriter​(File file) throws FileNotFoundExceptionpublic PrintWriter​(String fileName, Charset charset) throws IOExceptionpublic PrintWriter append​(CharSequence csq)// 格式化。与System.out.format()相同public PrintWriter format​(String format, Object... args)public void println​(String x)public void write​(char[] buf)public void write​(String s)
}

System类对IO的支持

public final class System extends Object {// 标准输出public static final PrintStream out;// 错误输出public static final PrintStream err;// 标准输入(键盘)public static final InputStream in	
;
}

BufferedReader缓冲输入流

二者都可以从键盘接收数据，API文档解释，public BufferedReader(Reader in)方法创建使用默认大小的输入缓冲区的缓冲字符输入流。public Scanner(InputStream source) 构造一个新的扫描器，它产生从指定的输入流扫描的值，从流字节转换为字符使用基础平台的默认字符集。

public class BufferedReader extends Reader {// 读取一行public String readLine() throws IOException
}

Scanner扫描流

Scanner是为了替代BufferedReader而产生。该类的API处理更简单。

BufferedReader与Scanner比较

BufferedReader 是支持同步的，而 Scanner 不支持。如果我们处理多线程程序，BufferedReader 应当使用。
BufferedReader 相对于 Scanner 有足够大的缓冲区内存。
Scanner 有很少的缓冲区(1KB 字符缓冲)相对于 BufferedReader(8KB字节缓冲)，但是这是绰绰有余的。
BufferedReader 相对于 Scanner 来说要快一点，因为 Scanner 对输入数据进行类解析，而 BufferedReader 只是简单地读取字符序列。

对象序列化

参考博文：Java基础学习总结——Java对象的序列化和反序列化[https://www.cnblogs.com/xdp-gacl/p/3777987.html]

序列化和反序列化的概念

把对象转换为字节序列的过程称为对象的序列化。
把字节序列恢复为对象的过程称为对象的反序列化。
对象的序列化主要有两种用途：

  • 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
  • 在网络上传送对象的字节序列。

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

JDK类库中的序列化API

1、序列化之后保存的是类的信息
2、被声明为transient的属性不会被序列化，这就是transient关键字的作用
3、被声明为static的属性不会被序列化，这个问题可以这么理解，序列化保存的是对象的状态，但是static修饰的变量是属于类的而不是属于变量的，因此序列化的时候不会序列化它

Serializable序列化标记
ObjectOutputStream对象输出流
ObjectInputStream对象输入流
transient关键字-手动指定序列化过程

Java中transient关键字的作用，简单地说，就是让某些被修饰的成员属性变量不被序列化，这一看好像很好理解，就是不被序列化，那么什么情况下，一个对象的某些字段不需要被序列化呢？如果有如下情况，可以考虑使用关键字transient修饰：
private transient Integer area;

这篇关于Java基础回顾系列-第七天-高级编程之IO的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1148491。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...
Linux 网络编程 --- 应用层

Linux 网络编程 --- 应用层

一、自定义协议和序列化反序列化 代码： 序列化反序列化实现网络版本计算器 二、HTTP协议 1、谈两个简单的预备知识 https://www.baidu.com/ --- 域名 --- 域名解析 --- IP地址 http的端口号为80端口，https的端口号为443 url为统一资源定位符。CSDNhttps://mp.csdn.net/mp_blog/creation/editor
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2