1 package org.java;
2
3 import java.io.BufferedReader;
4 import java.io.BufferedWriter;
5 import java.io.File;
6 import java.io.FileInputStream;
7 import java.io.FileOutputStream;
8 import java.io.FileReader;
9 import java.io.FileWriter;
10 import java.io.FilenameFilter;
11 import java.io.IOException;
12
13
14 public class JavaUseTest {
15
16 public static void main(String[] args) {
17 /*
18 Java文件输入输出
19 从输入流中 读取数据
20 在输出流中 写入数据
21
22 Java.io包提供流类
23 InputStream抽象类 的 子类 创建的 流对象 称为 字节输入流
24 OutputStream抽象类 的 子类 创建的 流对象 称为 字节输出流
25 Reader抽象类 的 子类 创建的 流对象 称为字符输入流
26 Writer抽象类 的 子类 创建的 流对象 称为字符输出流
27
28
29 File类：
30 主要 获取一些文本信息：
31 构造方法:
32 File(URI uri);//传入文件的目录地址和名字 :file.txt:绝对路径是->C:\Users\Nirobert Einteson\Desktop\java\File\file.txt
33 File(String filename);//filename文件名字；会被认为在当前应用程序在同一目录;hello.txt:C:\Users\Nirobert Einteson\eclipse-workspace\HelloWorld\hello.txt
34 File(String directoryPath,String filename);//directoryPath文件路径
35 File(File fileParentPath,String name);//在 file 的父路径 路径 下创建 新的 文件 filex.txt;
36
37 文件的属性：
38 public String getName();//获取文件的名字
39 public boolean canRead();//判断文件是否是 可读的
40 public boolean canWrite();//判断文件是否是 可被写入
41 public boolean exists();//判断文件是否 存在
42 public String getAbsolutePath();//获取文件的绝对路径
43 public String getParent();//获取文件的父目录
44 public boolean isFile();//判断文件是否是 一个普通的文件，而不是目录
45 public boolean isDirectory();//判断文件是否是一个目录
46 public boolean isHidden();//判断文件是否是 隐藏文件
47 public long lastModified();//获取文件的 最后修改的时间（毫秒数)
48 public long length();//获取文件的长度
49 public boolean delete();//删除文件;file.delete();
50 public boolean createNewFile();//如果目录中没有要创建的文件，那么会调用这个方法，创建这个文件
51 public
52
53
54 文件的创建
55 File file=new File(filename);
56 文件的删除
57
58 目录：
59 pubic boolean mkdir();//创建一个目录 创建成功返回true,否则返回false(文件已存在也是false);
60 public String[] list();//以字符串形式目录下的所有文件
61 public String[] list(FilenameFilter object);//以字符串形式 返回目录下指定的类型的文件 如：.txt,.java
62 public File[] listFiles();//以File对象的形式返回目录下的所有文件
63 public File[] listFiles(FilenameFilter object);//以 File对象的形式 返回返回目录下指定的类型的文件 如：.txt,.java
64
65 FilenameFilter是一个接口;有方法accept(File dir,String name);需要实现接口
66 public boolean accept(File dir,String name);
67
68 字节型
69 基本管道：FileInputStream FileOutputStream
70 增强型 管道：在基本管道的外面 包上一层)
71 DataInputStream DataOutputStream
72 BufferedInputStream BufferedOutputStream
73 ObjectInputStream ObjectOutputStream
74 增强型管道的 源 和目的地 都是 字节型 基本管道
75 public DataInputStream（InputStream in）
76 public DataOutputStream（OutnputStream out）
77 public BufferedInputStream(InputStream in)
78 public BufferedInputStream(InputStream in, int size)
79 public BufferedOutputStream(OutputStream out)
80 public BufferedOutputStream(OutputStream out, int size)
81 ObjectInputStream(InputStream in)
82 ObjectOutputStream(OutputStream out)
83 对象输出流使用writeObject(Object obj)方法将一个对象obj写入到一个文件；对象输入流使用readObject()读取一个对象到程序中。
84 当使用对象流写入或读入对象时，要保证对象是序列化的
85 一个类如果实现了Serializable接口(java.io包中的接口)，那么这个类创建的对象就是所谓序列化的对象 。
86
87
88
89 字符型：
90 基本管道:
91 FileReader FileWriter
92 增强型:
93 BufferedReader BufferedWriter
94
95
96
97
98 文件字节流：
99 读写文件的子类:FileInputStream 和FileOutputStream
100 若只是简单的读写文件，那么就可以使用FileInputStream 和FileOutputStream
101
102
103
104 文件字节输入流:
105 关闭输入流 :fileInputStream.close();
106 FileInputStream 是 InputStream 的子类：
107 构造方法：
108 FileInputStream(String name);
109 FileInputStream（File file);
110 参数name 和file 称为输入流的源，输入流通过调用read方法 读出 源 中的数据
111
112 以字节为单位 读 文件
113 //2^8 =256-> 返回(0,255)字节值，到达末尾 返回-1
114 int read();//输入流 调用read() 方法 顺序 地 从源 中读取 单个 字节数据 ；
115 int read(byte b[]);//按照字节 顺序地 从文件中读取b.length个数据，然后放到 字节数组 b里面
116 int read(byte b[],int off,int len);///按照字节 顺序地 从文件中 off开始 顺序地 读取len个字节 ， 放到 字节数组 b里面
117 read读取文件，只要不关闭流，那么每次调用read 方法 都会顺序地 读取剩余 的内容，直到读完流中的文件 或者文件关闭
118
119 FileOutputStream类：
120 关闭输出流: 关闭输入流 :fileOutputStream.close();
121 构造方法：
122 FileOutputStream(String name);
123 FileOutputStream(File file);
124 以name ,file 作为目的地 把数据在 输出流中 写入文件中
125
126 以字节为单位 写入文件:
127 //以字节为单位顺序写入 数据
128 public void write(byte b[]);//把字节数组中 数据 全部写入到文件中
129 public void write(byte b[],int off,int len);//把字节数组中 偏移量off开始 共len个字节 数据，写入到文件中
130
131
132 字节流 ：的 read()和write() 方法
133 字节流不能很好的 处理Unicode字符 ，如汉字在文件中 占两个字节，使用字节流，可能出现乱码
134 可以加大 输入输出流的 强度
135
136 将字节型 流 变成 字符型流
137 变成 FileReader()和 FileWriter() 是 Reader和Writer的子类
138 在java.io.*包里面
139 构造方法:
140 FileReader(String filename);
141 FileReader(File filename);
142 FileWriter(String filename);
143 FileWriter(File filename);
144
145 字符型read()，write()方法
146 int read();//从源 中读取一个字符 ，返回(0-65535，Unicode字符值)，读出失败返回-1
147 int read(char ch[]);//从源 中读取 ch.length 个 字符 ，放到 字符 数组 ch中；到达 源(文件) 的末尾 返回-1
148 int read(char ch[],int offset,int len);//从源 中从off开始 读取 len 个 字符 放到 字符数组 ch里面，到达 源(文件) 的末尾 返回-1;
149 void write(char ch);//字符输出流 写入 一个 字符
150 void write(char ch[]);//在字符输出流中 写入 一个 字符数组
151 void write(char ch[],int off,int len);//在字符输出流中 写入 一个 字符数组 的off开始 ，共len个字符
152
153
154
155
156 缓冲流：
157 BufferReader类：缓冲输入流
158 BufferWriter类：缓冲输出流
159 如果要读取一行，那么字符型输入流 很难 知道一行是 多少个字符，所以采用 缓冲输入流
160
161 缓冲流的 源和目的地： 必须是 字符输入流 和 字符输出流
162 构造方法：
163 BufferedReader(reader in);
164 BufferedWriter(Writer out);
165
166 向BufferedReader 传递 一个Reader的 子类 对象 (如：FileReader fileReader)来创建BufferedReader对象
167 如： FileReader fileReader=new FileReader(file);
168 BufferedReader bufferedReader=new BufferedReader(fileReader);//创建 缓冲 输入流 对象
169 String str=bufferedReader.readLine();//方法读取一行数据,赋值给str-->toCharArray()变成字符数组
170 //newLine();//写入一个回车符号
171 BufferedWriter(Writer out);
172
173 write(String str,int off,int len);//字符串str从 off开始 ，共len个字符 写入 文件中
174
175 字符输入流FileReader 首先 将 数据 读入缓存，然后 BufferedReader缓冲输入流 再从 缓存中 读取数据
176 BufferedWriter缓冲输出流 先向 缓存中 写入数据，然后字符输入流FileWriter将 缓存 中的 数据 写入 目的地；
177 当BufferedWriter 调用flush()方法 刷新 缓存 或close()方法 关闭的时候，即使 缓存 没有 溢出，仍然要 将缓存的内容送入目的地
178 要先关闭 缓冲流，然后才能关闭 字符流
179
180
181
182 */
183 String path="C:\\Users\\Nirobert Einteson\\Desktop\\java\\File\\";//文件的所在的目录
184
185 File file=new File(path+"file.txt");//在path路径下 创建file.txt文件
186 File file2=new File("file2.txt");//默认 和当前应用程序在同一目录;即:*.java 在同一目录下
187 File file3=new File(path,"file3.txt");//在path路径下，创建file3.txt文件
188 File file4=new File(file3.getParent(),"file4.txt");//在 file3的父路径 路径 下创建 新的 文件 file4.txt;
189
190 System.out.println(file.getName()+" :绝对路径是->"+file.getAbsolutePath());
191 System.out.println(file2.getName()+":绝对路径是->"+file2.getAbsolutePath());
192 System.out.println(file3.getName()+":绝对路径是->"+file3.getAbsolutePath());
193 System.out.println(file4.getName()+":绝对路径是->"+file4.getAbsolutePath());
194
195 System.out.println("file文件是否可读"+file.canRead());
196 System.out.println("file文件是否可写"+file.canWrite());
197 System.out.println("file文件的长度"+file.length());
198
199 //路径 path 下.的内容；//.代表 当前路径
200 File dir=new File(path+".");//C:\Users\Nirobert Einteson\Desktop\java\File\.
201 //取出目录下的 所有.txt文件
202 String[] filenames=dir.list(new FilenameFilter(){
203 //重写 接口的 方法，这里属于是匿名接口的实现
204 @Override
205 public boolean accept(File dir,String name) {
206 return name.endsWith(".txt");//dir路径下;名字以.txt结尾的文件
207 }});
208 //文件以字符串的形式 已经存到 filenames里面
209 System.out.println(path+"路径下以.txt结尾的文件有"+filenames.length+"个"+"\n"+"分别是:");
210 for(String name1:filenames) {
211 System.out.println(name1);
212 }
213
214 //直接获取文件夹里面的所有文件 存到字符串数组里面
215 File file5=new File(path+".");//C:\Users\Nirobert Einteson\Desktop\java\File\.
216 String names[]=file5.list();//获取这个路径下的所有文件
217 System.out.println(path+"路径下以.txt结尾的文件有"+names.length+"个"+"\n"+"分别是:");
218 for(String name1:names) {
219 System.out.println(name1);
220 }
221
222 //删除文件
223 file3.delete();
224 System.out.println(file3.exists());
225
226 try {//文件可能会抛出异常 ，所以需要在try-catch语句里面进行写
227
228 //在输出流中 ，向文件写入数据--write();方法
229 FileOutputStream fileOutputStream3=new FileOutputStream(file3);
230 //变成字节数组，在 文件输出流中 ，写入到文件里面
231 byte byteFile[]="this is a byte stream".getBytes();
232 fileOutputStream3.write(byteFile);
233 fileOutputStream3.close();
234
235 FileOutputStream fileOutputStream4=new FileOutputStream(file4);
236 fileOutputStream4.write(byteFile);
237 fileOutputStream4.close();
238
239 //从文件字节 的输入流 中读数据--->read()方法
240 FileInputStream fileInputStream=new FileInputStream(file);
241
242 byte byteReadData[]=new byte[8];//初始化8个字节数组
243 int data;
244 while((data=fileInputStream.read(byteReadData,0,8))!=-1) {//每次都读取8个字节 放到 byteReadData字节数组里面
245 //data位每次从输入流中 实际读取了多少个数据
246 //String string=new String(byteReadData,0,data);//data是每次读取了多少个字节数，比如8,8,8,3最后一个到不了8个字节
247 //String string2=new String(byteReadData,0,8);//每次都输出8个，可能不正确，比如只读出了3个却输出了8个
248 //System.out.println(string);
249 }
250 fileInputStream.close();
251
252
253 //字符型 输出流
254
255 FileWriter fileWriter=new FileWriter(file);
256 char ch[]="这是一个字符型流测试的样例".toCharArray();//字符串 变成 字符串数组
257 fileWriter.write(ch);//字符数组
258 fileWriter.write(ch, 4, 3);//字符数组
259 fileWriter.write('X');//写入一个字符
260 fileWriter.write("hello",1,3);//字符串
261 fileWriter.close();
262
263 //字符输入流
264 FileReader fileReader=new FileReader(file);
265 char readChar[]=new char[8];//每次读取8个字符
266 int index=0;
267 while((index=fileReader.read(readChar,0,8))!=-1) {
268 String tmp=new String(readChar,0,index);
269 System.out.println("读取的字符型数据："+tmp+"\n");
270 System.out.println("读取单个字符："+(char)fileReader.read());//返回0-65535转成字符
271 }
272 fileReader.close();
273
274
275 // 缓冲 输出流
276 FileWriter fileWriter2=new FileWriter(file);
277 BufferedWriter bufferedWriter=new BufferedWriter(fileWriter2);
278 bufferedWriter.write("hhhhhhhh+ko+'\n'+ok+hhhhhhhh");
279 bufferedWriter.newLine();//写入换行符
280 bufferedWriter.close();//要先关闭 缓冲流，然后才能关闭 字符流
281 fileWriter2.close();
282
283
284 //缓冲 输入流
285 FileReader fileReader2=new FileReader(file);
286 BufferedReader bufferedReader=new BufferedReader(fileReader2);
287 String string=null;//string用来接收 readLine() 字符串,最后默认返回为null
288 while((string=bufferedReader.readLine())!=null) {//只要读出的 不是null,说明不为空
289 System.out.println("缓冲输入流：读出的文件是："+string);
290 }
291 bufferedReader.close();//要先关闭 缓冲流，然后才能关闭 字符流
292 fileReader2.close();
293
294
295 }catch (IOException e) {
296 System.out.println(e);
297 }
298
299 }
300
301 }
输出结果：
1 file.txt :绝对路径是->C:\Users\Nirobert Einteson\Desktop\java\File\file.txt
2 file2.txt:绝对路径是->C:\Users\Nirobert Einteson\eclipse-workspace\HelloWorld\file2.txt
3 file3.txt:绝对路径是->C:\Users\Nirobert Einteson\Desktop\java\File\file3.txt
4 file4.txt:绝对路径是->C:\Users\Nirobert Einteson\Desktop\java\File\file4.txt
5 file文件是否可读true
6 file文件是否可写true
7 file文件的长度29
8 C:\Users\Nirobert Einteson\Desktop\java\File\路径下以.txt结尾的文件有3个
9 分别是:
10 file.txt
11 file3.txt
12 file4.txt
13 C:\Users\Nirobert Einteson\Desktop\java\File\路径下以.txt结尾的文件有3个
14 分别是:
15 file.txt
16 file3.txt
17 file4.txt
18 false
19 读取的字符型数据：这是一个字符型流
20
21 读取单个字符：测
22 读取的字符型数据：试的样例字符型X
23
24 读取单个字符：e
25 读取的字符型数据：ll
26
27 读取单个字符：�
28 缓冲输入流：读出的文件是：hhhhhhhh+ko+'
29 缓冲输入流：读出的文件是：'+ok+hhhhhhhh
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
