一、多种方式读文件内容。【参考:http://www.ibm.com/developerworks/cn/java/j-lo-javaio/】
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
001 |
import java.io.BufferedReader;
|
002 |
import java.io.File;
|
003 |
import java.io.FileInputStream;
|
004 |
import java.io.FileReader;
|
005 |
import java.io.IOException;
|
006 |
import java.io.InputStream;
|
007 |
import java.io.InputStreamReader;
|
008 |
import java.io.RandomAccessFile;
|
009 |
import java.io.Reader;
|
010 |
public class ReadFromFile {
|
011 |
/** |
012 |
* 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
|
013 |
* @param fileName 文件的名
|
014 |
*/
|
015 |
public static void readFileByBytes(String fileName){
|
016 |
File file = new File(fileName);
|
017 |
InputStream in = null ;
|
018 |
try {
|
019 |
System.out.println( "以字节为单位读取文件内容,一次读一个字节:" );
|
020 |
// 一次读一个字节
|
021 |
in = new FileInputStream(file);
|
022 |
int tempbyte;
|
023 |
while ((tempbyte=in.read()) != - 1 ){
|
024 |
System.out.write(tempbyte);
|
025 |
}
|
026 |
in.close();
|
027 |
} catch (IOException e) {
|
028 |
e.printStackTrace();
|
029 |
return ;
|
030 |
}
|
031 |
try {
|
032 |
System.out.println( "以字节为单位读取文件内容,一次读多个字节:" );
|
033 |
//一次读多个字节
|
034 |
byte [] tempbytes = new byte [ 100 ];
|
035 |
int byteread = 0 ;
|
036 |
in = new FileInputStream(fileName);
|
037 |
ReadFromFile.showAvailableBytes(in);
|
038 |
//读入多个字节到字节数组中,byteread为一次读入的字节数
|
039 |
while ((byteread = in.read(tempbytes)) != - 1 ){
|
040 |
System.out.write(tempbytes, 0 , byteread);
|
041 |
}
|
042 |
} catch (Exception e1) {
|
043 |
e1.printStackTrace();
|
044 |
} finally {
|
045 |
if (in != null ){
|
046 |
try {
|
047 |
in.close();
|
048 |
} catch (IOException e1) {
|
049 |
}
|
050 |
}
|
051 |
}
|
052 |
} |
053 |
/** |
054 |
* 以字符为单位读取文件,常用于读文本,数字等类型的文件
|
055 |
* @param fileName 文件名
|
056 |
*/
|
057 |
public static void readFileByChars(String fileName){
|
058 |
File file = new File(fileName);
|
059 |
Reader reader = null ;
|
060 |
try {
|
061 |
System.out.println( "以字符为单位读取文件内容,一次读一个字节:" );
|
062 |
// 一次读一个字符
|
063 |
reader = new InputStreamReader( new FileInputStream(file));
|
064 |
int tempchar;
|
065 |
while ((tempchar = reader.read()) != - 1 ){
|
066 |
//对于windows下,/r/n这两个字符在一起时,表示一个换行。
|
067 |
//但如果这两个字符分开显示时,会换两次行。
|
068 |
//因此,屏蔽掉/r,或者屏蔽/n。否则,将会多出很多空行。
|
069 |
if ((( char )tempchar) != '/r' ){
|
070 |
System.out.print(( char )tempchar);
|
071 |
}
|
072 |
}
|
073 |
reader.close();
|
074 |
} catch (Exception e) {
|
075 |
e.printStackTrace();
|
076 |
}
|
077 |
try {
|
078 |
System.out.println( "以字符为单位读取文件内容,一次读多个字节:" );
|
079 |
//一次读多个字符
|
080 |
char [] tempchars = new char [ 30 ];
|
081 |
int charread = 0 ;
|
082 |
reader = new InputStreamReader( new FileInputStream(fileName));
|
083 |
//读入多个字符到字符数组中,charread为一次读取字符数
|
084 |
while ((charread = reader.read(tempchars))!=- 1 ){
|
085 |
//同样屏蔽掉/r不显示
|
086 |
if ((charread == tempchars.length)&&(tempchars[tempchars.length- 1 ] != '/r' )){
|
087 |
System.out.print(tempchars);
|
088 |
} else {
|
089 |
for ( int i= 0 ; i<charread; i++){
|
090 |
if (tempchars[i] == '/r' ){
|
091 |
continue ;
|
092 |
} else {
|
093 |
System.out.print(tempchars[i]);
|
094 |
}
|
095 |
}
|
096 |
}
|
097 |
}
|
098 |
|
099 |
} catch (Exception e1) {
|
100 |
e1.printStackTrace();
|
101 |
} finally {
|
102 |
if (reader != null ){
|
103 |
try {
|
104 |
reader.close();
|
105 |
} catch (IOException e1) {
|
106 |
}
|
107 |
}
|
108 |
}
|
109 |
} |
110 |
/** |
111 |
* 以行为单位读取文件,常用于读面向行的格式化文件
|
112 |
* @param fileName 文件名
|
113 |
*/
|
114 |
public static void readFileByLines(String fileName){
|
115 |
File file = new File(fileName);
|
116 |
BufferedReader reader = null ;
|
117 |
try {
|
118 |
System.out.println( "以行为单位读取文件内容,一次读一整行:" );
|
119 |
reader = new BufferedReader( new FileReader(file));
|
120 |
String tempString = null ;
|
121 |
int line = 1 ;
|
122 |
//一次读入一行,直到读入null为文件结束
|
123 |
while ((tempString = reader.readLine()) != null ){
|
124 |
//显示行号
|
125 |
System.out.println( "line " + line + ": " + tempString);
|
126 |
line++;
|
127 |
}
|
128 |
reader.close();
|
129 |
} catch (IOException e) {
|
130 |
e.printStackTrace();
|
131 |
} finally {
|
132 |
if (reader != null ){
|
133 |
try {
|
134 |
reader.close();
|
135 |
} catch (IOException e1) {
|
136 |
}
|
137 |
}
|
138 |
}
|
139 |
} |
140 |
/** |
141 |
* 随机读取文件内容
|
142 |
* @param fileName 文件名
|
143 |
*/
|
144 |
public static void readFileByRandomAccess(String fileName){
|
145 |
RandomAccessFile randomFile = null ;
|
146 |
try {
|
147 |
System.out.println( "随机读取一段文件内容:" );
|
148 |
// 打开一个随机访问文件流,按只读方式
|
149 |
randomFile = new RandomAccessFile(fileName, "r" );
|
150 |
// 文件长度,字节数
|
151 |
long fileLength = randomFile.length();
|
152 |
// 读文件的起始位置
|
153 |
int beginIndex = (fileLength > 4 ) ? 4 : 0 ;
|
154 |
//将读文件的开始位置移到beginIndex位置。
|
155 |
randomFile.seek(beginIndex);
|
156 |
byte [] bytes = new byte [ 10 ];
|
157 |
int byteread = 0 ;
|
158 |
//一次读10个字节,如果文件内容不足10个字节,则读剩下的字节。
|
159 |
//将一次读取的字节数赋给byteread
|
160 |
while ((byteread = randomFile.read(bytes)) != - 1 ){
|
161 |
System.out.write(bytes, 0 , byteread);
|
162 |
}
|
163 |
} catch (IOException e){
|
164 |
e.printStackTrace();
|
165 |
} finally {
|
166 |
if (randomFile != null ){
|
167 |
try {
|
168 |
randomFile.close();
|
169 |
} catch (IOException e1) {
|
170 |
}
|
171 |
}
|
172 |
}
|
173 |
} |
174 |
/** |
175 |
* 显示输入流中还剩的字节数
|
176 |
* @param in
|
177 |
*/
|
178 |
private static void showAvailableBytes(InputStream in){
|
179 |
try {
|
180 |
System.out.println( "当前字节输入流中的字节数为:" + in.available());
|
181 |
} catch (IOException e) {
|
182 |
e.printStackTrace();
|
183 |
}
|
184 |
} |
185 |
186 |
public static void main(String[] args) {
|
187 |
String fileName = "C:/temp/newTemp.txt" ;
|
188 |
ReadFromFile.readFileByBytes(fileName);
|
189 |
ReadFromFile.readFileByChars(fileName);
|
190 |
ReadFromFile.readFileByLines(fileName);
|
191 |
ReadFromFile.readFileByRandomAccess(fileName);
|
192 |
} |
193 |
} |
二、将内容追加到文件尾部
001 |
import java.io.FileWriter;
|
002 |
import java.io.IOException;
|
003 |
import java.io.RandomAccessFile;
|
004 |
005 |
/** |
006 |
* 将内容追加到文件尾部 |
007 |
*/ |
008 |
public class AppendToFile {
|
009 |
010 |
/** |
011 |
* A方法追加文件:使用RandomAccessFile
|
012 |
* @param fileName 文件名
|
013 |
* @param content 追加的内容
|
014 |
*/
|
015 |
public static void appendMethodA(String fileName, String content){
|
016 |
try {
|
017 |
// 打开一个随机访问文件流,按读写方式
|
018 |
RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw" );
|
019 |
// 文件长度,字节数
|
020 |
long fileLength = randomFile.length();
|
021 |
//将写文件指针移到文件尾。
|
022 |
randomFile.seek(fileLength);
|
023 |
randomFile.writeBytes(content);
|
024 |
randomFile.close();
|
025 |
} catch (IOException e){
|
026 |
e.printStackTrace();
|
027 |
}
|
028 |
} |
029 |
/** |
030 |
* B方法追加文件:使用FileWriter
|
031 |
* @param fileName
|
032 |
* @param content
|
033 |
*/
|
034 |
public static void appendMethodB(String fileName, String content){
|
035 |
try {
|
036 |
//打开一个写文件器,构造函数中的第二个参数true表示以追加形式写文件
|
037 |
FileWriter writer = new FileWriter(fileName, true );
|
038 |
writer.write(content);
|
039 |
writer.close();
|
040 |
} catch (IOException e) {
|
041 |
e.printStackTrace();
|
042 |
}
|
043 |
} |
044 |
045 |
public static void main(String[] args) {
|
046 |
String fileName = "C:/temp/newTemp.txt" ;
|
047 |
String content = "new append!" ;
|
048 |
//按方法A追加文件
|
049 |
AppendToFile.appendMethodA(fileName, content);
|
050 |
AppendToFile.appendMethodA(fileName, "append end. /n" );
|
051 |
//显示文件内容
|
052 |
ReadFromFile.readFileByLines(fileName);
|
053 |
//按方法B追加文件
|
054 |
AppendToFile.appendMethodB(fileName, content);
|
055 |
AppendToFile.appendMethodB(fileName, "append end. /n" );
|
056 |
//显示文件内容
|
057 |
ReadFromFile.readFileByLines(fileName);
|
058 |
} |
059 |
} |
060 |
061 |
三文件的各种操作类 |
062 |
063 |
import java.io.*;
|
064 |
065 |
/** |
066 |
* FileOperate.java |
067 |
* 文件的各种操作 |
068 |
* @author 杨彩 http://blog.sina.com.cn/m/yangcai |
069 |
* 文件操作 1.0 |
070 |
*/ |
071 |
072 |
public class FileOperate
|
073 |
{ |
074 |
075 |
public FileOperate()
|
076 |
{ |
077 |
} |
078 |
/** |
079 |
* 新建目录 |
080 |
*/ |
081 |
public void newFolder(String folderPath)
|
082 |
{ |
083 |
try |
084 |
{ |
085 |
String filePath = folderPath; |
086 |
filePath = filePath.toString(); |
087 |
File myFilePath = new File(filePath);
|
088 |
if (!myFilePath.exists())
|
089 |
{ |
090 |
myFilePath.mkdir(); |
091 |
} |
092 |
System.out.println( "新建目录操作 成功执行" );
|
093 |
} |
094 |
catch (Exception e)
|
095 |
{ |
096 |
System.out.println( "新建目录操作出错" );
|
097 |
e.printStackTrace(); |
098 |
} |
099 |
} |
100 |
/** |
101 |
* 新建文件 |
102 |
*/ |
103 |
public void newFile(String filePathAndName, String fileContent)
|
104 |
{ |
105 |
try |
106 |
{ |
107 |
String filePath = filePathAndName; |
108 |
filePath = filePath.toString(); |
109 |
File myFilePath = new File(filePath);
|
110 |
if (!myFilePath.exists())
|
111 |
{ |
112 |
myFilePath.createNewFile(); |
113 |
} |
114 |
FileWriter resultFile = new FileWriter(myFilePath);
|
115 |
PrintWriter myFile = new PrintWriter(resultFile);
|
116 |
String strContent = fileContent; |
117 |
myFile.println(strContent); |
118 |
resultFile.close(); |
119 |
System.out.println( "新建文件操作 成功执行" );
|
120 |
} |
121 |
catch (Exception e)
|
122 |
{ |
123 |
System.out.println( "新建目录操作出错" );
|
124 |
e.printStackTrace(); |
125 |
} |
126 |
} |
127 |
/** |
128 |
* 删除文件 |
129 |
*/ |
130 |
public void delFile(String filePathAndName)
|
131 |
{ |
132 |
try |
133 |
{ |
134 |
String filePath = filePathAndName; |
135 |
filePath = filePath.toString(); |
136 |
File myDelFile = new File(filePath);
|
137 |
myDelFile.delete(); |
138 |
System.out.println( "删除文件操作 成功执行" );
|
139 |
} |
140 |
catch (Exception e)
|
141 |
{ |
142 |
System.out.println( "删除文件操作出错" );
|
143 |
e.printStackTrace(); |
144 |
} |
145 |
} |
146 |
/** |
147 |
* 删除文件夹 |
148 |
*/ |
149 |
public void delFolder(String folderPath)
|
150 |
{ |
151 |
try |
152 |
{ |
153 |
delAllFile(folderPath); //删除完里面所有内容
|
154 |
String filePath = folderPath; |
155 |
filePath = filePath.toString(); |
156 |
File myFilePath = new File(filePath);
|
157 |
if (myFilePath.delete()) { //删除空文件夹
|
158 |
System.out.println( "删除文件夹" + folderPath + "操作 成功执行" );
|
159 |
} else {
|
160 |
System.out.println( "删除文件夹" + folderPath + "操作 执行失败" );
|
161 |
} |
162 |
} |
163 |
catch (Exception e)
|
164 |
{ |
165 |
System.out.println( "删除文件夹操作出错" );
|
166 |
e.printStackTrace(); |
167 |
} |
168 |
} |
169 |
/** |
170 |
* 删除文件夹里面的所有文件 |
171 |
* @param path String 文件夹路径 如 c:/fqf |
172 |
*/ |
173 |
public void delAllFile(String path)
|
174 |
{ |
175 |
File file = new File(path);
|
176 |
if (!file.exists())
|
177 |
{ |
178 |
return ;
|
179 |
} |
180 |
if (!file.isDirectory())
|
181 |
{ |
182 |
return ;
|
183 |
} |
184 |
String[] tempList = file.list(); |
185 |
File temp = null ;
|
186 |
for ( int i = 0 ; i < tempList.length; i++)
|
187 |
{ |
188 |
if (path.endsWith(File.separator))
|
189 |
{ |
190 |
temp = new File(path + tempList[i]);
|
191 |
} |
192 |
else |
193 |
{ |
194 |
temp = new File(path + File.separator + tempList[i]);
|
195 |
} |
196 |
if (temp.isFile())
|
197 |
{ |
198 |
temp.delete(); |
199 |
} |
200 |
if (temp.isDirectory())
|
201 |
{ |
202 |
//delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件 |
203 |
delFolder(path+ File.separatorChar + tempList[i]); //再删除空文件夹
|
204 |
} |
205 |
} |
206 |
System.out.println( "删除文件操作 成功执行" );
|
207 |
} |
208 |
/** |
209 |
* 复制单个文件 |
210 |
* @param oldPath String 原文件路径 如:c:/fqf.txt |
211 |
* @param newPath String 复制后路径 如:f:/fqf.txt |
212 |
*/ |
213 |
public void copyFile(String oldPath, String newPath)
|
214 |
{ |
215 |
try |
216 |
{ |
217 |
int bytesum = 0 ;
|
218 |
int byteread = 0 ;
|
219 |
File oldfile = new File(oldPath);
|
220 |
if (oldfile.exists())
|
221 |
{ |
222 |
//文件存在时 |
223 |
InputStream inStream = new FileInputStream(oldPath); //读入原文件
|
224 |
FileOutputStream fs = new FileOutputStream(newPath);
|
225 |
byte [] buffer = new byte [ 1444 ];
|
226 |
while ( (byteread = inStream.read(buffer)) != - 1 )
|
227 |
{ |
228 |
bytesum += byteread; //字节数 文件大小
|
229 |
System.out.println(bytesum); |
230 |
fs.write(buffer, 0 , byteread);
|
231 |
} |
232 |
inStream.close(); |
233 |
} |
234 |
System.out.println( "删除文件夹操作 成功执行" );
|
235 |
} |
236 |
catch (Exception e)
|
237 |
{ |
238 |
System.out.println( "复制单个文件操作出错" );
|
239 |
e.printStackTrace(); |
240 |
} |
241 |
} |
242 |
/** |
243 |
* 复制整个文件夹内容 |
244 |
* @param oldPath String 原文件路径 如:c:/fqf |
245 |
* @param newPath String 复制后路径 如:f:/fqf/ff |
246 |
*/ |
247 |
public void copyFolder(String oldPath, String newPath)
|
248 |
{ |
249 |
try |
250 |
{ |
251 |
( new File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹
|
252 |
File a= new File(oldPath);
|
253 |
String[] file=a.list(); |
254 |
File temp= null ;
|
255 |
for ( int i = 0 ; i < file.length; i++)
|
256 |
{ |
257 |
if (oldPath.endsWith(File.separator))
|
258 |
{ |
259 |
temp= new File(oldPath+file[i]);
|
260 |
} |
261 |
else |
262 |
{ |
263 |
temp= new File(oldPath+File.separator+file[i]);
|
264 |
} |
265 |
if (temp.isFile())
|
266 |
{ |
267 |
FileInputStream input = new FileInputStream(temp);
|
268 |
FileOutputStream output = new FileOutputStream(newPath + "/" +
|
269 |
(temp.getName()).toString()); |
270 |
byte [] b = new byte [ 1024 * 5 ];
|
271 |
int len;
|
272 |
while ( (len = input.read(b)) != - 1 )
|
273 |
{ |
274 |
output.write(b, 0 , len);
|
275 |
} |
276 |
output.flush(); |
277 |
output.close(); |
278 |
input.close(); |
279 |
} |
280 |
if (temp.isDirectory())
|
281 |
{ |
282 |
//如果是子文件夹 |
283 |
copyFolder(oldPath+ "/" +file[i],newPath+ "/" +file[i]);
|
284 |
} |
285 |
} |
286 |
System.out.println( "复制文件夹操作 成功执行" );
|
287 |
} |
288 |
catch (Exception e)
|
289 |
{ |
290 |
System.out.println( "复制整个文件夹内容操作出错" );
|
291 |
e.printStackTrace(); |
292 |
} |
293 |
} |
294 |
/** |
295 |
* 移动文件到指定目录 |
296 |
* @param oldPath String 如:c:/fqf.txt |
297 |
* @param newPath String 如:d:/fqf.txt |
298 |
*/ |
299 |
public void moveFile(String oldPath, String newPath)
|
300 |
{ |
301 |
copyFile(oldPath, newPath); |
302 |
delFile(oldPath); |
303 |
} |
304 |
/** |
305 |
* 移动文件到指定目录 |
306 |
* @param oldPath String 如:c:/fqf.txt |
307 |
* @param newPath String 如:d:/fqf.txt |
308 |
*/ |
309 |
public void moveFolder(String oldPath, String newPath)
|
310 |
{ |
311 |
copyFolder(oldPath, newPath); |
312 |
delFolder(oldPath); |
313 |
} |
314 |
public static void main(String args[])
|
315 |
{ |
316 |
String aa,bb; |
317 |
boolean exitnow= false ;
|
318 |
System.out.println( "使用此功能请按[1] 功能一:新建目录" );
|
319 |
System.out.println( "使用此功能请按[2] 功能二:新建文件" );
|
320 |
System.out.println( "使用此功能请按[3] 功能三:删除文件" );
|
321 |
System.out.println( "使用此功能请按[4] 功能四:删除文件夹" );
|
322 |
System.out.println( "使用此功能请按[5] 功能五:删除文件夹里面的所有文件" );
|
323 |
System.out.println( "使用此功能请按[6] 功能六:复制文件" );
|
324 |
System.out.println( "使用此功能请按[7] 功能七:复制文件夹的所有内容" );
|
325 |
System.out.println( "使用此功能请按[8] 功能八:移动文件到指定目录" );
|
326 |
System.out.println( "使用此功能请按[9] 功能九:移动文件夹到指定目录" );
|
327 |
System.out.println( "使用此功能请按[10] 退出程序" );
|
328 |
while (!exitnow)
|
329 |
{ |
330 |
FileOperate fo= new FileOperate();
|
331 |
try |
332 |
{ |
333 |
BufferedReader Bin= new BufferedReader( new InputStreamReader(System.in));
|
334 |
String a=Bin.readLine(); |
335 |
int b=Integer.parseInt(a);
|
336 |
switch (b)
|
337 |
{ |
338 |
case 1 :System.out.println( "你选择了功能一 请输入目录名" );
|
339 |
aa=Bin.readLine(); |
340 |
fo.newFolder(aa); |
341 |
break ;
|
342 |
case 2 :System.out.println( "你选择了功能二 请输入文件名" );
|
343 |
aa=Bin.readLine(); |
344 |
System.out.println( "请输入在" +aa+ "中的内容" );
|
345 |
bb=Bin.readLine(); |
346 |
fo.newFile(aa,bb); |
347 |
break ;
|
348 |
case 3 :System.out.println( "你选择了功能三 请输入文件名" );
|
349 |
aa=Bin.readLine(); |
350 |
fo.delFile(aa); |
351 |
break ;
|
352 |
case 4 :System.out.println( "你选择了功能四 请输入文件名" );
|
353 |
aa=Bin.readLine(); |
354 |
fo.delFolder(aa); |
355 |
break ;
|
356 |
case 5 :System.out.println( "你选择了功能五 请输入文件名" );
|
357 |
aa=Bin.readLine(); |
358 |
fo.delAllFile(aa); |
359 |
break ;
|
360 |
case 6 :System.out.println( "你选择了功能六 请输入文件名" );
|
361 |
aa=Bin.readLine(); |
362 |
System.out.println( "请输入目标文件名" );
|
363 |
bb=Bin.readLine(); |
364 |
fo.copyFile(aa,bb); |
365 |
break ;
|
366 |
case 7 :System.out.println( "你选择了功能七 请输入源文件名" );
|
367 |
aa=Bin.readLine(); |
368 |
System.out.println( "请输入目标文件名" );
|
369 |
bb=Bin.readLine(); |
370 |
fo.copyFolder(aa,bb); |
371 |
break ;
|
372 |
case 8 :System.out.println( "你选择了功能八 请输入源文件名" );
|
373 |
aa=Bin.readLine(); |
374 |
System.out.println( "请输入目标文件名" );
|
375 |
bb=Bin.readLine(); |
376 |
fo.moveFile(aa,bb); |
377 |
break ;
|
378 |
case 9 :System.out.println( "你选择了功能九 请输入源文件名" );
|
379 |
aa=Bin.readLine(); |
380 |
System.out.println( "请输入目标文件名" );
|
381 |
bb=Bin.readLine(); |
382 |
fo.moveFolder(aa,bb); |
383 |
break ;
|
384 |
case 10 :exitnow= true ;
|
385 |
System.out.println( "程序结束,请退出" );
|
386 |
break ;
|
387 |
default :System.out.println( "输入错误.请输入1-10之间的数" );
|
388 |
} |
389 |
System.out.println( "请重新选择功能" );
|
390 |
} |
391 |
catch (Exception e)
|
392 |
{ |
393 |
System.out.println( "输入错误字符或程序出错" );
|
394 |
} |
395 |
} |
396 |
} |
397 |
} |
相关推荐
各种字节流的用法①节点流②处理流③流的使用一般步骤④流的关闭具体用法Ⅰ文件流Ⅱ字节数组流Ⅲ缓冲流Ⅳ转换流Ⅴ数据流Ⅵ对象流(序列化和反序列化)Ⅶ打印流(PrintStream)Ⅷ附加:随机访问流最后 前言 今天带来...
一、多种方式读文件内容。 1、按字节读取文件内容 2、按字符读取文件内容 3、按行读取文件内容 4、随机读取文件内容 二、将内容追加到文件尾部
Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
多种方式读文件内容, 按字节读取文件内容、按字符读取文件内容、按行读取文件内容、随机读取文件内容; 多种方式写文件内容, 按字节写文件内容、按字符写文件内容、按行写文件内容 ; 添加内容到文件结尾;文件的...
Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...
Java访问权限控制源代码 1个目标文件 摘要:Java源码,文件操作,权限控制 Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流...
BufferedReader 从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。 BufferedWriter 将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。 ...
Java访问权限控制源代码 1个目标文件 摘要:Java源码,文件操作,权限控制 Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义写到文件的信息、定义文件,输出到c:/hello.txt、写信息到文件、关闭输出流...
2、掌握字节流IO的操作。 3、掌握字符流IO的操作。 4、初步掌握随机流操作。 5、掌握Java数据库开发(JDBC操作)的准备。 6、掌握和理解导入包的类。 三、实验结论和思考 1、完成“6.5.1枚举基础和应用”中【3、星期...
JAVA平台提供了两个类:String和StringBuffer,它们可以储存和操作字符串,即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变...
JAVA平台提供了两个类:String和StringBuffer,它们可以储存和操作字符串,即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要...
9.3.2基于标准输入输出的IO操作 296 9.3.3文件读写及随机访问 297 9.3.4Java的文件管理 297 9.4 Java网络通信 297 9.4.1网络基础知识及Java网络模型 298 9.4.2无连接的数据报 298 9.4.3 Java访问网络资源 298
// 随机文件访问类 private RandomAccessFile ipFile; // 内存映射文件 private MappedByteBuffer mbb; // 单一模式实例 private static volatile IPSeeker instance = null; // 起始地区的开始和结束...
本课程从零开始,以通俗易懂的方式讲解Java技术,手把手教你掌握每一个知识点。 真正做到零基础入门学习,适合初学者的教程! 课程内容包括: 1.File类 2.IO流简介 3.流的分类 输入流、输出流 字节流、字符...