尺有所短；寸有所长。物有所不足；智有所不明
java之I/O输入输出流解析
一、流的概述
流是一组有序的数据序列，根据操作的类型，可以分为输入流和输出流。I/O流提供了一条通道程序，可以使用这条通道把源中的字节序列送到目的地。
二、输入模式 输出模式图
三、java流的分类
输入流: 程序可以从中读取数据的流。
输出流: 程序能向其中写入数据的流。
按数据传输单位分:
字节流: 以字节为单位传输数据的流
字符流: 以字符为单位传输数据的流
节点流: 用于直接操作目标设备的流
处理流: 是对一个已存在的流的链接和封装，通过对数据进行处理为程序提供功能强大、灵活的读写功能。
四、字节输入流(InputStream)/字节输出流(OutputStream)简介及方法
InputStream类是字节输入流的抽象类，是所有字节输入流的父类。必须依靠其子类实现各种功能，且数据单位为字节(8bit)；他是指数据以字节形式从其他文件或者设备向程序流入。常用方法如下：
（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。
　　（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的
　　（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。
　　（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返
回0，这个方法必须由继承InputStream类的子类对象调用才有用，
　　（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取
　　（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭.
OutputStream类是字节输出流的抽象类，此抽象类是表示输出字节流的所有类的超类；他是数据以字节形式从程序流出，输出流只能向流中写入数据
OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。
　　1. public void write(byte b[ ])：将参数b中的字节写到输出流。
　　2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。
　　3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。
　　4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。
　　5. public void close( ) : 关闭输出流并释放与流相关的系统资源。
注意：并不是所有的inputstream类的子类都支持inputstream中定义的方法，如skip() mark() reset()等方法只对某些子类有用
五、文件输入/输出流实例
FileInputStream类与FileOutputStream类
&span style="font-size:12"&/*文件输入流： FileInputStream类
作用：以文件作为数据输入源的数据流。或者说是打开文件，从文件读数据到内存的类。
import java.io.IOE
import java.io.FileInputS
public class TestFile {
public static void main(String args[]) throws IOException {
FileInputStream rf=new
FileInputStream("A.java");
//有内容的java文件
int n=512;
while((rf.read(b,0,n)!=-1)&&(n&0)){
System.out.println(new String(b) );
System.out.println();
rf.close();
} catch(IOException
System.out.println(IOe.toString());
/*文件输出流：FileOutputStream类
作用：用来处理以文件作为数据输出目的数据流；或者说是从内存区读数据入文件
import java.io.IOE
import java.io.FileOutputS
public class TestFile {
public static void main(String args[]) throws IOException {
System.out.println("请输入");
int count, n = 512;
byte buffer[] = new byte[n];
count = System.in.read(buffer);
//从键盘接收
FileOutputStream wf = new FileOutputStream("d:/write.txt");
//文件需要已存在
wf.write(buffer, 0, count);
wf.close(); // 当流写操作结束时，调用close方法关闭流。
System.out.println("内容保存成功！");
} catch (IOException IOe) {
System.out.println("文件写入失败！");
六、字符流的读取和写入 抽象类：Reader和Writer
Reader用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。
1) FileReader :与FileInputStream对应
主要用来读取字符文件，使用缺省的字符编码，有三种构造函数：
(1）将文件名作为字符串 ：FileReader f=new FileReader(“c:/temp.txt”);
(2）构造函数将File对象作为其参数。
File f=new file(“c:/temp.txt”);
FileReader f1=new FileReader(f);
构造函数将FileDescriptor对象作为参数
FileDescriptor() fd=new FileDescriptor()
FileReader f2=new FileReader(fd);
(1) 用指定字符数组作为参数：CharArrayReader(char[])
(2) 将字符数组作为输入流:CharArrayReader(char[], int, int)
读取字符串，构造函数如下： public StringReader(String s);
(3) CharArrayReader：与ByteArrayInputStream对应
(4) StringReader : 与StringBufferInputStream对应
(5) InputStreamReader从输入流读取字节，在将它们转换成字符:Public inputstreamReader(inputstream is);
(6) FilterReader: 允许过滤字符流
protected filterReader(Reader r);
(7) BufferReader :接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。
Public BufferReader(Reader r);
Writer 写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。
1） FileWrite: 与FileOutputStream对应
将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。
Public FileWrite(file f);
chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。
Public CharArrayWrite();
　　3) PrintWrite:生成格式化输出
public PrintWriter(outputstream os);
　　4) filterWriter:用于写入过滤字符流
protected FilterWriter(Writer w);
　　5) PipedWriter：与PipedOutputStream对应
6) StringWriter：无与之对应的以字节为导向的stream
主要方法：
public void write(int c) throws IOException； //将整型值c的低16位写入输出流
public void write(char cbuf[]) throws IOException； //将字符数组cbuf[]写入输出流
public abstract void write(char cbuf[],int off,int len) throws IOException； //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流
public void write(String str) throws IOException； //将字符串str中的字符写入输出流
public void write(String str,int off,int len) throws IOException； //将字符串str 中从索引off开始处的len个字符写入输出流
flush( ) //刷空输出流，并输出所有被缓存的字节。
关闭流 public abstract void close() throws IOException
----------------------------------------------------------------------------------------------------------------------------
字节与字符的转换流
说到这先说一下二者的区别
1）字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，
2）而字节流处理单元为1个字节， 操作字节和字节数组。
字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以。
所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！
如果是 音频文件、图片、歌曲，就用字节流好点。
如果是关系到中文（文本）的，用字符流好点
InputStreamReader 和OutputStreamWriter 分别是Reander和Writer的子类，二者用于字节流和字符流之间的转换。
InputStreamReader用于将输入的字节流转变为字符流
OutputStreamWriter
用于将输入的字符流转变为字节流
Reader reader = new InputStreamReader(new FileInputStream("d:\\1.txt"));
System.out.println(reader.read());
reader.close();
File f=new File(“d:/1.txt”);
OutputStreamWriter os=new OutputStreamWriter(new FileOPutInStream(f));
Os.write(“hello word”);
Os.close();
---------------------------------------------------------------------------------------------------------------
七、带缓存的输入/输出流
BufferedInputStream:当向缓冲流写入数据时候，数据先写到缓冲区，待缓冲区写满后，系统一次性将数据发送给输出设备。
BufferedOutputStream :当从向缓冲流读取数据时候，系统先从缓冲区读出数据，待缓冲区为空时，系统再从输入设备读取数据到缓冲区。
1）将文件读入内存：
将BufferedInputStream与FileInputStream相接
FileInputStream in=new
FileInputStream( “file1.txt ” );
BufferedInputStream bin=new
BufferedInputStream( in);
2）将内存写入文件：
将BufferedOutputStream与 FileOutputStream相接
FileOutputStreamout=new FileOutputStream(“file1.txt”);
BufferedOutputStream
bin=new BufferedInputStream(out);
BufferedReader和BufferedWriter是带缓冲区的Reader和Writer.
使用BufferedReader读取文本时，将首先从文件中读取字符数据并存入缓冲区中，然后调用read(),先冲缓冲区开始读取，缓冲区不足是再从文件中读取；
使用BufferedWriter时，写入数据将先存储到缓冲区中，在缓冲区饱满的情况下将一次性写入目的地。
通过缓冲区可以减少对硬盘的输入或输出操作，提高文件存取效率。
File f=new File（“d;/demo.txt）;
FileWriter bufWriter=new BufferedWriter(writer);
bufWriter.writer(“hello word);
bufwruter.close();
writer.close();
FileReader reader =new FileReader(“f);
BufferedReader bufReader=new BufferedReader(reader);
Sysout.out.print(bufReader.readLine());
八、数据输入/输出流
DataInputStream与DataOutputStream允许应用程序以与机器无关的方式从底层输入流中读取基本java数据类型。
简单说就是，当读取一个数据时，不必再关心这个数值应当是哪种字节
DataInputStream(InputStream in)
使用指定的底层 InputStream 创建一个 DataInputStream
DataOutputStream(OutputStream out) 创建一个新的数据输出流，将数据写入指定基础输出流。
DataOutputStream类提供的3种写入方法
writeBytes(String s)
将字符串按字节顺序写出到基础输出流中。
writeChars(String s)
将字符串按字符顺序写入基础输出流。
writeUTF(String str)
以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
&span style="font-size:12"&public static void main(String[] args) throws Exception {
//创建FileOutputStream对象
FileOutputStream fos=new FileOutputStream("d:/1.txt");
//创建DataOutputStream对象
DataOutputStream dos=new DataOutputStream(fos);
//写入磁盘文件数据
dos.writeUTF("使用writeUTF()方法写入数据");
// dos.writeBytes("使用writeBytes()方法写入数据");
// dos.writeChars("使用writeChars()方法写入数据");
dos.close();//关闭流
//创建FileInputStream对象
FileInputStream fis=new FileInputStream("d:/1.txt");
//创建DataInputStream对象
DataInputStream dis=new DataInputStream(fis);
System.out.print(dis.readUTF());
//将文件输入输出
九、一言不合就上题：文件及文件夹的拷贝实例
&span style="font-size:12"&public static void main(String[] args) {
File f=new File("d:/英雄时刻");
new File(f, f.getName()).mkdir();
copyDirectory(new File("d:/英雄时刻"),new File( "e:/"));
copyFile(new File("d:/1.txt"), new File("e:/1.txt"));
} catch (IOException e) {
e.printStackTrace();
System.out.println("拷贝完毕！");
//文件的复制
public static void copyFile(File f1,File f2) throws IOException{
BufferedInputStream bis=new BufferedInputStream(new FileInputStream(f1));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(f2));
byte [] b=new byte[512];
while((len=bis.read(b))!=-1){
bos.write(b, 0, len);
bos.flush();
if(bos!=null)
bos.close();
if(bos!=null)
bis.close();
//文件夹的复制
public static void copyDirectory(File f1,File f2){
File f=new File(f2, f1.getName());
f.mkdir();
File []fl=f1.listFiles();
for (File file : fl) {
if(file.isDirectory()){
copyDirectory(file, f);
copyFile(file, new File(f,file.getName()));
} catch (IOException e) {
e.printStackTrace();
十、IOException异常类的子类
1.public class
EOFException ：
非正常到达文件尾或输入流尾时，抛出这种类型的异常。
2.public class FileNotFoundException：
当文件找不到时，抛出的异常。
3.public class InterruptedIOException：
当I/O操作被中断时，抛出这种类型的异常。
为什么要有异常处理
因为在输入输出中，会出现一些你想不到的异常，所以要用try catch语句捕获这些异常并做友好提示，方便我们的操作
比如读文件时你的文件不存在 它会出现系统错误，为了方便，捕获他做友好提示很方便继续操作
更多内容：
http://blog.csdn.net/hguisu/article/details/7418161
http://blog.csdn.net/xfhuajian/article/details/6439374
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！JAVA最简单的输入输出
一、从命令行输入输出数据
1.向控制台输出数据
标准输出流（System.out）中为人们提供了3种输出方法：
1）print(输出项)：实现不换行输出。输出项可以是变量名、常量、表达式。
2）println（输出项）：输出数据后换行。输出项可以是变量名、常量、表达式。
3）printf（"格式控制部分”,表达式1,表达式2，....表达式n）：格式控制部分由“格式控制符”+“普通字符组成”。。。普通字符原样输出；常用的格式控制符有：
%d（代表十进制数）、%c（代表一个字符）、%f（代表浮点数）、%e（代表科学计数法的浮点数）、%s（代表字符串）、%n（代表换行符）。。。。
输出时也可以控制数据的宽度：
%md：输出的int型数组占m列%m.nf：输出的浮点型数组占m列，小数点部分保留n位%.nf：输出的浮点型数据小数部分保留n位
关于%e举例：
System.out.printf("%e",1500.34);
二、从控制台输入数据
1.使用Scanner类---------java.util.Scanner类。步骤：
---------------------------import java.util.*;
---------------------------构造Scanner类对象，它附属于标准输入流System.in如：Scanner sb = new Scanner(System.in);
---------------------------常用的next()方法系列：nextInt():输入整数nextLine():输入字符串nextDouble():输入双精度数next():输入字符串（以空格作为分隔符）
import java.util.*;
public class DEMO_1 {
public static void main(String[] args){
Scanner sb = new Scanner(System.in);
System.out.print("输入你的姓名：");
String name = sb.nextLine();
System.out.print("输入你的年龄：");
int age = sb.nextInt();
System.out.println("姓名：" + name + "年龄：" + age );
sb.close();//若没有关闭Scanner对象将会出现警告
输入你的姓名：一吨重的肥羊
输入你的年龄：99
姓名：一吨重的肥羊年龄：99
责任编辑：
声明：该文观点仅代表作者本人，搜狐号系信息发布平台，搜狐仅提供信息存储空间服务。
今日搜狐热点豆丁微信公众号
君，已阅读到文档的结尾了呢~~
java输入输出流总结
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
java输入输出流总结
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='http://www.docin.com/DocinViewer--144.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口以大多数人的努力程度之低，根本轮不到拼天赋！
java输入输出流实例代码
1.编写一个程序，读取源代码文件的内容并在控制台输出。如果源文件不存在，则显示相应的错误信息。
import java.io.F
import java.io.FileNotFoundE
import java.io.FileR
import java.io.IOE
public class test01 {
public static void main(String[] args) {
File f = new File("test01.java");//文件当前目录下，在eclipse下是该工程目录下。
FileReader fr = new FileReader(f);//将文件读取到内容中
//int包含char的范围
while((m=fr.read())!=-1){
System.out.print((char)(m));//强制转为char
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
2.编写一个程序实现如下功能，从当前目录下的文件input.txt中读取80个字节（实际读到的字节数可能比80少）并将读来的字节写入当前目录下的文件output.txt中
import java.io.F
import java.io.FileInputS
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.IOE
public class test01 {
public static void main(String[] args) {
File f1 = new File("input.txt");
File f2 = new File("output.txt");
FileInputStream fis = new FileInputStream(f1);
FileOutputStream fos = new FileOutputStream(f2);
byte[] temp = new byte[80];//定义一个字节数组
fis.read(temp);//读到内存中
fos.write(temp);//写到文件
fis.close();
fos.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("运行结束");
3,使用java的输入/输出流技术将一个文本文件的内容按行读出，每读出一行就顺序添加行号，并写入到另一个文件中。
import java.io.BufferedR
import java.io.BufferedW
import java.io.F
import java.io.FileNotFoundE
import java.io.FileR
import java.io.FileW
import java.io.IOE
public class test01 {
public static void main(String[] args) {
File f1 = new File("input.txt");
File f2 = new File("output.txt");
FileReader fr = new FileReader(f1);
FileWriter fw = new FileWriter(f2);
BufferedReader br = new BufferedReader(fr);
BufferedWriter bw = new BufferedWriter(fw);
int i=1;//行号
while((temp=br.readLine())!=null){
bw.write(i+","+temp);
bw.newLine();//换行
bw.flush();//把缓冲区内容写到文件,如果没有这条语句，输出文件为空。
//使用缓存型流时操作完成后必须加上flush语句。
br.close();
bw.close();
br.close();
bw.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("运行结束");
4.编写一个程序，接收从键盘输入的数据，并把从键盘输入的内容写到input.txt文件中，如果输入"quit"，则程序结束。
import java.io.F
import java.io.FileW
import java.io.IOE
import java.util.S
public class Test {
public static void main(String[] args) {
File f = new File("input.txt");
FileWriter fw = new FileWriter(f);
Scanner scanner = new Scanner(System.in);
while(!((temp=scanner.nextLine()).equals("quit"))){
fw.write(temp);
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
5.编写一个程序实现如下功能，文件input.txt是无行结构（无换行符）的汉语文件，从input中读取字符，写入文件output.txt中，每10个字符一行（最后一行可能少于10个字）
* 注意设置input.txt为UTF-8格式，否则读取中文显示乱码
import java.io.F
import java.io.FileNotFoundE
import java.io.FileR
import java.io.FileW
import java.io.IOE
public class test01 {
public static void main(String[] args) {
File f1=new File("input.txt");
File f2=new File("output.txt");
FileReader fr=new FileReader(f1);
FileWriter fw=new FileWriter(f2);
char temp[]=new char[10];
while((len=fr.read(temp))!=-1)
if(len==10)
fw.write(new String(temp)+"\r\n");
* windows下的文本文件换行符:\r\n linux/unix下的文本文件换行符:\r
* Mac下的文本文件换行符:\n
fw.write(temp, 0, len);
fr.close();
fw.close();
} catch (FileNotFoundException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
System.out.println("程序结束");
}6.逐行读取汉字文件，复制到另一个文件
import java.io.BufferedR
import java.io.F
import java.io.FileInputS
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.FileW
import java.io.IOE
import java.io.InputStreamR
import java.io.OutputStreamW
public class test01 {
public static void main(String[] args)
File f = new File("input.txt");
File outFile=new File("output.txt");
InputStreamReader read =
OutputStreamWriter write=
read = new InputStreamReader (new FileInputStream(f));//注意事先设置好input.txt的编码格式为UTF-8，否则输出乱码
write=new OutputStreamWriter(new FileOutputStream(outFile));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
BufferedReader reader=new BufferedReader(read);
while ((line = reader.readLine()) != null) {
System.out.println(line);
write.write(line+"\r\n");
write.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！&>&Java初学者输入输出流常用方法及简介
Java初学者输入输出流常用方法及简介
上传大小：1.55MB
简介输入输出流意义及分类，举例常用文件读取与写入方式
综合评分：0
{%username%}回复{%com_username%}{%time%}\
/*点击出现回复框*/
$(".respond_btn").on("click", function (e) {
$(this).parents(".rightLi").children(".respond_box").show();
e.stopPropagation();
$(".cancel_res").on("click", function (e) {
$(this).parents(".res_b").siblings(".res_area").val("");
$(this).parents(".respond_box").hide();
e.stopPropagation();
/*删除评论*/
$(".del_comment_c").on("click", function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_invalid/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parents(".conLi").remove();
alert(data.msg);
$(".res_btn").click(function (e) {
var parentWrap = $(this).parents(".respond_box"),
q = parentWrap.find(".form1").serializeArray(),
resStr = $.trim(parentWrap.find(".res_area_r").val());
console.log(q);
//var res_area_r = $.trim($(".res_area_r").val());
if (resStr == '') {
$(".res_text").css({color: "red"});
$.post("/index.php/comment/do_comment_reply/", q,
function (data) {
if (data.succ == 1) {
var $target,
evt = e || window.
$target = $(evt.target || evt.srcElement);
var $dd = $target.parents('dd');
var $wrapReply = $dd.find('.respond_box');
console.log($wrapReply);
//var mess = $(".res_area_r").val();
var mess = resS
var str = str.replace(/{%header%}/g, data.header)
.replace(/{%href%}/g, 'http://' + window.location.host + '/user/' + data.username)
.replace(/{%username%}/g, data.username)
.replace(/{%com_username%}/g, data.com_username)
.replace(/{%time%}/g, data.time)
.replace(/{%id%}/g, data.id)
.replace(/{%mess%}/g, mess);
$dd.after(str);
$(".respond_box").hide();
$(".res_area_r").val("");
$(".res_area").val("");
$wrapReply.hide();
alert(data.msg);
}, "json");
/*删除回复*/
$(".rightLi").on("click", '.del_comment_r', function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_comment_del/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parent().parent().parent().parent().parent().remove();
$(e.target).parents('.res_list').remove()
alert(data.msg);
//填充回复
function KeyP(v) {
var parentWrap = $(v).parents(".respond_box");
parentWrap.find(".res_area_r").val($.trim(parentWrap.find(".res_area").val()));
评论共有0条
VIP会员动态
CSDN下载频道资源及相关规则调整公告V11.10
下载频道用户反馈专区
下载频道积分规则调整V1710.18
spring mvc+mybatis+mysql+maven+bootstrap 整合实现增删查改简单实例.zip
资源所需积分/C币
当前拥有积分
当前拥有C币
输入下载码
为了良好体验，不建议使用迅雷下载
Java初学者输入输出流常用方法及简介
会员到期时间：
剩余下载个数：
剩余积分：0
为了良好体验，不建议使用迅雷下载
积分不足！
资源所需积分/C币
当前拥有积分
您可以选择
程序员的必选
绿色安全资源
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
您的积分不足，将扣除 10 C币
为了良好体验，不建议使用迅雷下载
无法举报自己的资源
你当前的下载分为234。
你还不是VIP会员
开通VIP会员权限，免积分下载
你下载资源过于频繁，请输入验证码
您因违反CSDN下载频道规则而被锁定帐户，如有疑问，请联络:!
若举报审核通过，可返还被扣除的积分
被举报人：
举报的资源分：
请选择类型
资源无法下载 （ 404页面、下载失败、资源本身问题）
资源无法使用 （文件损坏、内容缺失、题文不符）
侵犯版权资源 （侵犯公司或个人版权）
虚假资源 （恶意欺诈、刷分资源）
含色情、危害国家安全内容
含广告、木马病毒资源
*详细原因：
Java初学者输入输出流常用方法及简介}