java基础 day17 IO流

最新推荐文章于 2023-05-18 02:01:02 发布
最新推荐文章于 2023-05-18 02:01:02 发布
阅读量85 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21694049/article/details/103447112
版权

IO流：

在这里插入图片描述

FileInputStream:
package wwl.Io;

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

/**
 * 读字节为单位读取文件的内容
 *
 */
public class Test02 {

	public static void main(String[] args) throws IOException {
		//1.在当前程序与指定文件之间建立流通道，读取d:/abc.txt文件的内容，通过构造方法指定要访问的文件
		//如果文件不存在就会抛出异常
		FileInputStream fis = new FileInputStream("d:/abc.txt");
		//文件内容：ABCabc
		
		//2.读写文件内容
		//read()方法从文件中读取一个字节，并把读到的字节返回，读到文件末尾返回-1
		
//		int cc = fis.read(); 	//65,A的码值
//		System.out.println(cc);
//		cc = fis.read(); 		//66,B的码值
//		System.out.println(cc);
//		cc = fis.read(); 		//67,C的码值
//		System.out.println(cc);
//		cc = fis.read(); 		//97,a的码值
//		System.out.println(cc);
//		cc = fis.read();		//98,b的码值
//		System.out.println(cc);
//		cc = fis.read(); 		//99,c的码值
//		System.out.println(cc);
//		cc = fis.read(); 		//-1,已经读到文件末尾
//		System.out.println(cc);
		
		//使用循环读取：
		int cc = fis.read(); 	//65,A的码值
		while( cc != -1) {
			//把读到的字节cc进行处理，把cc转换为字符再打印，因为当前文件中只有英文字符，有个字节对应一个字符
			System.out.print((char)cc);
			cc = fis.read();
			
		}
		//3.关闭流通道
		fis.close();
	}

}
读字节为单位读取文件的内容

在这里插入图片描述

package wwl.Io;

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

/**
 * 一次读取一个字节数组
 * 读取很多字节保存到字节数组中
 * 循环读取
 *
 */
public class Test03 {

	public static void main(String[] args) throws IOException {
		//1.在程序与读取文件之间建立流通道
		FileInputStream fis = new FileInputStream("d:/abc.txt");
		//ABCabcABC
		
		byte[] bytes = new byte[4];
		
		//从流中读取很多字节，保存到字节数组中，返回读到的字节数,如果读到文件末尾，返回-1
		int len = fis.read(bytes);
		
		while(len != -1) {
			//从文件中读取了len个字节保存到bytes数组中，对len个字节进行处理
			//把读到的len个字节转换为字符串 new String(byte[] bytes , 0 , len)
			System.out.print(new String(bytes , 0 , len));
			//继续读
			len = fis.read(bytes);
		}
		
//		System.out.println(len);
//		System.out.println(Arrays.toString(bytes));
//		
//		len = fis.read(bytes);
//		System.out.println(len);
//		System.out.println(Arrays.toString(bytes));
//		
//		len = fis.read(bytes);
//		System.out.println(len);
//		System.out.println(Arrays.toString(bytes));
//		
//		len = fis.read(bytes);
//		System.out.println(len);
//		System.out.println(Arrays.toString(bytes));
//		
		fis.close();
	}

}
异常处理：
package wwl.Io;

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

/**
 * 异常处理
 *
 */
public class Test04 {

	public static void main(String[] args) {
		m1();   //一次读取一个字节，手动关闭流，异常处理
		System.out.println();
		m2();   //从文件中读取字节保存到字节数组中，异常处理，自动关闭流
	}
	
	//从JDK7开始，流可以自动关闭
	private static void m2() {
		try(       //try资源块，自动释放
				FileInputStream fis = new FileInputStream("d:/abc.txt");
				) {
			byte[] bytes = new byte[4];
			int len = fis.read(bytes);
			while(len != -1) {
				System.out.print(new String(bytes , 0 , len));
				len = fis.read(bytes);
			}
		} catch (Exception e) {
			e.printStackTrace();//打印异常
		}
	}

