黑马程序员学习日记--IO流技术（二）

最新推荐文章于 2015-06-18 14:38:50 发布
最新推荐文章于 2015-06-18 14:38:50 发布
阅读量344 收藏
点赞数
分类专栏： 黑马学习日记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z137478244/article/details/46372773
版权 
------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一：File对象和常用方法

File类： 

用来将文件或者文件夹封装成对象

方便对文件和文件夹的属性信息进行操作

File对象可以作为参数传递给流的构造函数

File类中的常用方法：

1，创建

boolean createNewFile( )

(在指定的位置创建文件，如果该文件已经存在，则不创建，返回false)

boolean mkdir():创建文件夹

boolean mkdirs()：创建多级文件夹

2，删除

boolean delete()：删除失败返回false

void deleteOnExit():在程序退出时删除指定文件

3，判断

boolean exists():文件是否存在

isDirectory():

isFile()

isHidden()

isAbsolute()

4,获取信息

getName()

getPath()

getParent()

getAbsolute()

long lastModified()

long length()

练习代码：

//File对象功能
import java.io.*;
class J20_1 
{
	public static void main(String[] args) throws IOException
	{
		//consMethod();
		//method_1();
		//method_2();
		//method_3();
		//method_4();
		method_5();
	}
	static void sop(Object obj)
	{
		System.out.println(obj);
	}
	static void consMethod() throws IOException
	{
		File f1 = new File("a.txt");
		File f2 = new File("D:","c.txt");
		File d = new File("D:");
		File f3 = new File(d,"c.txt");
		sop("f1="+f1);
		sop("f2="+f2);
		sop("f3="+f3);
	}
	static void method_1() throws IOException
	{
		File f = new File("a.txt");
		//sop("create:"+f.createNewFile());
		sop("delete:"+f.delete());
	}
	static void method_2() throws IOException
	{
		File dir = new File("aaa\\bbb\\ccc\\ddd");
		//sop("execute:"+f.canExecute());
		//sop("exist:"+f.exists());
		sop("dirmake:"+dir.mkdirs());
	}
	static void method_3() throws IOException
	{
		File f = new File("D:\\file.txt");
		//f.createNewFile();
		//f.mkdir();
		sop("ifFile:"+f.isFile());
		sop("ifDirectory:"+f.isDirectory());
		sop("isAbsolute:"+f.isAbsolute());
	}
	static void method_4() throws IOException
	{
		File f = new File("D:\\file.txt");
		//f.createNewFile();
		sop("path:"+f.getPath());
		sop("absolutePath:"+f.getAbsolutePath());
		sop("parent:"+f.getParent());
	}
	static void method_5() throws IOException
	{
		File f1 = new File("a.txt");
		File f2 = new File("b.txt");
		sop("rename:"+f2.renameTo(f1));

	}
}

二：递归

递归：函数自身调用自身

注意：

1，限定条件

2，递归的次数，要避免内存溢出

练习代码：

