输入和输出处理

已于 2023-07-15 16:33:18 修改
阅读量157 收藏
点赞数
分类专栏： Java高级 文章标签： java 开发语言 eclipse 输入输出处理
于 2023-07-02 13:56:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44114187/article/details/131491482
版权

目录

1.File类

2.流

2.1.InputStream

2.2.OutputStream

2.3.Reader

2.3.1.FileReader

2.3.2.BufferedReader

2.4.Writer

2.4.1.OutputStreamWriter

2.4.2.FileWriter

2.4.3.BufferedWriter

2.5.读写二进制文件

2.5.1.DataInputStream

2.5.2.DataOutputStream

2.6.序列化和反序列化

1.File类

文件：相关记录或存放在一起的数据的集合

Java程序如何访问文件属性？

        Java API：java.io.File类

File类访问文件属性：

File类的常用方法：

方法名称说明

boolean exists( )

判断文件或目录是否存在

boolean isFile( )

判断是否是文件

boolean isDirectory( )

判断是否是目录

String getPath( )

返回此对象表示的文件的相对路径名

String getAbsolutePath( )

返回此对象表示的文件的绝对路径名

String getName( )

返回此对象表示的文件或目录的名称

boolean delete( )

删除此对象指定的文件或目录

boolean createNewFile( )

创建名称的空文件，不创建文件夹

long  length()

返回文件的长度，单位为字节, 如果文件不存在，则返回 0L

import java.io.File;
import java.io.IOException;

public class TestFile {

	public static void main(String[] args) {
		File file = new File("E:\\eclipse_workspaces\\testDemo/test01.txt");
		System.out.println("是否存在："+file.exists());
		System.out.println("是否文件："+file.isFile());
		System.out.println("是否目录："+file.isDirectory());
		System.out.println("相对路径："+file.getPath());
		System.out.println("绝对路径："+file.getAbsolutePath());
		System.out.println("获得名称："+file.getName());
//		System.out.println("删除："+file.delete());
//		try {
//			System.out.println("创建空文件："+file.createNewFile());
//		} catch (IOException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		System.out.println("文件长度："+file.length());
		

	}

}

 测试：

import java.io.File;
import java.io.IOException;