	//手动关闭流，异常处理
	//alt+shift+z可以捕获所选代码的异常
	private static void m1() {
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("d:/abc.txt");
			
			int cc = fis.read();
			while( cc != -1) {
				System.out.print((char)cc);
				cc = fis.read();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if( fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				} //关闭流，释放系统资源
			}
		}
		
		
	}

}
Fileoutputstream:
package wwl.Io;

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

/**
 *FileOutputStream
 * 以字节为单位把数据保存到文件中
 */
public class Test05 {

	public static void main(String[] args) throws IOException {
		//1.建立流通道
		//如果访问的文件不存在，系统会创建一个新文件；如果文件已存在内容，会覆盖原文件内容
//		FileOutputStream fos = new FileOutputStream("d:/def.txt");
		
		//如果文件不存在就创建文件，如果文件已存在，把内容保存到文件后面，即以追加的方式打开文件
		FileOutputStream fos = new FileOutputStream("d:/def.txt" , true);
		
		//2.保存数据
		//一次写一个字节
		fos.write(65);  //把65对应的字符A保存到文件中
		fos.write(66);  //把66对应的字符A保存到文件中
		fos.write(67);  //把67对应的字符A保存到文件中
		
		//换行，在windows操作系统中，换行需要使用\r\n两个字符
		fos.write('\r');  //回车，13
		fos.write('\n');  //换行，10
		
		//一次写一个字节数组
		byte[] bytes = "wwlssaa".getBytes();
		fos.write(bytes);  //把bytes数组中所有的字节保存到文件中
		
		//换行
		fos.write(13);
		fos.write(10);
		
		//把字节数组的部分字节保存到文件中
		fos.write(bytes, 0, 2);
		
		//3.关闭流
		fos.close();
	}

}
以字节为单位实现文件的复制：
package wwl.Io;

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

import wwl.interfaces.swimer.fish;

/**
 * 以字节为单位实现文件的复制
public class Test06 {

	public static void main(String[] args) {
		String src = "F:/Java code/wwl/src/wwl/Io/Test06.java";
		String deString = "d:/test08.java";
		copyFile(src, deString);
	}
	
	//一次复制一个字节,异常处理，手动关闭流
	public static void copyFile(String srcFilename , String destFilename)  {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream(srcFilename);
			fos = new FileOutputStream(destFilename);
			int cc = fis.read();
			//如果cc不是-1，把cc保存到目标文件中
			while(cc != -1) {
				fos.write(cc); // 把读到的字节cc保存到输出流中
				cc = fis.read();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(fos != null) {
				try {
					fos.close();
				}  catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
}
以字节数组为单位实现文件的复制（效率要远远高于以字节为单位复制）：
package wwl.Io;

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

import wwl.interfaces.swimer.fish;

/**
 * 以字节数组为单位实现文件的复制
 *
 */
public class Test07 {

	public static void main(String[] args) {
//		String src = "F:/Java code/wwl/src/wwl/Io/Test06.java";
//		String deString = "d:/test08.java";
		
		String src = "F:\\学习\\2017MySQL\\001_动力节点_MySQL_MySQL数据库管理系统前言\\动力节点_MySQL_001_MySQL数据库管理系统前言.avi";
		String deString = "d:/hehe.avi";
		copyFile(src, deString);
	}
	