/*
练习：
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中
建立一个java文件列表文件

思路：
1：对指定的目录进行递归
2：获取递归过程中java文件的路径
3：将这些路径存储到集合中
4：将集合中的数据写入文件
*/
import java.util.*;
import java.io.*;
class J20_5 
{
	public static void main(String[] args) throws IOException
	{
		File file = new File("E:\\demo");
		List<File> list = new ArrayList<File>();
		fileToList(file,list);
		System.out.println(list.size());
		File f1 = new File("D:\\javalist.txt");
		writeToFile(list,f1);
	}
	static void fileToList(File file,List<File> list)
	{
		File[] files = file.listFiles();
		for(File f:files)
		{
			if(f.isDirectory())
				fileToList(f,list);
			else if(f.getName().endsWith(".java"))
				list.add(f);
		}
	}
	static void writeToFile(List<File> list,File file)
	{
		BufferedWriter bw = null;
		try
		{
			bw = new BufferedWriter(
			new FileWriter(file));
			for(File f:list)
			{
				bw.write(f.getAbsolutePath());
				bw.newLine();
				bw.flush();
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException();
		}
		finally
		{
			if(bw!=null)
				try
				{
					bw.close();
				}
				catch (IOException e)
			{
				throw new RuntimeException();
			}
		}
		
	}
}

三：Properties

Properties是hashtable 的子类

是集合中和IO技术相结合的集合容器

特点：可用于键值对形式的配置文件中

练习代码：

/*
练习：
记录应用程序运行次数
如果使用次数已到，那么给出注册提示
*/
import java.io.*;
import java.util.*;
class J20_7 
{
	public static void main(String[] args) throws IOException
	{
		Properties prop = new Properties();
		File file = new File("count.ini");
		file.createNewFile();
		FileInputStream fis = new FileInputStream(file);
		int count = 0;
		prop.load(fis);
		String time = prop.getProperty("time");
		if(!(time==null))
		{
			count = Integer.parseInt(time);
			if(count>=5)
			{
				System.out.println("使用次数已到，请去官网注册");
				return;
			}
		}
		count++;
		prop.setProperty("time",count+"");
		FileOutputStream fos = new FileOutputStream("count.ini");
		prop.store(fos,"");
		fis.close();
		fos.close();
	}
}

四：打印流 ，序列流，操作对象

打印流：

PrintWriter与PrintStream

可以直接操作输出流和文件，该流提供了打印方法，可以将各种数据类型的数据都原样打印

PrintStream构造函数可接受的参数类型：

1，file对象 File

2，字符串路径 String

3，字符输出流 OutputStream

PrintWriter构造函数可以接受的参数类型：

1，file对象 File

2，字符串路径 String

3，字符输出流 OutputStream

4，字符输出流 Writer

练习代码：

import java.io.*;
class J20_8 
{
	public static void main(String[] args) throws IOException 
	{
		BufferedReader br = new BufferedReader(
			new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);
		String line = null;
		while((line=br.readLine())!=null)
		{
			if(line.equals("over"))
				break;
			out.println(line.toUpperCase());
			//out.flush();
		}
		br.close();
		out.close();
	}
}


序列流：

SequenceInputStream  对多个流进行合并

练习代码：

import java.util.*;
import java.io.*;
class J20_9 
{
	public static void main(String[] args)  throws IOException
	{
		Vector<FileInputStream> v = new Vector<FileInputStream>();
		v.add(new FileInputStream("1.txt"));
		v.add(new FileInputStream("2.txt"));
		v.add(new FileInputStream("3.txt"));
		Enumeration<FileInputStream> e = v.elements();
		SequenceInputStream sis = new SequenceInputStream(e);
		FileOutputStream fos = new FileOutputStream("4.txt");
		byte[] buf = new byte[1024];
		int len = 0;
		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}
		sis.close();
		fos.close();
	}
}


操作对象：

ObjectinputStream和ObjectOutputStream

被操作的对象需要实现Serializable（标记接口）

练习代码：

import java.io.*;
class J21_1 
{
	public static void main(String[] args) throws Exception
	{
		writeDemo();
		readDemo();
	}
	static void readDemo() throws Exception
	{
		ObjectInputStream ois = new ObjectInputStream(
			new FileInputStream("out.txt"));
		Person p = (Person)ois.readObject();
		System.out.println(p);
	}
	static void writeDemo() throws IOException
	{
		ObjectOutputStream oos = new ObjectOutputStream(
			new FileOutputStream("out.txt"));
		Person p = new Person("hoop",25,"kr");
		oos.writeObject(p);
		oos.close();
	}
}
class Person implements Serializable
{
	public static final long serialVersionUID = 42L;
	private String name;
	transient int age;
	static String country = "CN";
	Person(String name,int age,String country)
	{
		this.name = name;
		this.age = age;
		this.country = country;
	}
	public String toString()
	{
		return name+"..."+age+"..."+country;
	}
}


五：管道流

PipedInputStream和PipedOutputStream

输入输出可以直接进行连接，通过结合线程使用

练习代码：

import java.io.*;
class J21_2 
{
	public static void main(String[] args) throws IOException
	{
		PipedInputStream pis = new PipedInputStream();
		PipedOutputStream pos = new PipedOutputStream();
		pis.connect(pos);
		Read r = new Read(pis);
		Write w = new Write(pos);
		new Thread(r).start();
		new Thread(w).start();
	}
}
class Read implements Runnable
{
	private PipedInputStream pis;
	Read(PipedInputStream pis)
	{
		this.pis = pis;
	}
	public void run()
	{
		try
		{
			byte[] buf = new byte[1024];
			int len = 0;
			System.out.println("读取数据，没有数据则阻塞");
			len = pis.read(buf);
			System.out.println("读取完毕");
			System.out.println(new String(buf,0,len));
			pis.close();
		}
		catch (IOException e)
		{
			throw new RuntimeException("管道读取流失败");
		}
		
	}
}
class Write implements Runnable
{
	private PipedOutputStream pos;
	Write(PipedOutputStream pos)
	{
		this.pos = pos;
	}
	public void run()
	{
		try
		{
			System.out.println("等待6秒后写入数据");
			Thread.sleep(6000);
			pos.write("piped come".getBytes());
			pos.close();
		}
		catch (Exception e)
		{
			throw new RuntimeException("管道输出流失败");
		}
		
	}
}