//文件操作：文件创建，获取文件相关信息，删除文件
public class FileDemo {
	// 创建文件
	public void create(File file) {
		if (!file.exists()) {
			// 如果文件不存在，则创建
			try {
				file.createNewFile();
				System.out.println("文件已创建！");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	// 获取文件信息
	public void showFileInfo(File file) {
		if (file.exists()) {
			if (file.isFile()) {
				// 是文件
				System.out.println("文件名称：" + file.getName());
				System.out.println("文件相对路径：" + file.getPath());
				System.out.println("文件绝对路径：" + file.getAbsolutePath());
				System.out.println("文件大小为：" + file.length() + "个字节");
			}
			if (file.isDirectory()) {
				// 是目录
				System.out.println("此文件是目录！");
			}
		} else {
			System.out.println("此文件不存在！");
		}

	}

	// 删除文件
	public void delete(File file) {
		if (file.exists()) {
			file.delete();
			System.out.println("文件已删除！");
		}
	}

	// 测试方法
	public static void main(String[] args) {
		FileDemo fileDemo = new FileDemo();
		File file = new File("E:\\eclipse_workspaces\\testDemo\\test.txt");//绝对路径
		//File file = new File("test.txt");//相对路径
//		fileDemo.create(file);
//		fileDemo.showFileInfo(file);
		fileDemo.delete(file);//删除文件
	}
}

2.流

如何读写文件？

  • 通过流来读写文件
    • 流是一组有序的数据序列
    • 以先进先出的方式发送信息的通道

Java流的分类：

输入输出流是相对于计算机内存来说的

字节流是 8 位通用字节流，字符流是 16 位 Unicode 字符流

2.1.InputStream

InputStream与FileInputStream

  • InputStream类常用方法（抽象类-基类）
    • int read( )
      • 从输入流一个字节一个字节的读，返回的是该字节的整数表示形式，如果读到了输入流的末尾。返回 -1。
    • int read(byte[ ] b)
      • 从输入流读取若干字节，把这些字节保存到数组b中。返回的是读取到的字节数，，如果读到了输入流的末尾，返回-1。
    • int read(byte[ ] b , int off , int len)
      • 从输入流读取若干字节，把这些字节保存到数组b中。off指的是字节数组中开始保存数据的起始下标。len指的是读取的字节数目。返回的是实际读取到的字节数，如果读到了输入流的末尾，返回-1。
    • void close( )
      • 关闭输入流
    • int available( )
      • 可以从输入流中读取的字节数目
  • 子类FileInputStream常用的构造方法
    • FileInputStream（File file）
    • FileInputStream（String name）

使用FileInputStream读文本文件操作步骤：

  1. 引入相关的类

    import java.io.IOException;

    import java.io.FileInputStream;

  2. 构造文件输入流-FileInputStream对象

    FileInputStream fis= new FileInputStream("c:\\test.txt");

  3. 读取文本文件的数据

    fis.available();

    fis.read();    

  4. 关闭文件流对象

     fis.close();

代码演示：

//1.引入资源

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

//通过字节输入流完成对文件的读操作
public class FileInputStreamDemo {

	public static void main(String[] args) {
		FileInputStream fis = null;
		try {

			// 2.创建FileInputStream对象
			fis = new FileInputStream("E:\\eclipse_workspaces\\testDemo\\test.txt");
			System.out.println("可以读取到的字节数：" + fis.available());

			// 3.借助FileInputStream对象的read()方法读取文件
//			int data;	//读取到的每个字节的整数表示形式    比如 和--104
//			while ((data = fis.read()) != -1) {
//				System.out.print((char) data);
//			}
			// 借助借助FileInputStream对象的read(byte[])方法读取文件
			byte[] b = new byte[1024];
			int data;// 读取到的字节数
			while ((data = fis.read(b)) != -1) {
				//字节读取到了字节数组b中，需要循环输出b的内容
				for (int i = 0; i < data; i++) {
					System.out.print((char)b[i]);
				}
			
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 4.关闭输入流

			try {
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

2.2.OutputStream

OutputStream与FileOutputStream

  • OutputStream类常用方法（抽象类-基类）
    • white(int)：
      • 往输入流中写入一个个的字节。
    • write(byte[] buf)
      • 往输入流中写入一个字节数组。
    • write(byte[] b,int off,int len)
      • 往输入流中写入一个字节数组，off代表开始从字节数组的off位置开始往外写，len代表往外写len长度的字节。
    • void close( )
      • 关闭输出流。
    • void flush()
      • 强制把缓冲区的数据写到输出流中
  • 子类FileOutputStream常用的构造方法
    • FileOutputStream（File file）
    • FileOutputStream（String name）
    • FileOutputStream（String name，boolean append）
  1. 前两种构造方法在向文件写数据时将覆盖文件中原有的内容。
  2. 创建FileOutputStream实例时，如果相应的文件并不存在，则会自动创建一个空的文件

使用FileOutputStream读文本文件操作步骤：

  1. 引入相关的类

    import java.io.IOException;

    import java.io.FileOutputStream;

  2. 构造文件输入流-FileInputStream对象

    FileOutputStream fos = new FileOutputStream("text.txt");

  3. 读取文本文件的数据

    String str ="好好学习,天天向上！";

    byte[] words  = str.getBytes();

    fos.write(words, 0, words.length);

  4. 关闭文件流对象

     fos.close();

代码演示：

//1.引入资源

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

//通过字节输出流完成对文件的读操作
public class FileOutputStreamDemo {

	public static void main(String[] args) {
		FileOutputStream fos = null;
		try {
			// 2.创建字节输出流对象（FileOutputStream）
			//fos = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\test.txt");
			//不覆盖原有的内容。进行追加
			fos = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\test.txt",true);
			
			// 3.调用字节输出流对象（FileOutputStream）的write（）方法写入文件
			String infoString = "好好学习，天天向上!";
			// 将写入的字符串打散为一个字节数组
			byte[] infos = infoString.getBytes();
			fos.write(infos, 0, infos.length);
			System.out.println("test文件已被更新！");

		} catch (FileNotFoundException e) {

			e.printStackTrace();
		} catch (IOException e) {

			e.printStackTrace();
		}finally {
			// 4.关闭输出流
			try {
				fos.close();
			} catch (IOException e) {
			
				e.printStackTrace();
			}
		}

	}

}

2.3.Reader

  • 字符输入流Reader类常用方法（基类-抽象类）
    • int read()
    • int read(char[ ] c)
    • int read(char[ ] ,int off ,int len)
    • void close()
  • File类是Reader类的孙子类
    • FileReader (File file)
    • FileReader (String name)

2.3.1.FileReader

使用FileReader读文本文件的操作步骤：

  • 引入资源
  • 创建FileReader对象
  • 调用相应read（）读取文件（文件操作）
  • 关闭字符流

解决中文乱码问题：

  1. 手动调整
  2. 通过流读取时设置编码格式
    1. InputStreamReader(InputStream in) 
    2. InputStreamReader(InputStream in,String charsetName) 
2.3.2.BufferedReader

       如何提高字符流读取文本文件的效率：使用FileReader类与BufferedReader类

         BufferedReader类是Reader类的子类，BufferedReader带有缓冲区，内有按行读取内容的readLine()方法。

BufferedReader：

  •  带有缓冲区的字符输入流
  •  提高了文件的读取效率

-------------------------------------------------------------------------------------------------------------

  • BufferedReader类常用的构造方法
    • BufferedReader（Reader in）
  • 子类BufferedReader特有的方法
    • readLine（）

使用BufferedReader读文本文件的操作步骤：

  1. 引入相关的类

    import java.io.FileReader;

    import java.io.BufferedReader;

    import java.io.IOException;

  2. 构造 BufferedReader 对象和 FileReader 对象

    Reader fr = new  FileReader("C:\\myTest.txt ");

    BufferedReader br=new BufferedReader(fr);

  3. 调用 readLine（）方法读取数据

    ​​​​​​br.readLine();

  4. 关闭文件流对象

    br.close();

    fr.close();

2.4.Writer

  • Writer类常用方法
    • write(String str)
    • write(String str，int off, int len)
    • void close()
    • void flush()
2.4.1.OutputStreamWriter

子类OutputStreamWriter常用的构造方法

  • OutputStreamWriter(OutputStream out)
  • OutputStreamWriter(OutputStream out,String charsetName)  //指定字符输出格式
2.4.2.FileWriter

孙子类FileWriter

  • FileWriter (File file)
  • FileWriter (String name)
  • 该类只能按照本地平台的字符编码来写数据，用户不能指定其他的字符编码类型

使用FileWriter写文件的操作步骤：

  1. 引入相关的类

    import java.io.Reader;

    import java.io.FileWriter;

    Import java.io.IOException;

  2. 创建FileWriter对象

    Writer fw= new FileWriter("D:\\myDoc\\简介.txt");

  3. 写文本文件

    fw.write();

  4. 关闭相关的流对象

    fw.close();

2.4.3.BufferedWriter
  • BufferedWriter类带有缓冲区的字符输出类
  • BufferedWriter（Write out）构建对象并使用

使用BufferedWriter写文件的操作步骤：

  1. 引入相关的类

    import java.io.FileWriter ;

    import java.io.BufferedWriter ;

    import java.io.IOException;

  2. 创建 BufferedWriter 和 FileWriter 对象

    FileWriter fw=new FileWriter("C:\\myTest.txt");

    BufferedWriter bw=new BufferedWriter(fw);

  3. 调用write（）方法写数据

    bw.write("hello");

  4. 流对象的清空和关闭 flush()和close()

    bw.flush(); 

    fw.close();

2.5.读写二进制文件

  • DataInputStream类
    • FileInputStream的子类
    • 与FileInputStream类结合使用读取二进制文件
  • DataOutputStream类
    • FileOutputStream的子类
    • 与FileOutputStream类结合使用写二进制文件
2.5.1.DataInputStream

使用 DataInputStream 读二进制文件步骤：

  1. 引入相关的类

    import java.io.FileInputStream;

    import java.io.DataInputStream;

  2. 构建数据输入流对象

    FileInputStream fis=new FileInputStream("C:\\HelloWorld.class");

    DataInputStream dis=new DataInputStream(fis);

  3. 调用read（）方法读取二进制数据

               dis.read ();

  4. 关闭数据输入流

    dis.close();

2.5.2.DataOutputStream

使用 DataOutputStream写二进制文件步骤：

  1. 引入相关的类

    import java.io.FileOutputStream;

    import java.io.DataOutputStream;

  2. 构建数据输出流对象

    FileOutputStream outFile = new FileOutputStream("C:\\temp.class");

    DataOutputStream out = new DataOutputStream(outFile);

  3. 调用write（）方法读取二进制数据

    out.write();

  4. 关闭数据输入流

    out.close();

------------------------------------------------------------------

练习：复制文件

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

//CopyPicture
//借助DataInputStream和DataOutputStream实现二进制文件读写
public class CopyPicture {
	public static void main(String[] args) {
		//读取图片文件 E:/eclipse_workspaces/img.jpg
		DataInputStream dis = null;
		FileInputStream fis = null;
		
		//将图片文件写	E:\eclipse_workspaces\testDemo\img.jpg
		DataOutputStream dos = null;
		FileOutputStream fos = null;
		try {
			//输入流
			fis = new FileInputStream("E:/eclipse_workspaces/img.jpg");
			dis = new DataInputStream(fis);
			//输出流
			fos = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\img.jpg");
			dos = new DataOutputStream(fos);
			//输入流读取二进制文件的同时，输出流写入二进制文件
			int temp;
			while ((temp = dis.read()) != -1) {
				dos.write(temp);
			}
	
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				dos.close();
				fos.close();
				dis.close();
				fis.close();
			} catch (IOException e) {

				e.printStackTrace();
			}
		
		}

	}
}

2.6.序列化和反序列化

调用Serializable接口

序列化过程：

序列化是将对象的状态写入到特定的流中的过程。

反序列化则是从特定的流中获取数据重新构建对象的过程。

--------------------------------------------------------------------------------

序列化的步骤：

  1. 实现Serializable接口
  2. 创建对象输出流
  3. 调用writeObject（）方法将对象写入文件
  4. 关闭对象输出流

反序列化的步骤：

  1. 实现Serializable接口
  2. 创建对象输入流
  3. 调用readObject（）方法读取对象
  4. 关闭对象输入流

transient ：被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

eg:

注：学生类未展示

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

//序列化和反序列化学员对象
public class SeriaStu {
	public static void main(String[] args) {
		Student student = new Student(18, "张三", "男", "123456");
		// 对象输出流
		ObjectOutputStream oos = null;
		FileOutputStream fos = null;
		//对象输入流
		ObjectInputStream ois = null;
		FileInputStream fis = null;

		try {
			
			//构建对象输出流，为序列化做准备
			fos = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\student.txt");
			oos = new ObjectOutputStream(fos);
			
			//构建对象输入流，为反序列化做准备
			fis = new FileInputStream("E:\\eclipse_workspaces\\testDemo\\student.txt");
			ois = new ObjectInputStream(fis);
			//实现对象序列化
			oos.writeObject(student);
			//实现对象范序列化
			Student student1 = (Student)ois.readObject();
			System.out.println("反序列化出来的学生信息："+student1.getAge()+"-"+student1.getName()+"-"+student1.getSex()+"-"+student1.getPassword());
		} catch (FileNotFoundException e) {

			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		finally {
			try {
				ois.close();
				fis.close();
				oos.close();
				fos.close();
			} catch (IOException e) {
		
				e.printStackTrace();
			}
		
		}

	}

}

eg：

集合实现序列化 

package dh06.demo04;

import java.util.List;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;

//E:\\eclipse_workspaces\\testDemo\\student.txt
//序列化和反序列化学员对象-----集合
public class SeriaStu2 {
	public static void main(String[] args) {

		try {
			List<Student> list = new ArrayList<Student>();
			list.add(new Student(18, "张三", "男", "123456"));
			list.add(new Student(22, "李四", "女", "666666"));
			list.add(new Student(33, "王五", "男", "888888"));
			// 序列化
			OutputStream os = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\student.txt");
			ObjectOutputStream oos = new ObjectOutputStream(os);
			oos.writeObject(list);// 将对象存入
			System.out.println("存入成功！！！");

			// 反序列化
			InputStream is = new FileInputStream("E:\\eclipse_workspaces\\testDemo\\student.txt");
			ObjectInputStream ois = new ObjectInputStream(is);
			List<Student> list2 = (List<Student>) ois.readObject();
			for (Student student : list2) {
				
				student.show();
			}

			oos.close();
			os.close();
			ois.close();
			is.close();

		} catch (Exception e) {

			e.printStackTrace();
		} finally {

		}

	}

}

愚人钊呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ChatGPT技术的输入和输出处理要点.docx
07-23
ChatGPT技术的使用教程、使用方法、使用技巧、使用注意事项、使用中常见问题
Java常见工具类及异常处理
12-31
Java常用工具类及异常,异常的原理 try,catch,finally,throws,throw Arrays类 Random类 System和Runtime类
java文件输入和输出处理(I/O流程)
yxjh21312的博客
11-10 2481
java文件输入和输出处理(I/O流程)
Java输入和输出处理（一）
wisbhxnhsj的博客
12-26 357
4.FileInputStream 字节输入流，用于从文件中读取字节数据。FileOutputStream 字节输出流 用于向文件中写入字节数据。使用 FileInputStream 读文本文件的步骤。使用 FileOutputStream 写文本文件的步骤。JAVA API：java.io.File类。1.文件：相关记录或放在一起的数据的集合。：强制把缓冲区的数据写到输出流中。使用 File类操作文件或目录。：可以从输入流中读取的字节数目。4.File 类的常用方法。二、文件（File）类。
深入剖析Java中的输入输出流：InputStream与OutputStream的精髓解读
程序猿小样的博客
10-19 1431
在计算机编程领域，文件和数据的输入输出是开发中常见的需求。Java作为一门强大的编程语言，提供了丰富的输入输出流（IO）操作功能，使得开发者可以轻松地处理各种数据源，包括文件、网络连接、内存等。本文将深入探讨Java中的输入输出流，着重介绍InputStream和OutputStream的原理、使用方法以及常见应用场景，帮助读者更好地理解和运用Java中的IO操作。希望通过本文的介绍，读者能够更好地掌握Java中InputStream与OutputStream的使用，为今后的开发工作提供有力支持。
MapReduce的输入输出和处理流程
东城庞太师
02-02 5694
MapReduce的输入和输出 MapReduce框架运转在<key,value>键值对上，也就是说，框架把作业的输入看成是一组<key,value>键值对，同样也产生一组<key,value>键值对作为作业的输出，这两组键值对可能是不同的。 一个MapReduce作业的输入和输出类型如下图所示：可以看出在整个标准的流程中，会有三组<key,value...
C++异常处理与输入输出
Afanda
10-21 4474
C++异常处理与输入输出 文章目录C++异常处理与输入输出1. C++异常处理1.1 使用简单的错误分支处理abort()和exit()1.2 使用try-throw-catch处理机制1.3使用exception类，头文件exception2. C++输入与输出2.1使用string类的getline()输入字符串2.2控制台的输入与输出操作对象cin与cout，iostream头文件，类ost...
牛客网在线编程JavaScript输入和输出处理方法
狗哥的博客
05-03 7689
近段时间在牛客网刷题，到目前为止刷了53道编程题（其中包括23道剑指offer编程题，30道各大厂往年的校招真题）。刚开始在牛客网刷各大厂校招真题的时候，最头疼的就是输入数据的读取和结果的输出了吧。网上搜有关牛客网JS编程的输入和输出的处理方法，找到有点帮助也就只有牛客网在线判题系统使用帮助 。今天闲来无事，因此对已经刷过的编程题就如何处理输入输出做一个总结，仅供参考。 举例说明 简单...
深入理解PyTorch中LSTM的输入和输出（从input输入到Linear输出）
热门推荐
KI的博客
01-18 7万+
深入理解PyTorch中LSTM的输入和输出（从input输入到Linear输出）
计算机输入设备和输出设备怎么区分,输入设备和输出设备的区别
weixin_34266692的博客
07-26 7991
输入设备介绍输入设备：向计算机输入数据和信息的设备。是计算机与用户或其他设备通信的桥梁。输入设备是用户和计算机系统之间进行信息交换的主要装置之一。键盘，鼠标，摄像头，扫描仪，光笔，手写输入板，游戏杆，语音输入装置等都属于输入设备。输入设备(InputDevice)是人或外部与计算机进行交互的一种装置，用于把原始数据和处理这些数的程序输入到计算机中。计算机能够接收各种各样的数据，既可以是数值型的数据...
java学习 输入和输出处理复习知识点
06-28
部分内容如下所示： 1）java.io包 File类 什么是文件：相关记录或放在一起的数据的集合 访问文件属性的API：java.io.File类 ...File(String pathname) 接受文件名作为字符串 File(Strint dir,String subpath) ...
输入输出与文件处理
05-11
（1） 理解流式输入输出的基本原理。 （2） 掌握DataInputStream和DataOutputStream类的使用方法。 （3） 掌握File、FileInputStream、FileOutputStream类的使用方法。 （4） 掌握RandomAccessFile类的使用方法。
在Ruby中处理文件的输入和输出的教程
01-20
类 IO 提供了所有基础的方法，比如 read、 write、 gets、 puts、 readline、 getc 和 printf。 本章节将讲解所有 Ruby 中可用的基础的 I/O 函数。如需了解更多的函数，请查看 Ruby 的 IO 类。 puts 语句 在前面的...
java输入输出处理
05-16
java输入输出处理 java输入输出处理 java输入输出处理 java输入输出处理 java输入输出处理 java输入输出处理
【C++篇】C++的输入和输出
陈七的博客，学习知识分享，期待与大家的交流
06-21 2万+
知识总结顺序参考C Primer Plus（第六版）和谭浩强老师的C程序设计（第五版）等，内容以书中为标准，同时参考其它各类书籍以及优质文章，以至减少知识点上的错误，同时方便本人的基础复习，也希望能帮助到大家最好的好人，都是犯过错误的过来人；一个人往往因为有一点小小的缺点，将来会变得更好。如有错漏之处，敬请指正，有更好的方法，也希望不吝提出。最好的生活方式就是和努力的大家，一起奔跑在路上。
文件输入流和输出流详解
qq_40135955的博客
06-24 1万+
按照流向划分为输入流和输出流 输入流：就是以程序为中心点，硬盘上的文件内容流入到程序中可以存储数据的东西中比如说数组，用read方法 输出流：就是以程序为中心点，程序中的数组或者其他的可以存储数据的东西中的内容输出到硬盘文件中，用write方法，需要用flush方法刷新一下，确保程序中的数组内容写出到硬盘文件中 按照传输的数据划分为字节流和字符流 字节流:二进制，可以一切文件 包括 ...
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1600
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 1091
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
设计模式之装饰器模式
最新发布
丿微风乍起的博客
06-05 883
装饰器模式是一种结构型设计模式，它允许我们在不改变原有对象结构的情况下，动态地给对象增加一些职责（即增加其额外功能）。其核心在于通过组合而非继承的方式来扩展对象的功能。Component: 这是抽象组件接口，所有的具体组件和装饰器都必须实现这个接口。Concrete Component: 具体组件，这是我们要装饰的基本对象，它实现了Component接口。Decorator: 抽象装饰器，也是实现Component接口的，它包含一个对Component类型的引用，通常在构造函数中初始化。
linux输入和输出重定向
06-28
总之，输入和输出重定向是Linux系统中非常重要的概念，可以帮助用户更高效地处理输入和输出。熟练地使用输入和输出重定向符号可以极大地提高代码的可读性和效率。 回答3：</h3><br/>Linux输入和输出重定向是一种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

愚人钊呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值