JAVA输入输出流
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{ System.exit(0);
}
});
validate();
}
public void itemStateChanged(ItemEvent e)
choice=new Choice();
choice.add("training1.txt");
choice.add("training2.txt");
choice.add("training3.txt");
showCharacters=new Label("",Label.CENTER);
showCharacters.setFont(new Font("宋体",Font.BOLD,72));
if(boo)
{ if(flag==1)
{ wordStarPostion=inOne.getFilePointer()-1;
flag=0;
}
}
else
{ if(flag==0)
{
if(c==-1)
wordEndPostion=inOne.getFilePointer();
else
wordEndPostion=inOne.getFilePointer()-1;
Java中的流分为两种，一种是字节流，另一种是字符流，分别由四个抽象类来表示（每种流包括输入和输出两种所以一共四个）:InputStream，OutputStream，Reader，Writer。Java中其他多种多样变化的流均是由它们派生出来的。
（3）通过编译得出如下答案
【代码1】：new FileReader(file);【代码2】：new BufferedReader(inOne);【代码3】：inTwo.readLine();【代码4】：new FileReader(helpFile);【代码5】：new BufferedReader(inOne);
{ allWorsd=new Vector();
noSameWord=new Vector();
}
public void wordStatistic(File file)
{ try{ RandomAccessFile inOne=【代码1】//创建指向文件file的inOne的对象
RandomAccessFile inTwo=【代码2】//创建指向文件file的inTwo的对象
showCharacters.setBackground(Color.green);
getCharacters=new Button("下一个汉字");
voiceCharacters=new Button("发音");
voiceThread=new Thread(this);
choice.addItemListener(this);
}
try{ voiceThread.start();
}
catch(Exception exp){}
}
if(e.getSource()==help)
{ mycard.show(pCenter,"help") ;
try{ File helpFile=new File("help.txt");
FileReader inOne=【代码4】//创建指向文件helpFile的inOne的对象
（4）程序修改补充完整后的运行结果如下：
（1）模板代码
//WordStatistic.java
import java.io.*;
import java.util.Vector;
public class WordStatistic
{ Vector allWorsd,noSameWord;
WordStatistic()
【代码4】// inTwo调用seek方法将读写位置移动到wordStarPostion
byte cc[]=new byte[(int)wordEndPostion-(int)wordStarPostion];
【代码5】// inTwo调用readFully(byte a)方法，向a传递cc
k=0;
showCharacters.setText(""+c);
}
else
{ showCharacters.setText("请选择一个汉字字符文件");
}
}
if(e.getSource()==voiceCharacters)
{ if(!(voiceThread.isAlive()))
{ voiceThread=new Thread(this);
int k=0;
Panel pCenter;
CardLayout mycard;
TextArea textHelp;
MenuBar menubar;
Menu menu;
MenuItem help;
public StudyFrame()
{ chinese=new ChineseCharacters();
三、实验内容与步骤
1学读汉字
2统计英文单词字
3请按模板要求，将【代码】替换为Java程序代码。
四、实验过程与分析
1学读汉字
（1）实验模板：
//ChineseCharacters.java
import java.io.*;
import java.util.StringTokenizer;
public class ChineseCharacters
String s=null;
int i=0;
while((s=【代码3】)!=null) //inTwo读取一行
{ StringTokenizer tokenizer=new StringTokenizer(s," ,'\n' ");
while(tokenizer.hasMoreTokens())
{ hanzi.append(tokenizer.nextToken());
甘肃政法学院
本科生实验报告
（Java输入/输出流）
甘肃政法学院实验管理中心印制
实验题目
Java输入/输出流
小组合作
姓名
班级
学号
一、实验目的
1、掌握java常用输入、输出流类及其各自方法。
2、能够灵活使用java常用输入、输出流类及其各自方法解决实际应用问题。
二．实验环境
计算机Eclipse SDK编程软件
}
public void actionPerformed(ActionEvent e)
{ if(e.getSource()==getCharacters)
{ if(trainedChinese!=null)
{ char c=trainedChinese.charAt(k);
k++;
if(k>=trainedChinese.length())
}
}
}
catch(Exception e) {}
return hanzi;
}
}
//StudyFrame.java
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.sound.sampled.*;
public class StudyFrame extends Frame implements ItemListener,ActionListener,Runnable
}
catch(IOException exp){}
}
}
public void run()
{ voiceCharacters.setEnabled(false);
try{ if(clip!=null)
{ clip.close()
}
clip=AudioSystem.getClip();
File voiceFile=new File(showCharacters.getText().trim()+".wav");
{ public StringBuffer getChinesecharacters(File file)
{ StringBuffer hanzi=new StringBuffer();
try{ FileReader inOne=【代码1】//创建指向文件f的inOne的对象
BufferedReader inTwo=【代码2】//创建指向文件inOne的inTwo的对象
voiceCharacters.addActionListener(this);
getCharacters.addActionListener(this);
Panel pNorth=new Panel();
pNorth.add(new Label("选择一个汉字字符组成的文件"));
pNorth.add(choice);
{ public static void main(String args[])
{ new StudyFrame();
}
}
（2）知识点的理解与程序解读
Java语言的输入输出功能是十分强大而灵活的，美中不足的是看上去输入输出的代码并不是很简洁，因为你往往需要包装许多不同的对象。在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流
java输入输出流实验报告总结
java输入输出流实验报告总结Java输入输出流是Java中非常重要的概念，也是Java程序设计的基础。
在Java 程序中，输入输出流用于处理与设备之间的数据传输，例如键盘、鼠标、文件等。
Java的输入输出流主要包含两种类型：字节流和字符流。
字节流以字节为最小读写单位，而字符流以字符为最小读写单位。
Java的输入流有很多种类型，例如：InputStream、ByteArrayInputStream、FileInputStream等。
这些输入流的共同特点是读取外部数据到程序中。
Java的输出流也有多种类型，例如：OutputStream、ByteArrayOutputStream、FileOutputStream等。
这些输出流的共同特点是将程序中的数据输出到外部。
下面将以实验报告的形式进行总结，详细介绍Java输入输出流的原理和使用方法。
实验一：字节流输入输出1. 实验目的：掌握字节流输入输出的基本使用方法。
2. 实验内容：编写一个程序，实现从文件中读取数据，然后将数据输出到另一个文件中。
3. 实验步骤：a. 创建一个输入流对象，用于读取原始文件的数据。
b. 创建一个输出流对象，用于将读取到的数据输出到目标文件中。
c. 循环读取输入流中的数据，直到读取到文件末尾。
d. 将读取到的数据写入输出流中。
e. 关闭输入流和输出流。
4. 实验结果：成功读取原始文件中的数据，并将数据输出到目标文件中。
实验二：字符流输入输出1. 实验目的：掌握字符流输入输出的基本使用方法。
2. 实验内容：编写一个程序，实现从键盘输入文字，然后将文字输出到屏幕上。
3. 实验步骤：a. 创建一个字符输入流对象，用于读取键盘输入的文字。
b. 创建一个字符输出流对象，用于将读取到的文字输出到屏幕上。
c. 循环读取输入流中的文字，直到读取到换行符。
d. 将读取到的文字写入输出流中。
e. 关闭输入流和输出流。
4. 实验结果：成功从键盘输入文字，并将文字输出到屏幕上。
（JAVA）从零开始之--对象输入输出流ObjectInputStream、ObjectO。。。
（JAVA）从零开始之--对象输⼊输出流ObjectInputStream、ObjectO。
对象的输⼊输出流 : 主要的作⽤是⽤于写⼊对象信息与读取对象信息。
对象信息⼀旦写到⽂件上那么对象的信息就可以做到持久化了 对象的输出流： ObjectOutputStream 对象的输⼊流: ObjectInputStream使⽤：对象的输出流将指定的对象写⼊到⽂件的过程，就是将对象序列化的过程，对象的输⼊流将指定序列化好的⽂件读出来的过程，就是对象反序列化的过程。
既然对象的输出流将对象写⼊到⽂件中称之为对象的序列化，那么可想⽽知对象所对应的class必须要实现Serializable接⼝。
（查看源码可得知：Serializable接⼝没有任何的⽅法，只是作为⼀个标识接⼝存在）。
1、将User类的对象序列化1class User implements Serializable{//必须实现Serializable接⼝2 String uid;3 String pwd;4public User(String _uid,String _pwd){5this.uid = _uid;6this.pwd = _pwd;7 }8 @Override9public String toString() {10return "账号:"+this.uid+" 密码:"+this.pwd;11 }12 }1314public class Demo1 {1516public static void main(String[] args) throws IOException {17//假设将对象信息写⼊到obj.txt⽂件中，事先已经在硬盘中建⽴了⼀个obj.txt⽂件18 File f = new File("F:\\obj.txt");19 writeObjec(f);20 System.out.println("OK");21 }2223//定义⽅法把对象的信息写到硬盘上------>对象的序列化。
输入输出流
输入输出流的相关简介系别：计算机技术与信息管理系班级：09软件技术姓名：徐燕学号：09207745目录一．Java输入输出流详解 (3)1.什么是流： (3)2、流的分类 (3)2.1字节流 (3)2.2．字符流 (4)2.3．对象流 (4)4．字节流与字符流的区别： (4)二．流的层次结构 (5)1．InputStream类 (6)2．OutputStream类 (7)3．FileInputStream类 (7)4．FileOutputStream类 (8)5．File类 (8)6．从一个流构造另一个流 (9)7.BufferInputStream和bufferOutputStream (10)8.printstream (11)三．字符流的读取和写入 (11)1.BufferInputStream和bufferOutputStream (14)2.printstream (15)四．java的i/o输入输出类怎么分出是输入流还是输出流？ (15)五．java中什么时候用输入流,什么时候用输出流? (16)六．JA V A输出输入流函数注意事项 (16)1. 处理概述： (17)2. 字节流： (17)2.1输入流： (17)2.2输出流： (18)3、字符流: (18)3.1. 字符流处理概述 (18)3.2. 字符流处理 (19)3.3流处理中的其它方法： (20)七.总结 (21)一．Java输入输出流详解stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。
在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型：1.什么是流：流是一个抽象的概念。
当Java程序需要从数据源读取数据时，会开启一个到数据源的流。
数据源可以是文件，内存或者网络等。
同样，当程序需要输出数据到目的地时也一样会开启一个流，数据目的地也可以是文件、内存或者网络等。
基于Java文件输入输出流实现文件上传下载功能
基于Java⽂件输⼊输出流实现⽂件上传下载功能本⽂为⼤家分享了Java实现⽂件上传下载功能的具体代码，供⼤家参考，具体内容如下前端通过form表单的enctype属性，将数据传递⽅式修改为⼆进制”流“的形式，服务端（servlet）通过 getInputStream() 获取流信息，运⽤java I/O 流的基础操作将流写⼊到⼀个服务端临时创建的⽂件temp中，然后再次利⽤⽂件基本操作，读取并截取临时⽂件内容，根据其中信息创建相应的⽂件，将读取出来的具体信息写⼊，下载时，根据提交的⽂件名称，找到服务器端相应的⽂件，然后根据输出流outStream输出到页⾯，同时将servlet的响应类型和响应头进⾏设置。
具体传输流程如下图：流信息的部分为：具体代码如下：前端代码：<html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><title>Insert title here</title><script src="Js/jquery.js"></script></head><body><form action="FileUpServlet" method="post" enctype="multipart/form-data"><table><tr><td>请选择上传⽂件:</td><td><input id="myfile" name="myfile" type="file" value="" /></td><td><input type="submit" value="上传"></td></tr><tr><td>${info}</td></tr></table></form>⽂件下载：<a href="FileLoadownServlet?filename=${filename}">${filename}</a></body></html>上传servlet部分（核⼼）@WebServlet("/FileUpServlet")public class FileUpServlet extends HttpServlet {private static final long serialVersionUID = 1L;/*** @see HttpServlet#HttpServlet()*/public FileUpServlet() {super();// TODO Auto-generated constructor stub}/*** @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)*/protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // TODO Auto-generated method stubdoPost(request, response);}/*** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)*/protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // TODO Auto-generated method stubrequest.setCharacterEncoding("utf-8");InputStream filesource = request.getInputStream();//request获取流信息String tempname = "D:/temp";//tempfile代表临时存放⽂件File tempfile = new File(tempname);//创建临时⽂件FileOutputStream outputStream = new FileOutputStream(tempfile);//输出流对象，指定输出指tempfile⽬录下byte b[] = new byte[1024];int n;while((n = filesource.read(b))!= -1)//从输出流中每次读取1024字节,直⾄读完{outputStream.write(b,0,n);}outputStream.close();filesource.close();//关闭输⼊输出流/*以下为具体的⽂件操作，主要为解析临时产⽣的 temp⽂件，知识多为java输⼊输出流的内容！*/RandomAccessFile randomfile = new RandomAccessFile(tempfile, "r");//随机流，指定要读临时⽂件，只读randomfile.readLine();//读取第⼀⾏,⽆效数据，不需要String str = randomfile.readLine();//读取第⼆⾏int beginIndex = stIndexOf("=")+2;//指定所需数据的开始位置int endIndex = stIndexOf("\"");//指定所需数据截⾄位置String filename = str.substring(beginIndex,endIndex);//截取⽂件名//重新定位⽂件指针，获取⽂件内容randomfile.seek(0);//⽂件指针从头开始long startext = 0;int i = 1;//⽂件内容开始位置while((n=randomfile.readByte()) != -1&&i <= 4){if(n=='\n'){startext = randomfile.getFilePointer();i++;}}startext = randomfile.getFilePointer() - 1;//获取⽂件内容结束位置randomfile.seek(randomfile.length());long endtext = randomfile.getFilePointer();int j = 1;while(endtext >= 0 && j <= 2){endtext--;randomfile.seek(endtext);if(randomfile.readByte()=='\n'){j++;}}endtext = endtext-1;//将临时⽂件保存⾄指定⽬录中String realpath = getServletContext().getRealPath("/")+"images";//设置⽂件保存⽬录System.out.println(realpath);File fileupload = new File(realpath);if(!fileupload.exists()){fileupload.mkdir();//⽬录不存在则创建}File savefile = new File(realpath,filename);RandomAccessFile randomAccessFile = new RandomAccessFile(savefile, "rw");randomfile.seek(startext);while(startext<endtext){randomAccessFile.write(randomfile.readByte());//⽂件写⼊startext = randomfile.getFilePointer();}//关闭各种输⼊输出流randomAccessFile.close();randomfile.close();tempfile.delete();//删除临时⽂件SimpleDateFormat timed = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date nowdate = new Date();String time = timed.format(nowdate.getTime());request.setAttribute("info", time+" "+filename+"上传成功！");request.setAttribute("filename", filename);request.getRequestDispatcher("/fildeOp.jsp").forward(request, response);}}下载部分protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // TODO Auto-generated method stubString filename = request.getParameter("filename");String path = getServletContext().getRealPath("/")+"images/";File file = new File(path+filename);//找到⽂件if(file.exists())response.setContentType("application/x-msdownload"); //设置响应类型,此处为下载类型response.setHeader("Content-Disposition", "attachment;filename=\""+filename+"\"");//以附件的形式打开 InputStream inputStream = new FileInputStream(file);ServletOutputStream outputStream = response.getOutputStream();byte b[] = new byte[1024];int n;while((n = inputStream.read(b)) != -1){outputStream.write(b,0,n);}outputStream.close();inputStream.close();}else{request.setAttribute("result", "⽂件不存在！下载失败！");request.getRequestDispatcher("/fildeOp.jsp").forward(request, response);}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
Java自学第10期——File类与IO流（输入输出流、处理流、转换流、缓冲流、Prope。。。
Java⾃学第10期——File类与IO流（输⼊输出流、处理流、转换流、缓冲流、Prope。
1、IO简介IO（输⼊输出）通过java.io包下的类和接⼝来⽀持，包下包括输⼊、输出两种IO流，每种输⼊输出流⼜可分为字符流和字节流两⼤类。
2、File类File类是io包下与平台⽆关的⽂件和⽬录，File能新建、删除、重命名⽂件和⽬录，不能访问⽂件本⾝，后者需要使⽤输⼊输⼊流。
2.1 构造⽅法File类的构造⽅法：File(File parent, String child) 参数：⽗路径，⼦路径根据 parent 抽象路径名和 child 路径名字符串创建⼀个新 File 实例。
File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建⼀个新 File 实例。
File(String parent, String child)根据 parent 路径名字符串和 child 路径名字符串创建⼀个新 File 实例。
File(URI uri)通过将给定的 file: URI 转换为⼀个抽象路径名来创建⼀个新的 File 实例。
2.2 静态⽅法File类静态⽅法：static String pathSeparator()与系统有关的路径分隔符，为了⽅便，它被表⽰为⼀个字符串。
static char pathSeparatorChar()与系统有关的路径分隔符。
static String separator()与系统有关的默认名称分隔符，为了⽅便，它被表⽰为⼀个字符串。
static char separatorChar()与系统有关的默认名称分隔符。
2.3 常⽤⽅法：2.3.1 获取相关public String getAbsolutePath()返回此File的绝对路径名字符串。
public String getPath()将此File转换为路径名字符串。
public String getName()返回由此File表⽰的⽂件或⽬录的名称。
JAva第 6 章 Java的输入输出.ppt
2020/8/16
2020/8/16
Java面向对象程序设计教程
9
输入输出类的分类
文件I/O ：FileInputStream 内存缓冲区I/O ：BufferedInputStream 存取I/O ：DataInputStream 管道I/O ：PipedInputStream 过滤器I/O ：FilterInputStream
2020/8/16
Java面向对象程序设计教程
10
标准流及其重定向
System.out是标准的输出流，默认情况下， 它是一个控制台。
System.in是标准输入流，默认情况下， 它指的是键盘。
System.err指的是标准错误流，它默认是 控制台。
这些流可以重定向到任何兼容的输入/输出 设备。
6.3 数据持久化
• 6.3.1 对象串行化 • 6.3.2 XML文件的输入输出 • 6.3.3 JDBC入门
6.4 文件类的应用
• 6.4.1 File类 • 6.4.2 File类应用举例
2020/8/16
Java面向对象程序设计教程
2
6.1 流输入/输出类的层次结构
流的概念
流（Stream）是有序的数据序列，它有源（输入流）与 目的（输出流）。
举例：RedirectSample.java
2020/8/16
Java面向对象程序设计教程
11
IOException及其子类
在java.io中，每一个特定的I/O错误都是 用异常IOException及其子类来报告的。
最常见的I/O异常有 FileNotFoundException、 EOFException、 InterruptedIOException、 UTFDataFormatError等。
java 标准输入输出流
java 标准输入输出流
计算机系统都有标准的输入设备和标准输出设备。
对一般系统而言，标准输入设备通常是键盘，而标准输出设备是屏幕。
Java程序经常需要从键盘上输入数据，从屏幕上输出数据，为此频繁创建输入/输出流对象将很不方便。
因此，Java语言事先定义好了两个对象，分别对系统的标准输入和标准输出相联系，如System.in和System.out，另外还定义了标准的System.err错误输出流。
System.in是标准输入流，是InputStream类的实例。
可以使用read()方法从键盘上读取字节，也可以将它包装成数据流读取各种类型的数据和字符串。
在使用System.in的read()方法时，由于read()方法在定义时抛出了IOException 异常，所以必须使用try-catch结构捕获异常或声明抛出异常；
System.out和System.err是标准输出流和标准错误输出流，是PrintStream类的实例。
如果从标准输入流键盘上输入基本数据类型，可以将标准输入流包装成具有缓
执行上述代码，结果如图12-12所示。
图12-12 System.in 标准输入流。
输入输出流
public class Files
{
public static void main(String[] args) throws IOException
{
Files f = new Files();
// System.out.println(f.readFile("f:\\LinkFile.java"));
}
}
}
/**
* 检查文件中是否为一个空
* @param filePath
* @param fileName
* @return 为空返回true
* @throws IOException
*/
public boolean fileIsNull(String filePath,String fileName) throws IOException
for(int i=0;i<ss.length;i++)
{
ss[i] = "信息技术和互联网(计算机软硬件,通讯) "+i;
}
f.writeFile("f:\\ss\\","TestFile.txt",ss);
}
/**
* 文件的写入
* @param filePath(文件路径)
/**
* @author zhangqinglin
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code and Comments
JAVA输入输出流
int read() int read(byte[] buffer) int read(byte[] buffer, int offset, int length)
其它方法:
void close() int available() skip(long n) boolean markSupported() void mark(int readlimit) void reset()
9.4常用输入输出流类(2)
FileReader-文件字符输入流
构造方法: public FileReader(String name) throws FileNotFoundException public FileReader(File file) throws FileNotFoundException
方法:参见InputStream FileOutputStream-文件字节输出流
构造方法: public FileOutputStream(String name) throws FileNotFoundException public FileOutputStream(File file) throws FileNotFoundException 方法:参见OutputStream
//标准输出流System.out是字节输出流
//把标准输出流转化成缓冲字节输出流 /用BufferedOutputStream中函数Write输出 //数据从缓冲区中全部输出
import java.io.*; public class Test3 { public static void main(String[] args) throws IOException{ String s = "Hello"; OutputStreamWriter o = new OutputStreamWriter(System.out); o.write(s); 把标准字节输出流转化 成字符输出流 o.flush(); } }
java08(第8章输入输出流)
在java.io包中定义了很多这二个基本类具体实现 包中定义了很多这二个基本类具体实现 输入输出功能的子类， 输入输出功能的子类，表8.1为部分常用字节输入 为部分常用字节输入 流类和字节输出流子类的功能。 流类和字节输出流子类的功能。
表8.1
类 名 FileInputStream 和 FileOutputStream ByteArrayInputStream和 ByteArrayOutputStream ObjectInputStream 和 ObjectOutputStream FilterInputStream 和 FilterOutputStream DataInputStream 和 DataOutputStream BufferedInputStream 和 BufferedOutputStream
【例8-1 】
1. /* 读取文件 */ 2. import java.io.FileInputStream; 3. import javax.swing.JOptionPane; 4. class Example8_1 5. { public static void main( String args[ ]) 6. { byte buffer[ ] = new byte[2056]; 7. String str; 8. try{ 9. File file=new File("d:/jtest/test.dat"); 10. FileInputStream fileInput = new FileInputStream(file); 11. int bytes = fileInput.read( buffer, 0, 2056 ); //读到的字节数 读到的字节数 12. str = new String( buffer, 0, bytes ); 13. } 14. catch(Exception e) 15. { 16. str= e.toString(); 17. } 18. JOptionPane.showMessageDialog(null,str); 19. System.exit(0); //退出程序 退出程序 20. } 21. }