java io 多种文件操作方式（字节、字符、行、随机）

一、多种方式读文件内容。【参考：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

}