六：RandomAccessFile

IO包中成员，具备读和写功能

内部封装了一个数组，通过指针对数组的元素进行操作

可以通过getFilePointer获取指针位置

同时可以通过seek改变指针的位置

（该类只能操作文件，而且操作文件还有模式）

练习代码：

import java.io.*;
class J21_3 
{
	public static void main(String[] args) throws IOException 
	{
		//writeDemo();
		writeDemo_2();
		//readDemo();
	}
	static void readDemo() throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("raf.txt","r");
		byte[] buf = new byte[4];
		//raf.seek(8);
		raf.skipBytes(8);
		raf.read(buf);
		String s = new String(buf);
		System.out.println("name:"+s);
		int age = raf.readInt();
		System.out.println("age:"+age);
		raf.close();
	}
	static void writeDemo_2() throws IOException
	{
		File f = new File("raf.txt");
		RandomAccessFile raf = new RandomAccessFile(f,"rw");
		raf.seek(8*0);
		raf.write("周期".getBytes());
		raf.writeInt(101);
		raf.close();
	}
	static void writeDemo() throws IOException
	{
		File f = new File("raf.txt");
		RandomAccessFile raf = new RandomAccessFile(f,"rw");
		raf.write("张三".getBytes());
		raf.writeInt(97);
		raf.write("李四".getBytes());
		raf.writeInt(99);
		raf.close();
	}
}


七：操作基本数据类型，操作字节数组，操作字符数组，操作字符串

操作基本数据类型：

DataInputStream和DataOutputStream

练习代码：

import java.io.*;
class J21_4 
{
	public static void main(String[] args) throws IOException 
	{
		//readDemo();
		//writeDemo();
		//writeUTFDemo();
		readUTFDemo();
	}
	static void readUTFDemo() throws IOException
	{
		DataInputStream dis = new DataInputStream(
			new FileInputStream("UTFData.txt"));
		String s = dis.readUTF();
		System.out.println(s);
		dis.close();
	}
	static void writeUTFDemo() throws IOException
	{
		DataOutputStream dos = new DataOutputStream(
			new FileOutputStream("UTFData.txt"));
		dos.writeUTF("你好中国");
		dos.close();
	}
	static void readDemo() throws IOException
	{
		DataInputStream dis = new DataInputStream(
			new FileInputStream("data.txt"));
		int num = dis.readInt();
		Double d = dis.readDouble();
		boolean b = dis.readBoolean();
		System.out.println("num="+num);
		System.out.println("d="+d);
		System.out.println("b="+b);
		dis.close();
	}
	static void writeDemo() throws IOException
	{
		DataOutputStream dos = new DataOutputStream(
			new FileOutputStream("data.txt"));
		dos.writeInt(98);
		dos.writeDouble(983.762);
		dos.writeBoolean(true);
		dos.close();
	}
}


操作字节数组

ByteArrayInputStream：在构造时，需要接收数据源（字节数组）

ByteArrayOutputStream：在构造时，不用定义数据目的，内部封住了可变长度的字节数组

（两个流对象都操作的数组，没有使用系统资源）

练习代码：

import java.io.*;
class J21_5 
{
	public static void main(String[] args) 
	{
		ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFG".getBytes());
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		
		int by=0;
		while((by=bis.read())!=-1)
		{
			bos.write(by);
		}
		System.out.println(bos.size());
		System.out.println(bos.toString());
	}
}


操作字符数组

CharArrayReader和CharArrayWriter

操作字符串

StringReader和StringWriter


八：字符编码

字符流的出现为了方便操作字符，更重要的是加入了编码转换

通过子类转换流来完成:

InputStreamReader

OutputStreamWriter

(这两个对象构造的时候可以传入字符集)


