java文件流介绍
Input / Output:指跨越出JVM的边界,与外界数据的源头或者目标数据源进行数据交换.
输出Output
------------------------------->
JVM 数据源
<-------------------------------
输入Input
注意：输入/输出是针对JVM 而言。
File 类
可表示一个文件，也有可能是一个目录(在JA V A中文件和目录都属于这个类中，而且区分不是非常的明显，可以调用isDirectory()和isFile()来判断)。
File file = new File("c:\\abc.txt");
常用的方法：
exists() 用来判断文件或目录是否在硬盘存在。
isDirectory() 判断是否是目录
isFile() 判断是否是文件
mkdir() 创建目录
mkdirs() 创建目录包括它下面的子目录。
getAbsolutePath() 得到文件绝对路径
list() 得到文件名的String数组(得到当前目录下的文件名，目录名)
listFiles() 返回File类型数组，(目录,文件的File对象)可用getName()得到文件名。
delete() 删除文件
getName() 得到文件名
getPath() 得到文件相对路径
separtor() 得到文件分隔符//这个方法有更好的通用性,平台不同结果不同
deleteOnExit() 在进程退出的时候删除文件,常用在临时文件的删除。
1、流的概念：
输出流
程序----------->文件、网络
程序<-----------数据来源
输入流
2、流的分类：
按处理方式来分：
字节流：按8位传输InputStream OutputStream
字符流：按16位传输Reader Writer
按功能来分：
节点流：与文件、网络打交道的流，操作数据的来源
处理流(包装流)：操作节点流
如何区分：
输入流：以InputStream、Reader结尾的流
FileInputStream BufferedReader
输出流：以OutputStream、Writer结尾的流
FileOutputStream PrintWriter
字节流：以InputStream、OutputStream结尾的流
字符流：以Reader、Writer结尾的流
节点流：看构造器，参数为数据来源，参数是String或File之类的
new FileInputStream("d:\\abc.txt");
new FileOutputStream(new File("d:\\abc.txt"))
处理流：构造器的参数为其它流
new BufferedReader(new InputStreamReader(new FileInputStream("d:\\abc.txt")));
PrintWriter
选择流时：
首先确定是输入还是输出。
其次确定是字节流还是字符流。
然后确定是节点流还是处理流。
根据数据类型选择输入/输出流：
①byte、byte[] InputStream / OutputStream
②int、byte、char、double、String DataInputStream / DataOutputStream
③char、String Reader / Writer
④Object ObjectInputStream / ObjectOutputStream
若考虑性能会在前试着加Buffered
3、常用流：
DataInputStream&DataOutputStream 用于读写基本类型数据，如int、float、long、double 和boolean等。
此外，DataInputStream的readUTF()方法还能读取采用UTF-8字符编码的字符串。
BufferedInputStream&BufferedOutputStream
因为利用了缓冲区，所以常用于提高读写数据的效率。
BufferedInputStream先把一批数据读入到缓冲区，接下来read方法只需要从缓冲区内获得数据，减少了物理性读取数据的次数。
可以使用BufferedInputStream(InputStream in, int size) 中的size来指定缓冲区的大小
ObjectOutputStream&ObjectInputStream
对象的序列化是指把对象写到一个输出流中，
对象的反序列化是指从一个输入流中读取一个对象。
Java语言要求只有实现了java.io.Serializable接口的类的对象才能序列化和反序列化
Reader/Writer
当需要程序读写文本文件，而且文本文件采用特定的字符编码集时，应采用Reader/Writer。
InputStreamReader & OutputStreamWriter 桥梁流
把字节流转换成字符流
在桥转换的时候可以指定编解码方式
new BufferedReader(new InputStreamReader(new FileInputStream("d:\\abc.txt"), "utf8"));
BufferedReader
readLine()方法可以一次读入一行字符，以字符串形式返回。
PrintWriter 输出格式化的数据，所有的写数据的方法以print开头。
print (int i)
print (long l)
print (float f)
print (String s)
每个print() 方法都有一个println()方法对应
a.
printWriter.println("Hello");
b.
printWriter.print("Hello");
printWriter.println();
c.
printWriter.print("Hello\n");
以上三段代码是等价的
4、JA V A编码问题：UTF-8,GBK，GB2312是可以显示中文的。
ASCII 一个字符-----1B 任何一种编码均兼容A<-->65
ISO8859-1 (西欧) 一个字符-----1B
GB2312 / GBK 一个字符-----2B
Unicode 一个字符-----2B 会增加网络负担Java中的char是Unicode
UTF-8 变长字节(变长的Unicode方式)
英文-----1B
中文-----3B
提供编码帮助的类：java.nio.charset.Charset
GBK---中、日、韩，gb2312是GBK的子集
会出现中文编码问题的情况：
1、用流操作文件时
2、网页(动态、静态)
3、网络传递信息时
String--->乱码(再次转码)
String temp=p.getProperty("name");
temp=new String(temp.getBytes("ISO8859-1"),"GBK");这两处的编码有时需要互换位置
对象序列化
1：定义：把对象作为一个整体，在I/O流中传播
2：语法：
(１)实现了Serializeble接口的对象才能可序列化。这个接口里没有任何方法，没有方法的接口称为标记接口。
例如：class Student implements Serializeble{}
(２)如果一个序列化后的对象里面有一个属性是个对象属性，那么这个对象属性也需要实现序列化。
例如：class Student implements Serializeble{
Teacher t;//必须序列化
}
class Teacher implements Serializeble{}
(3)包名、类名、属性可以被序列化
方法、构造器不会序列化
所有的静态属性都不会被序列化
用transient关键字修饰的属性是临时属性，临时属性不参与序列化。
(4)当父类实现Serializeble接口，子类自动实现。对象序列化会创建对象，不调用构造，但子类实现Serializeble接口，
父类没有实现实现Serializeble接口，父类在反序列化时会调用构造。
3：使用注意：
a.用readObject读文件的时候，当文件结束的时候会抛出EOFException，当我们捕获这个异常的时候，程序就结束了。
Object o = null;
while((o =ois.readObject()) != null) {
}
b.如果需要向一个文件中追加对象，首先要把文件中原有的对象读出来，再把原有对象和新追加的对象一起写入到文件。
c. serialVersionUID是静态常量，表示当前对象的版本号，在接受传输的数据时会自动检查该值，保证版本的相同。
java.util.Properties属性类，针对属性文件操作，早期使用。
好处是可以在不修改代码的情况下改变相应的需求。
文件名以.properties结尾的文件称为属性文件
文件的内容是：名字=值的形式
常用方法：
public void load(InputStream inStream)throws IOException
public void store(OutputStream out,String comments)throws IOException public String getProperty(String key)
public String getProperty(String key,String defaultValue)
public Object setProperty(String key,String value)
java文件流操作
java 文件流操作 2010-05-08 20:17:23| 分类：java SE | 标签：|字号大中小订阅 java中多种方式读文件 一、多种方式读文件内容。 1、按字节读取文件内容InputStream 读取的是字节 2、按字符读取文件内容InputStreamReader 读取的是字符 3、按行读取文件内容BufferredReader 可以读取行 4、随机读取文件内容 import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.RandomAccessFile; import java.io.Reader; public class ReadFromFile { /** * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。* @param fileName 文件的名 */ public static void readFileByBytes(String fileName){ File file = new File(fileName); InputStream in = null; try { System.out.println("以字节为单位读取文件内容，一次读一个字节："); // 一次读一个字节 in = new FileInputStream(file); int tempbyte; while((tempbyte=in.read()) != -1){ System.out.write(tempbyte); } in.close(); } catch (IOException e) { e.printStackTrace(); return; } try { System.out.println("以字节为单位读取文件内容，一次读多个字节："); //一次读多个字节
实验9 Java输入输出流
山西大学计算机与信息技术学院 实验报告 姓名学号专业班级 课程名称 Java实验实验日期2013-12-4 成绩指导教师批改日期实验名称实验9 Java的输入输出流 ●实验目的 1. 理解I/O流的概念，掌握其分类 2. 掌握文本文件读写、二进制文件读写 ●实验内容 1. 分别使用FileWriter 和BufferedWriter 往文件中写入1万个随机数，比较用时的多少？(用时采用方法System.currentTimeMillis()）求时间差; 使用：FileWriter 程序源代码 package a; import java.io.*; public class Filewriter { public Filewriter(String string){ } public static void main(String[] args)throws IOException { long time =System.currentTimeMillis(); Filewriter filewriter=new Filewriter("text"); int num; for(int i=0;i<=10000;i++){ num=(int)Math.random()*10000; filewriter.write(num+" "); } filewriter.close(); time=System.currentTimeMillis()-time; System.out.println("使用Filewriter所用时间："+time+"um"); } private void write(String string){ } private void close(){ } }
JAVA输入输出流--字节流篇(什么时候用哪个)
1流的概念 stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样，如下图： 在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型： (1)字节流 表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据，如图象和声音。 (2)字符流 以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。 区别： Reader和Writer要解决的，最主要的问题就是国际化。原先的I/O类库只支持8位的字节流，因此不可能很好地处理16位的Unicode字符流。Unicode是国际化的字符集(更何况Java内置的char就是16位的Unicode 字符)，这样加了Reader和Writer之后，所有的I/O就都支持Unicode了。此外新类库的性能也比旧的好。 但是，Read和Write并不是取代InputStream和OutputStream，有时，你还必须同时使用"基于byte的类"和"基于字符的类"。为此，它还提供了两个"适配器(adapter)"类。InputStreamReader负责将InputStream转化成Reader，而OutputStreamWriter则将OutputStream转化成Writer。实际上是通过byte[]和String来关联。在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的。 以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，只是在操作时的导向不同。
Java 输入输出流及文件读写详解
I/O类体系 在JDK API中，基础的IO类都位于java.io包，而新实现的IO类则位于一系列以java.nio开头的包名中，这里首先介绍java.io包中类的体系结构。 按照前面的说明，流是有方向的，则整个流的结构按照流的方向可以划分为两类： 1、输入流： 该类流将外部数据源的数据转换为流，程序通过读取该类流中的数据，完成对于外部数据源中数据的读入。 2、输出流： 该类流完成将流中的数据转换到对应的数据源中，程序通过向该类流中写入数据，完成将数据写入到对应的外部数据源中。 而在实际实现时，由于JDK API历史的原因，在java.io包中又实现了两类流：字节流(byte stream)和字符流(char stream)。这两种流实现的是流中数据序列的单位，在字节流中，数据序列以byte为单位，也就是流中的数据按照一个byte一个byte的顺序实现成流，对于该类流操作的基本单位是一个byte，而对于字节流，数据序列以char为单位，也就是流中的数据按照一个char一个插入的顺序实现成流，对于该类流操作的基本单位是一个char。 另外字节流是从JDK1.0开始加入到API中的，而字符流则是从JDK1.1开始才加入到API中的，对于现在使用的JDK版本来说，这两类流都包含在API的内部。在实际使用时，字符流的效率要比字节流高一些。 在实际使用时，字符流中的类基本上和字节流中的类对应，所以在开始学习IO类时，可以从最基础的字节流开始学习。 在SUN设计JDK的IO类时，按照以上的分类，为每个系列的类设计了一个父类，而实现具体操作的类都作为该系列类的子类，则IO类设计时的四个体系中每个体系中对应的父类分别是： 字节输入流InputStream 该类是IO编程中所有字节输入流的父类，熟悉该类的使用将对使用字节输入流产生很大的帮助，下面做一下详细的介绍。 按照前面介绍的流的概念，字节输入流完成的是按照字节形式构造读取数据的输入流的结构，每个该类的对象就是一个实际的输入流，在构造时由API完成将外部数据源转换为流对象的操作，这种转换对程序员来说是透明的。在程序使用时，程序员只需要读取该流对象，就可以完成对于外部数据的读取了。
实验04 Java输入输出流报告
实验四 Java 输入输出流 1．实验目的 (1) 掌握输入输出流的总体结构； (2) 掌握流的概念； (3) 了解各种流（包括文件流、过滤流、对象的序列化、随机访问）的使用。2．实验内容 实验题1 编写一个Java Application程序，打印命令行输入的所有参数。 [基本要求] 编写完整程序。 运行结果： 代码如下： import java.util.Scanner; public class CommandOutPut { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub System.out.println("Please input ："); Scanner in = new Scanner(System.in);
String str = in.nextLine(); System.out.println("The output results ："); System.out.println(str); in.close(); } } 实验题2 通过键盘输入路径，搜索指定路径下的全部内容。 运行结果： 代码如下： package https://www.360docs.net/doc/7313869303.html,.output; import java.io.File; import java.io.FileInputStream; import java.io.IOException; public class Output { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub String fileName = "d:\\xxx.txt"; File file = new File(fileName); byte[] b=new byte[(int)file.length()]; FileInputStream out=new FileInputStream(file);
Java多线程和输入输出流
班级：13科技2班学号：201324131225 姓名：许耿宁 Java多线程和输入输出流 一、实验目的： 1.熟悉利用Thread类建立多线程方法。 2.熟悉利用Thread接口建立多线程方法。 3.熟悉Java的文件读写机制，练习输入输出流的使用。 二、实验内容： 1.阅读下列程序，分析并上机检验其功能。 public class DelayRunnable implements Runnable{ private static int count=0; private int no; private int delay; public DelayRunnable(){ count++; no=count; } public void run(){ try{ for (int i=0;i<10;i++){ delay=(int)(Math.random()*5000); Thread.sleep(delay); System.out.println("Thread "+no+" with a delay "+delay); } }catch(InterruptedException e){} } } class MyRunnable{ public static void main(String args[]){ DelayRunnable r1 = new DelayRunnable();
DelayRunnable r2 = new DelayRunnable(); Thread thread1=new Thread(r1); Thread thread2=new Thread(r2); thread1.start(); thread2.start(); try{ Thread.sleep(1000); }catch(InterruptedException e){ System.out.println("Thread wrong"); } } } 2.将上列程序利用Runnable接口改写，并上机检验。 3.创建简单的程序ThreeThread.java，该程序将创建三个线程，每个线程应当显示它所运行的时间（可以考虑使用Date类或Calendar类）。 4.键盘输入10个整数，从小到大进行排序。 5.接收键盘输入的字符串，用FileInputStream类将字符串写入文件，用 FileOutputStream类读出文件内容显示在屏幕上。 6.将一个文本文件的内容按行读出，每读出一行就顺序加上行号，并写入到另一个文件中。 三、实验要求： 1.通过实验掌握Thread 、Runnable使用方法； 2.程序必须能够实现多线程； 3.程序必须能够完成题目要求； 4.通过实验掌握文件输入输出流的使用方法； 5.程序必须能够从键盘接收字符串并保存在文件中； 6.程序必须能够读出文件内容显示在屏幕上； 7.写出实验报告。 四、实验代码及截图： 第一题： 在编译器上运行程序得到截图所示结果：
java File文件操作和文件流的详解(福哥出品)
一. 创建文件 （1）最常用的（获得一个固定路径下的文件对象） File parentFile = new File(“D:\\My Documents\\.....”);//参数是一个路径的字符串。 （2）在父目录创建一个名为child的文件对象，child 为文件对象的名字 File chileFile= new File(“D:\\My Documents\\.....”,String child); 或File chileFile= new File(parentFile,String child); 二,常见文件夹属性和方法 （1）createNewFile（）； 该方法的作用是创建指定的文件。该方法只能用于创建文件，不能用于创建文 件夹，且文件路径中包含的文件夹必须存在 File file=new ("D:\\My Document\\text.txt"); file.createNewFile(); 这样就会在D盘下的My Document 创建text.txt的记事本（注意：首先得保 证D盘下有My Documen这个文件夹） （2）mkdir(); 根据File对象的名字(路径)创建一个目录(文件夹)，如果是相对目录，则新建的目
录在当前目录下 （3）mkdirs(); 如果File对象名字有多级目录，则可以调用该方法一次性创建多级目录。 （4）exists(); 判断File对象指向的文件是否存在，返回一个boolean类型（5）isDirectory（）； 判断File对象指向的文件是否为目录，返回一个boolean类型的值，true或者false。 （6）getName();获得文件名称（不带路径） （7）length（）； 得到File对象指向文件的长度，以字节计算，返回一个长整形的值(long);注意：在 系统中，文件夹(目录)的大小为零，也就是不占用空间，使用length()时返回的是0 （8）delete（）; 删除File对象所指定的文件 （9）isFile（）； 判断File对象指向的文件是不是标准文件（就像图片，音乐文件等） 三,文件的属性和方法 1.File.separator 当前操作系统的名称分隔符，等于字符串“\”.
实验9 Java输入输出流
▇▆大学计算机与信息技术学院 实验报告 姓名□□□学号▅▅▅▅专业班级▅▅ 课程名称 Java实验实验日期???? 成绩指导教师▇▇██批改日期实验名称实验9 Java的输入输出流 ●实验目的 1. 理解I/O流的概念，掌握其分类 2. 掌握文本文件读写、二进制文件读写 ●实验内容 1. 分别使用FileWriter 和BufferedWriter 往文件中写入1万个随机数，比较用时的多少？(用时采用方法System.currentTimeMillis()）求时间差; 使用：FileWriter 程序源代码 import java.io.*; public class TestFileWriter { public static void main(String []args) throws IOException{ File f = new File("C:/java/tem.txt"); if (f.exists()){ System.out.printf("文件\"C:/java/tem.txt\"已存在"); System.exit(0); } FileWriter fileWriter = new FileWriter(f); long time = System.currentTimeMillis(); for(int i=0;i<10000;i++) fileWriter.write((int)(Math.random()*101)); fileWriter.close(); time = System.currentTimeMillis() - time; System.out.printf("使用FileWriter耗时："+time+"毫秒"); } } 程序运行结果贴图 使用：BufferedWriter 程序源代码 import java.io.*; public class TestBufferedWriter { public static void main(String []args) throws IOException{ File f = new File("C:/java/tem2.txt");
java输入输出流和文件操作
Java IO流和文件操作Java流操作有关的类或接口： Java流类图结构：
1、File类 File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。 构造方法摘要 File(File parent, String child) File(String pathname) File(String parent, String child) 构造函数 创建方法 1.boolean createNewFile() 不存在返回true 存在返回false 2.boolean mkdir() 创建目录 3.boolean mkdirs() 创建多级目录 删除方法 1.boolean delete() 2.boolean deleteOnExit() 文件使用完成后删除 例子1：列出指定文件夹的文件或文件夹 public class FileDemo1 { public static void main(String[] args){ File[] files =File.listRoots(); for(File file:files){
System.out.println(file); if(file.length()>0){ String[] filenames =file.list(); for(String filename:filenames){ System.out.println(filename); } } } } } 例子2：文件过滤 import java.io.File; public class FileTest2 { public static void main(String[] args) { File file = new File("file"); String[] names = file.list(); for(String name : names) { if(name.endsWith(".java")) { System.out.println(name); }
Java流(文件读写操作)
Java流 一、流的分类 ?按数据流动方向 –输入流：只能从中读取字节数据，而不能向其写出数据 –输出流：只能向其写入字节数据，而不能从中读取数据?按照流所处理的数据类型 –字节流：用于处理字节数据。 –字符流：用于处理Unicode字符数据。 ?按照流所处理的源 –节点流:从/向一个特定的IO设备读/写数据的流。（低级流）–处理流:对已存在的流进行连接和封装的流。（高级流）二、缓冲流 ?缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。 ?J2SDK提供了四种缓存流： –BufferedReader –BufferedWriter –BufferedInputStream s –BufferedOutputStream
?缓冲输入流支持其父类的mark()和reset()方法： –mark()用于“标记”当前位置，就像加入了一个书签，可以使用reset()方法返回这个标记重新读取数据。?BufferedReader提供了readLine()方法用于读取一行字符串（以\r 或\n分隔）。 ?BufferedWriter提供了newLine()用于写入一个行分隔符。 ?对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()方法将会使内存中的数据立刻写出。 三、类层次 3.1、InputStream类层次
3.2、OutputStream类层次 3.3、Reader类层次
3.4、Writer类层次 四、常用的字符流与字节流的转化 说明： 1.字节流用于读写诸如图像数据之类的原始字节流。 2.字符流用于读写诸如文件数据之类的字符流。 3.低级流能和外设交流。 4.高级流能提高效率。 5.InputStreamReader 是字节流通向字符流的桥梁。 6.OutputStreamWriter 是字符流通向字节流的桥梁。
Java输入输出流经典编程题
软件091班java程序机试题 编程题： 0. 求两点之间的距离。 要求： 1)设计点类，属性为点的坐标；利用点类设计距离类。 2)两点的坐标通过键盘输入，键盘输入要运用流，输入数据时要有合理的提示信息， 输出信息表达明确。 1．实现如下界面功能的图形界面应用程序（字体设置）。 2．编写程序，通过键盘输入多行信息，直接输入一个文本文件中。 要求：键盘输入的信息要使用流。 3．求5个以上学生的Java平均成绩。 要求： 1)要利用对象数组生成对象 2)信息通过键盘输入（利用流）。 3)Java成绩的范围在0-分100分，若输错，则需要重新输入。 4．设计一个包含两个命令按钮（显示文字和显示图片）的界面。 要求： 1)当单击“显示文字”命令按钮后，命令按钮变为“文字消失”，同时显示一行“单 击了命令按钮！”的文字。单击“文字消失”命令按钮后，命令按钮又变为“显 示文字”命令按钮，同时文字“单击了命令按钮！”消失。如此可以反复。 2)当单击“显示图片”命令按钮后，命令按钮变为“图片消失”，同时显示任意一 幅图片。单击“图片消失”命令按钮后，命令按钮又变为“显示图片”命令按钮， 同时图片消失。如此可以反复。 5．求5个以上人的平均年龄。 要求： 1)要利用对象数组生成对象 2)信息通过键盘输入（利用流）。 3)人年龄的范围在0岁-120岁，若输错，则需要重新输入。 6．打开Login1.Java源程序，题目要求见源程序的注释部分。 7．分别利用接口和抽象类，求给定三个以上三角形和给定三个以上矩形的平均周长。 提示：应该产生两个源程序。 要求： 1)要利用对象数组生成对象。 2)信息通过键盘输入（利用流）。 3)输入的三角形的三条边要能构成三角形，否则需要重新输入。
java文件流IO的增删改基础
package cn.itcast.file; import java.io.File; /* IO流(Input Output) ： IO技术主要的作用是解决设备与设备之间的数据传输问题。比如：硬盘--->内存内存的数据---->硬盘上把键盘的数据------->内存中 IO技术的应用场景： 导出报表，上传大头照、下载、解释xml文件 ... 数据保存到硬盘上，该数据就可以做到永久性的保存。数据一般是以文件的形式保存到硬盘上 sun使用了一个File类描述了文件或者文件夹的。 File类可以描述一个文件或者一个文件夹。 File类的构造方法： File(String pathname) 指定文件或者文件夹的路径创建一个File文件。 File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
File(String parent, String child) 目录分隔符：在windows机器上的目录分隔符是 \ ,在linux机器上的目录分隔符是/ . 注意：在windows上面\ 与 / 都可以使用作为目录分隔符。而且，如果写/ 的时候只需要写一个即可。 */ public class Demo1 { public static void main(String[] args) { //File file = new File("F:"+File.separator+"a.txt"); // 在linux机器上是不是一个合法路径？？？ File file = new File("F:/a.txt"); /*File parentFile = new File("F:\\"); File file = new File("F:\\","a.txt");*/ System.out.println("存在吗？ "+ file.exists()); // exists 判断该文件是否存在，存在返回true，否则返回false。 // System.out.println("目录分隔符："+ File.separator); } } package cn.itcast.file; import java.io.File;
java输入输出流总结
一、数据流的基本概念 流一般分为输入流（Input Stream）和输出流（Output Stream）两类，但这种划分并不是绝对的。比如一个文件，当向其中写数据时，它就是一个输出流；当从其中读取数据时，它就是一个输入流。当然，键盘只是一个数人流，而屏幕则只是一个输出流。 java的标准数据流：标准输入输出指在字符方式下（如DOS），程序与系统进行交互的方式，分为三种： 标准输入studin,对象是键盘。 标准输出stdout,对象是屏幕。 标准错误输出stderr,对象也是屏幕。 二、java.io包中的数据流和文件类 字节流：从InputStream和OutputStream派生出来的一系列类。这类流以字节(byte)为基本处理单位。 InputStream、OutputStream FileInputStream、FileOutputStream PipedInputStream、PipedOutputStream ByteArrayInputStream、ByteArrayOutputStream FilterInputStream、FilterOutputStream DataInputStream、DataOutputStream BufferedInputStream、BufferedOutputStream 字符流：从Reader和Writer派生出的一系列类，这类流以16位的Unicode码表示的字符为基本处理单位。 Reader、Writer InputStreamReader、OutputStreamWriter FileReader、FileWriter CharArrayReader、CharArrayWriter PipedReader、PipedWriter FilterReader、FilterWriter BufferedReader、BufferedWriter StringReader、StringWriter 三、字节流方法 InputStream 和OutputStream read()：从流中读入数据 skip()：跳过流中若干字节数 available()：返回流中可用字节数 mark()：在流中标记一个位置 reset()：返回标记过得位置 markSupport()：是否支持标记和复位操作 close()：关闭流 int read() :从输入流中读一个字节，形成一个0～255之间的整数返回（是一个抽象方法）。 int read(byte b[]) :读多个字节到数组中。 int read(byte b[], int off, int len)：从输入流中读取长度为len的数据，写入数组b中从索引of f开始的位置，并返回读取得字节数。 write(int b) :将一个整数输出到流中（只输出低位字节，抽象） write(byte b[]) :将字节数组中的数据输出到流中 write(byte b[], int off, int len) :将数组b中从off指定的位置开始，长度为len的数据输出到流
《Java面向对象程序设计》实验-实验八(输入输出流)
广西科技大学 计通学院 《Java面向对象程序设计》实验实验八输入输出流 学生姓名：××× 学号：××× 班级：××× 指导老师：××× 专业：计算机科学与技术 提交日期：×××年××月××日 实验报告内容
1．实验目的 掌握字符输入、输出流用法； 掌握使用Scanner类解析文件； 掌握Console流的使用。 2．实验内容 实验教材-第12章实验1、2、3 字符输入输出流；Scanner类和Console类。 要求:完善程序,给出实验结果截图； 完成试验后练习。 3．程序代码及运行结果： 实验1 举重成绩单 //AnalysisResult.java import java.io.*; import java.util.*; public class AnalysisResult { public static void main(String[] args) { File fRead=new File("score.txt"); File fWrite=new File("scoreAnalysis.txt"); try{ Writer out=new FileWriter(fWrite); BufferedWriter bufferWrite=new BufferedWriter(out); Reader in=new FileReader(fRead); BufferedReader bufferRead=new BufferedReader(in); String str=null; while((str=bufferRead.readLine())!=null){ double
java文件流介绍
Input / Output:指跨越出JVM的边界,与外界数据的源头或者目标数据源进行数据交换. 输出Output -------------------------------> JVM 数据源 <------------------------------- 输入Input 注意：输入/输出是针对JVM 而言。 File 类 可表示一个文件，也有可能是一个目录(在JA V A中文件和目录都属于这个类中，而且区分不是非常的明显，可以调用isDirectory()和isFile()来判断)。 File file = new File("c:\\abc.txt"); 常用的方法： exists() 用来判断文件或目录是否在硬盘存在。 isDirectory() 判断是否是目录 isFile() 判断是否是文件 mkdir() 创建目录 mkdirs() 创建目录包括它下面的子目录。 getAbsolutePath() 得到文件绝对路径 list() 得到文件名的String数组(得到当前目录下的文件名，目录名) listFiles() 返回File类型数组，(目录,文件的File对象)可用getName()得到文件名。 delete() 删除文件 getName() 得到文件名 getPath() 得到文件相对路径 separtor() 得到文件分隔符//这个方法有更好的通用性,平台不同结果不同 deleteOnExit() 在进程退出的时候删除文件,常用在临时文件的删除。 1、流的概念： 输出流 程序----------->文件、网络 程序<-----------数据来源 输入流 2、流的分类： 按处理方式来分： 字节流：按8位传输InputStream OutputStream 字符流：按16位传输Reader Writer 按功能来分： 节点流：与文件、网络打交道的流，操作数据的来源 处理流(包装流)：操作节点流
java实验11 输入输出流 - 答案
实验输入输出流 一、实验目的 1、掌握文件字节流的用法； 2、掌握文件字符流的用法； 3、掌握缓冲流的用法； 二、实验内容与步骤 1、编写程序，实现将诗句写入c:\小池.txt文件中，然后再从该文件中读出并打印输出。宋诗《小池》 作者：杨万里 泉眼无声惜细流， 树荫照水弄轻柔。 小荷才露尖尖角， 早有蜻蜓立上头。 import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class PoemWrite { public static void main(String[] args) { Scanner reader=new Scanner(System.in); String s; try{ FileWriter outOne=new FileWriter("c:\\小池.txt"); BufferedWriter outTwo=new BufferedWriter(outOne); while(!(s=reader.nextLine()).equals("0")){ outTwo.write(s); outTwo.newLine(); } outTwo.flush(); outTwo.close(); outOne.close(); FileReader inOne=new FileReader("c:\\小池.txt"); BufferedReader inTwo=new BufferedReader(inOne); while((s=inTwo.readLine())!=null){
Java的输入与输出流(实验报告)
成都大学实验报告 实验项目名称Java的输入与输出流 一、实验目的： 1. 理解I/O流的概念，掌握其分类 2. 掌握文本文件读写、二进制文件读写 二、实验内容（包括源程序及相关说明）： 1. 分别使用FileWriter 和BufferedWriter 往文件中写入10万个随机数，比较用时。源代码如下： （1） import java.io.*; public class Ex1_1 { public static void main(String[] args) throws IOException{ long t=System.currentTimeMillis(); FileWriter fw =new FileWriter("d:\\Ex1.txt"); for(int i=1;i<=100000;i++) { fw.write((int)(Math.random()*10000)+" \n"); } fw.close(); t=System.currentTimeMillis()-t; System.out.println("The elapsed: "+t); } } （2） import java.io.*; public class Ex1_1 { public static void main(String[] args) throws IOException{ long t=System.currentTimeMillis(); BufferedWriter fw=new BufferedWriter(new FileWriter("d:\\Ex1.txt"));
java输入输出流试验
输入输出流 一、实验目的： 熟悉Java的文件读写机制，练习输入输出流的使用。 二、实验内容： 1、键盘输入10个整数，从小到大进行排序。 2、接收键盘输入的字符串，用FileInputStream类将字符串写入文件，用 FileOutputStream类读出文件内容显示在屏幕上。 3、将一个文本文件的内容按行读出，每读出一行就顺序加上行号，并写入 到另一个文件中。 三、实验要求： 1. 通过实验掌握文件输入输出流的使用方法； 2. 程序必须能够从键盘接收字符串并保存在文件中； 3. 程序必须能够读出文件内容显示在屏幕上； 4. 写出实验报告。 四、实验步骤： 1、键盘输入10个整数，从小到大进行排序。 package javaTest; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Gui_21 { public static void main(String[] args) throws IOException { // TODO Auto-generated method stub BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); String str; int array[]=new int[10]; for(int i=0;i<10;i++) { System.out.println("请输入一个整数:"); str=br.readLine(); array[i]=Integer.parseInt(str);
JAVA流式输入输出与文件处理
流式输入输出与文件处理 实验目的 (1) 掌握字节流和字符流的特点和处理差异； (2) 掌握过滤流的使用； (3) 掌握File类的使用； (4) 掌握随机文件的使用。 (5) 掌握对象系列化的概念以及访问文件时对象读写方法。 知识要点 1 面向字节的输入/输出流 （1）类InputStream是面向字节的输入流的根。其主要方法见表13-1。 表13-1 类InputStream的方法 该流实现DataInput接口，主要方法有：readByte()，readBoolean()、 readShort()、readChar()、readInt() 、readLong()、readFloat()、readDouble()、readUTF()等。 （3）类OutputStream是面向字节输出流的根，其主要方法有： ●void write(int b) ：将参数b的低字节写入输出流 ●void write(byte b[]) ：将字节数组全部写入输出流 ●void write(byte b[],int offset, int len)：将字节数组中从b[offset]开始处的len个字节写入至输出流。 （4）类DataOutputStream实现各种类型数据的输出处理，它实现了DataOutput接口，主要方法有：writeByte(int)、writeBytes(String)、writeBoolean(boolean)、writeChars(String)、writeInt(int) 、writeLong()、writeFloat(float)、writeDouble(double)、writeUTF(String)等。 2 面向字符的输入与输出流 类Reader是面向字符的输入流的根，其提供的方法与InputStream类似，只是将基于Byte的参数改为基于Char。
servlet中的输入输出流
分类：Java JSP和Servlet中的输入输出流 2008-05-27 20:00 一、servlet response实现了HttpServletResponse接口，request实现了HttpServletRequest接口。 1、输出流有两个： 字节形式输出：response.getOutputStream() 字符形式输出：response.getWriter（） 2、输入流有两个： 字节形式输入：request.getInputStream() 字符形式输入：request.getReader（） 二、JSP JSP中的response对象已经实现了HttpServletResponse接口，request对象已经实现了HttpServletRequest接口。 1、输出流 jsp中可以使用response.getWriter()方法建立字符输出流来输出字符数据到网页上。 因为jsp转译成servlet时,当有输出就会使用getWriter(). 它是javax.servlet.jsp.JspWriter类型(extends java.io.Writer). 而getOutputStream(). 它是javax.servlet.ServletOutputStream类型(extends java.io.OutputStream). 而对客户端的输出只能使用一种类别输出. 当它在jsp里使用了getOutputStream(). 就会产生了两种类别输出,所以就会形成冲突.program根本不知道你要使用那一个作为输出. 一般在下载档案时都要使用getOutputStream().对客户端串流输出. 使用jsp作为下载档案时, 在jsp档案里,不能有任何的输出. 包括空格或out.println("xxx"); 因为会使用了jspWriter(). 2、输入流 jsp中好像没有自动实现输入流的对象，所以可以使用request.getInputStream()，request.getReader()方法建立输入流。 3、读写服务器上的文件 file.Reader()和file.Writer()方法可以用来读写服务器上任何位置的文件。