	//一次复制一个字节数组，异常处理，自动关闭流
	public static void copyFile(String srcFilename,String destFilename) {
		try ( 
				FileInputStream fis = new FileInputStream(srcFilename);
				FileOutputStream fos = new FileOutputStream(destFilename);
				){
			byte[] bytes = new byte[1024]; // 字节数组一般是1024的偶数倍
			int len = fis.read(bytes);
			while(len != -1) {
				fos.write(bytes, 0, len);
				len = fis.read(bytes);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	} 
}
FileReader:

以字符为单位读写内容：
与字节流大同小异

package wwl.Io;

import java.io.FileReader;
import java.io.IOException;

/**
 * FileReader/FileWriter
 * 以字符为单位读写文件内容，只能读写纯文本文件，要求文本文件的编码格式要与当前环境的编码格式兼容
 *
 */
public class Test08 {

	public static void main(String[] args) throws IOException {
		m1();//通过FileReader读取文件内容
		m2();//读取文本文件内容，一次性读取一个字符数组，异常处理，自动关闭
	}

	private static void m2() {
		try (
				FileReader fr = new FileReader("d:/abc.txt");
				){
			char[] contents = new char[1024];
			int len = fr.read(contents);
			while(len != -1) {
				//把读到的len个字符进行处理，转换为字符串打印
				System.out.println(new String(contents, 0, len));
				len = fr.read(contents);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private static void m1() throws IOException {
		//建立流通道
		//一般使用FileReader读取与当前环境编码一致的文件
		FileReader fr = new FileReader("d:/abc.txt");
		
		//read()一次读取一个字符，返回字符的码值，读到文件末尾返回-1
		int cc = fr.read();
		while(cc != -1) {
			//把读到的字符打印到屏幕上
			System.out.print((char)cc);
			cc = fr.read();
		}
		fr.close();
	}
	

}
FileWriter:

注意追加的方式打开

package wwl.Io;

import java.io.FileWriter;
import java.io.IOException;

/**
 * FileWriter
 * 		保存数据时，只能把数据保存到utf-8编码(当前环境是UTF8)格式的文件中
 *
 */
public class Test09 {

	public static void main(String[] args) {
		//建立流通道
		FileWriter fw = null;
		try {
			//如果文件不存在，会创建新的文件，如果文件存在会覆盖原来的内容
//			fw = new FileWriter("d:/abc.txt");
			
			//文件不存在就创建，文件已存在，以追加的方式打开
			fw = new FileWriter("d:/abc.txt",true);
			
			//把字符保存到文件中
			//一次写一个字符
			fw.write('A');
			fw.write('汉');
			
			//一次写一个字符串
			fw.write("哈师大哈师大");
			
			//换行
			fw.write("\r\n");
			
			//一次写一个字符数组
			char[] contents = "发生发生法发首发式发生，啊十分大方".toCharArray();
			fw.write(contents);
			
			//把字符数组的部分数组保存到文件中
			fw.write(contents, 0, 5);
			
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//关闭
			if(fw != null) {
				try {
					fw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

}
文本的文件复制：
package wwl.Io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 文本文件复制
 *
 */
public class Text10 {

	public static void main(String[] args) {
		String src = "d:/abc.txt";
		String dest = "d:/abc.txt";
		copyFile1(src, dest);
		copyFile2(src, dest);
	}
	
	//以文本文件复制，一次复制一个字符，异常处理，自动关闭流
	public static void copyFile1(String srcFilename , String destFilename) {
		try (
				FileReader fr = new FileReader(srcFilename);
				FileWriter fw = new FileWriter(destFilename);
				){
			int cc = fr.read();
			while(cc != -1) {
				fw.write(cc);
				cc = fr.read();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	//以文本文件复制，一次复制一个字符数组，异常处理，手动关闭流
	public static void copyFile2(String srcFilename , String destFilename) {
		FileReader fr = null;
		FileWriter fw = null;
		try {
			fr = new FileReader(srcFilename);
			fw = new FileWriter(destFilename);
			char[] contents = new char[1024];
			int len = fr.read(contents);
			while(len != -1) {
				fw.write(contents,0,len);
				len = fr.read(contents);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(fr != null) {
				try {
					fr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fw != null) {
				try {
					fw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}
转换流：
package wwl.Io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

/**
 * FileReader/FileWriter只能读写与当前环境编码兼容的文本文件
 * 如果文本文件与当前环境编码不兼容，使用InputStreamReader/OutputStreamWriter转换流读写
 * 转换流采用了适配器模式
 *
 */
public class Test11 {

	public static void main(String[] args) throws IOException {
		m1();//使用InputStreamReader读取文件内容
		m2();
	}
	
	//当操作的文件编码与当前环境编码不兼容可以使用OutStreamwriter把字符以指定的编码转换为字符
	private static void m2() throws IOException {
		//把字符保存到d:/abc.txt文件，该文件是GBk编码，当前环境是utf8编码，把字符转换为GBK格式再保存
		OutputStream out = new FileOutputStream("d:/abc.txt",true);
		OutputStreamWriter osw = new OutputStreamWriter(out,"GBK");
		
		osw.write("\r\n");
		osw.write("当前文件是转换流保存到文件，工作区是utf8，文件是GBK");
		osw.close();
	}

	//当文本文件的编码与当前环境编码不兼容时，使用InputStreamReader类读取
	private static void m1() throws IOException {
		//读取d:/abc.txt文件，该文件使用GBK编码，当前环境使用UTF-8编码
		//在当前程序与指定文件之间创建字节流通道
		InputStream in = new FileInputStream("d:/abc.txt");
		//使用GBK编码，把in字节流中的数据转换为字符流
		InputStreamReader isr = new InputStreamReader(in, "GBK");
		int len = isr.read();
		while(len != -1) {
			System.out.print((char)len);
			len = isr.read();
		}
		isr.close();
	}
}
字符缓冲流：

在这里插入图片描述

package wwl.Io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.Writer;

/**
 * 字符缓冲流
 * BufferedReader/BufferedWriter 
 * 也称一种处理流，包装流
 *
 */
public class Text12 {

	public static void main(String[] args) throws IOException {
		m1();//使用BufferedReader读取文本内容
		m2();//使用BufferedWriter保存文本到文件
		m3();//从键盘上输入文本，把这些文本保存到文件中
	}

	private static void m3() throws IOException {
		BufferedWriter bw = new BufferedWriter(new FileWriter("d:/abc.txt"));
		//使用BufferedReader对键盘输入流缓存
//		System.in(字节流)是标准的输入设备，即键盘
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		String line = br.readLine();
		while(line.length() > 0) {
			bw.write(line);
			bw.newLine();
			line = br.readLine();
		}
		br.close();
		bw.close();
	}

	private static void m2() throws IOException {
		Writer out = new FileWriter("d:/abc.txt",true);
		BufferedWriter bw = new BufferedWriter(out);
		
		bw.write("我送你");
		
		//bw.flush();//清空缓存区把数据保存到文件中
		bw.close();
	}

	private static void m1() throws IOException {
		Reader in = new FileReader("d:/abc.txt");
		BufferedReader br = new BufferedReader(in);
		
		//从缓冲字符流中读取一行，读到文件末尾返回null
		String Line = br.readLine();
		while(Line != null) {
			System.out.println(Line);
			Line = br.readLine();
		}
		br.close();//把包装流关闭后，被包装的流也会关闭
	}

}
龙是我吗？
关注
专栏目录
Java IO流（超详细！）
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
java 图片io流_关于JavaIO流的图片读取
weixin_32757449的博客
02-16 1099
关于JavaIO流的图片读取自我介绍一下大家好，新的一年,新的一个学期…我是一个大二的学生，我姓林。最近Java刚刚学到IO流这一板块知识。在此，发表一下关于IO流的图片读取总结的心得还有思路…简单介绍一下IO板块中有输出流还有输入流，后面还有缓冲流等等 ，现在简单介绍输出流还有输入流在Java的IO这一板块中,有输入流InPutStream(当然，这是输入流的父类也是抽象类)它的子类是FileI...
java中的io流
热门推荐
m0_66689823的博客
07-19 1万+
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 。
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6303
笑霸能看懂的学习笔记
【Java基础】· IO流习题详解
麟-小白的博客
12-18 1719
Hello大家好， 我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！！！如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多呀！❤❤❤爱你们！！！目录【往期回顾】什么是java序列化，如何实现java序列化？答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。
JAVA_IO流的关闭两种方式
bolinmengling的博客
03-21 5919
流的关闭 当使用完流后，显示的关闭所有打开的流仍然是一个好习惯。一个被打开的流有可能会用尽系统的资源，这取决于平台和实现。如果没有将流关闭，另一个程序试图打开另一个流时，可能会得到不需要的资源。 从JDK1.7后，有两种关闭数据流的方法，分别如下： 方法一：手动关闭。即为使用close()显式地关闭流，代码如下 package com.qfstu.Week04.Day01; import java.io.FileInputStream; import java.io.IOException; /**
Java基础-IO流（缓冲流）
weixin_50369190的博客
10-22 698
BufferedInputStream,BufferedOutputStream,BufferedReader ,BufferedWriter基本使用
《JAVA300集》IO流_处理流-day17
Amigo_1997的博客
12-29 2538
字节缓冲流 字节缓冲流可以提高读写操作的效率，默认的缓冲区大小是8K。 所有流的最底层都是节点流。 JAVA的节点流和处理流 节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader. 处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。 JAVA常用的节点流：　 文 件 FileInputStream FileOutpu..
Java 基础进阶篇（十五）：IO 流总结（全网最全面）
秀岩的博客
05-18 1508
前置内容：字符集 一、IO 流概述 二、字节流 三、字符流 四、缓冲流 五、转换流 六、序列化流 七、打印流 补充：Commons-IO 框架
Java基础——IO详解
qq_45821255的博客
03-21 3096
本文介绍了IO流的具体内容，包括总结了常用的IO流，把它们做成了体系图。根据体系图分别介绍了它们的使用场景...
day34IO流基础File类.rar
05-02
javaIO的基础File类，适合小小白啥都不会的第一次学Java的小朋友相信看完这几个文档和代码你就大概知道IO在做什么了。然后后面再继续学习。基本上不管学什么都是一个记忆和积累的过程小小白白们共勉。
Day22 IO流及Java8新特性.md
08-09
缓冲流：对于频繁操作的的文件一般使用缓冲流 Lambda:lambda表达式的写法 相当于匿名内部类的简写： 语法结构：(参数)->{功能语句}; Stream: 操作对象需要调用stream()或者是parallelStream()方法转换为流在进行方法...
yolo算法-电线杆数据集-1493张图像带标签-.zip
11-17
yolo算法-电线杆数据集-1493张图像带标签-.zip；yolo算法-电线杆数据集-1493张图像带标签-.zip；yolo算法-电线杆数据集-1493张图像带标签-.zip
yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip
11-17
yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip；yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip；yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip；yolo算法-电线杆数据集-7255张图像带标签-杆顶.zip
pillow_avif_plugin-1.2.1-cp37-cp37m-win32.whl.rar
11-17
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
【地震】基于matlab时域有限差分FDTD模拟地震盾构【含Matlab源码 9186期】.mp4
11-17
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
中国高质量发展指标体系-最新发布.zip
最新发布
11-17
中国高质量发展指标体系-最新发布.zip
【java毕业设计】班级同学录管理系统源码（ssm+mysql+说明文档）.zip
11-17
环境说明： 开发语言：Java 框架：ssm，mybatis JDK版本：JDK1.8 数据库：mysql 5.7及以上 数据库工具：Navicat11及以上 开发软件：eclipse/idea Maven包：Maven3.3及以上 服务器：tomcat7及以上
【java毕业设计】基于Java的汽车销售系统源码（ssm+mysql+说明文档）.zip
11-17
环境说明： 开发语言：Java 框架：ssm，mybatis JDK版本：JDK1.8 数据库：mysql 5.7及以上 数据库工具：Navicat11及以上 开发软件：eclipse/idea Maven包：Maven3.3及以上 服务器：tomcat7及以上
Java IO理解：字节流与字符流解析
在Java编程中，IO流（Input/Output Stream）是处理数据传输的核心部分，主要用于在不同设备之间进行数据的读取和写入。在描述的文档中，提到了以下几个关键知识点： 1. **IO流的概念**：IO流是一种模拟数据传输的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值