常见的编码表：

ASCII：美国标准信息交换码

用一个字节的7位可以表示

ISO8859-1：拉丁吗表。欧洲码表

用一个字节的8位表示

GBK2312：中国的中文编码表

GBK：中国的中文编码表升级，融合了更多的中文文字符号

Unicode：国际标准吗，融合了多种文字

所有文字都用两个字节来表示，Java语言使用的是Unicode

UTF-8：做多用三个字节来表示一个字符


编码：字符串编程字节数组 str.getBytes( )

解码：字节数组编程字符串 new String(bytes[ ] )

练习代码：

/*
有五个学生，每个学生有三门课的成绩
从键盘输入以上数据（包括姓名，三门课程及）
输入的格式：如：zhangsan，30，40，60计算出总成绩
并把学生的信息和计算出的总分高低顺序存放在磁盘文件“stud。txt”中
*/
import java.io.*;
import java.util.*;
class J21_9 
{
	public static void main(String[] args) throws IOException
	{
		Comparator<Student> comp = Collections.reverseOrder();
		Set<Student> stus = Tool.getStu(comp);
		Tool.write2File(stus);
	}
}
class Student implements Comparable<Student>
{
	private String name;
	private int math,cn,en,sum;
	int getSum()
	{
		return sum;
	}
	String getName()
	{
		return name;
	}
	Student(String name,int math,int cn,int en)
	{
		this.name = name;
		this.math = math;
		this.cn = cn;
		this.en = en;
		sum = math+cn+en;
	}
	public int hashCode()
	{
		return name.hashCode()+sum*29;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new ClassCastException();
		Student s = (Student)obj;
		return name.equals(s.name)&&sum==s.sum;
	}
	public String toString()
	{
		return "["+name+"]:"+math+","+cn+","+en;
	}
	public int compareTo(Student s)
	{
		int num = new Integer(this.sum).compareTo(new Integer(s.sum));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
}
class Tool
{
	public static Set<Student> getStu() throws IOException
	{
		return getStu(null);
	}
	public static Set<Student> getStu(Comparator<Student> comp) throws IOException
	{
		BufferedReader bis = new BufferedReader(
			new InputStreamReader(System.in));
		String line = null;
		Set<Student> stus = null;
		if(comp==null)
			stus = new TreeSet<Student>();
		else
			stus = new TreeSet<Student>(comp);
		while((line=bis.readLine())!=null)
		{
			if(line.equals("over"))
				break;
			String[] arr = line.split(",");
			Student s = new Student(arr[0],
				Integer.parseInt(arr[1]),
				Integer.parseInt(arr[2]),
				Integer.parseInt(arr[3]));
			stus.add(s);
		}
		return stus;
	}
	public static void write2File(Set<Student> stus) throws IOException
	{
		BufferedWriter bw = new BufferedWriter(
			new FileWriter("stud.txt"));
		for(Student s : stus)
		{
			int sum = s.getSum();
			String line = s.toString();
			bw.write(line+"..sum="+sum);
			bw.newLine();
			bw.flush();
		}
		bw.close();
	}
}



z137478244
关注
专栏目录
Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
本资料包“Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar”提供了一个深入学习Java IO流的全面资源，包含实例题目、源代码以及PPT教学材料，适合对Java IO有进阶需求的开发者。 1. **Java ...
黑马程序员_毕向东_Java基础视频教程第18天-14-IO流(拷贝文本文件图例).zip
04-07
黑马程序员_毕向东_Java基础视频教程第18天-14-IO流(拷贝文本文件图例).zip
黑马程序员-----IO流的基本概念以及使用
chihuo0431的博客
05-09 254
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 1.初识IO流         IO是Input%Output的缩写，即输入和输出。简单理解，就是通过IO流可以实现对硬盘数据或者键盘录入数据（内存数据）进行操作。          那么，IO流的体系？         从流向分，IO里有写入流（Writer和Out
黑马程序员学习日记--反射
z137478244的博客
06-18 349
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一：反射的基础 Class类： Java程序中每个java类都属于同一类事物，描述这类事物的Java类名及时Class。 得到各个字节码对应的实例对象（Class类型）： 类名.class 对象.getClass() Class.forName("类名") 九个预定义的C
黑马程序员学习日记--网络编程
z137478244的博客
06-16 323
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一：网络编程概述 网络模型： OSI参考模型 TCP/IP参考模型 网络通讯要素： IP地址： 网络中设备的标识 不易记忆，可用主机名 本地回环地址：127.0.0.1 主机名：localhost 端口号： 用于标识进程的逻辑地址 有效端口：0-65535，其中1-102
黑马程序员--Java中IO流小结
macover的专栏
04-08 458
------- android培训、java培训、期待与您交流！ ---------- 流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。   IO流的分类 根据处理数据类型的不同分为：字符流和字节流 根据数据流向不同分为：输入流和输出
黑马程序员--【学习日记八】——IO流
u013587258的专栏
09-12 408
知识列表 IO概述字符流IO异常FileReader复制文本文件BufferedWriterBufferedReaderInputStream和OutputStream复制图片文件 1）IO概述 字符流和字节流。 字节流两个基类：  InputStream?? OutputStream 字符流两个基类：  Reader Writer 2）字符流
黑马程序员——基础学习日记(IO流)
wjy1090233191的专栏
01-06 604
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- IO流、笔记 IO流概述 (1)用来处理设备(硬盘，控制台，内存)间的数据。 (2)java中对数据的操作都是通过流的方式。 (3)java用于操作流的类都在io包中。 (4)按照流操作的数据的类型不同：分为字节流和字符流。字符流是为了方便中文的操作而来的。
黑马程序员-学习日记13（IO流 1 ）
03-12 439
-------android培训、java培训、期待与您交流！ ----------     01.IO流（概述）  1.IO(Input Output)流   1）IO流用来处理设备之间的数据传输   2）java对数据的操作是通过流的方式   3）java且用于操作流的对象都在IO包中   4）流按操作数据分为两种：字节流与字符流。    (1)字符流:方便处理文本数
黑马程序员-学习日记13（IO流 2 ）
03-12 334
-------android培训、java培训、期待与您交流！ ----------     .IO流（BufferdeWriter）  1.字符流的缓冲区   1）缓冲区是为了提高流的操作效率而出现的。   所以在创建缓冲区之前，必须要先有流对象。   缓冲区在流的基础上对流的功能进行了增强。   2）该缓冲区中提供了一个跨平台的换行符：newLine();   3）对
黑马程序员-学习日记15（IO流 3 ）
03-12 152
-------android培训、java培训、期待与您交流！ ----------     .File类（java.io包）：   1）用来将文件或者文件夹封装成对象   2）方便对文件与文件夹的属性信息进行操作。//流只能操作数据。   3）File对象可以作为参数传递给流的构造函数。   4）了解File类中的常用方法。  2.深入介绍File类   1）文件和目录
IO-黑马程序员Java学习笔记.rar
07-24
"IO-黑马程序员Java学习笔记"这个压缩包包含了关于Java IO的详细教程，可以帮助我们深入理解这个关键领域。下面将根据提供的文件名来解析可能包含的知识点。 1. **IO.md**： 这个文件很可能是Markdown格式的学习...
黑马程序员_毕向东_Java基础视频教程第18天-09-IO流(文件的续写)
04-07
黑马程序员_毕向东_Java基础视频教程第18天-09-IO流(文件的续写)
传智播客黑马程序员javaIO流重点总结(必读).doc
11-23
传智播客黑马程序员javaIO流重点总结(必读).doc
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
正则表达式Regex是一种文本模式.docx
最新发布
09-14
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。 基本组成 普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。 特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。 字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。 预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任
黑马程序员io流笔记
07-29
根据提供的引用内容，IO流是Java中用于处理输入和输出的机制。在Java中，有字节流和字符流两种类型的IO流。字节流是以字节为单位进行操作的，而字符流是以字符为单位进行操作的。字节流更加方便且在处理图片、音频等二进制对象时更常用，而字符流在处理中文时更为方便。\[1\]\[2\]无论是使用字节流还是字符流，操作文件时都需要使用File类来定位文件对象，并通过字节流或字符流的子类来创建对象进行读写操作。最后，需要关闭输入/输出流以释放资源。\[3\] 关于黑马程序员的IO流笔记，根据提供的信息，无法得知具体内容。请提供更多细节或具体问题，以便我能够给出更准确的回答。 #### 引用[.reference_title] - *1* *2* *3* [黑马程序员—IO学习笔记](https://blog.csdn.net/showingtime/article/details/45305741)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值