java读取文件Demo代码

  1. import java.io.BufferedReader;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.InputStreamReader;
  8. import java.io.RandomAccessFile;
  9. import java.io.Reader;
  10. public class ReadFromFile {
  11. /**
  12. * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
  13. * @param fileName 文件的名
  14. */
  15. public static void readFileByBytes(String fileName){
  16. File file = new File(fileName);
  17. InputStream in = null;
  18. try {
  19. System.out.println(“以字节为单位读取文件内容,一次读一个字节:”);
  20. // 一次读一个字节
  21. in = new FileInputStream(file);
  22. int tempbyte;
  23. while((tempbyte=in.read()) != -1){
  24. System.out.write(tempbyte);
  25. }
  26. in.close();
  27. } catch (IOException e) {
  28. e.printStackTrace();
  29. return;
  30. }
  31. try {
  32. System.out.println(“以字节为单位读取文件内容,一次读多个字节:”);
  33. //一次读多个字节
  34. byte[] tempbytes = new byte[100];
  35. int byteread = 0;
  36. in = new FileInputStream(fileName);
  37. ReadFromFile.showAvailableBytes(in);
  38. //读入多个字节到字节数组中,byteread为一次读入的字节数
  39. while ((byteread = in.read(tempbytes)) != -1){
  40. System.out.write(tempbytes, 0, byteread);
  41. }
  42. } catch (Exception e1) {
  43. e1.printStackTrace();
  44. } finally {
  45. if (in != null){
  46. try {
  47. in.close();
  48. } catch (IOException e1) {
  49. }
  50. }
  51. }
  52. }
  53. /**
  54. * 以字符为单位读取文件,常用于读文本,数字等类型的文件
  55. * @param fileName 文件名
  56. */
  57. public static void readFileByChars(String fileName){
  58. File file = new File(fileName);
  59. Reader reader = null;
  60. try {
  61. System.out.println(“以字符为单位读取文件内容,一次读一个字节:”);
  62. // 一次读一个字符
  63. reader = new InputStreamReader(new FileInputStream(file));
  64. int tempchar;
  65. while ((tempchar = reader.read()) != -1){
  66. //对于windows下,rn这两个字符在一起时,表示一个换行。
  67. //但如果这两个字符分开显示时,会换两次行。
  68. //因此,屏蔽掉r,或者屏蔽n。否则,将会多出很多空行。
  69. if (((char)tempchar) != ’r'){
  70. System.out.print((char)tempchar);
  71. }
  72. }
  73. reader.close();
  74. } catch (Exception e) {
  75. e.printStackTrace();
  76. }
  77. try {
  78. System.out.println(“以字符为单位读取文件内容,一次读多个字节:”);
  79. //一次读多个字符
  80. char[] tempchars = new char[30];
  81. int charread = 0;
  82. reader = new InputStreamReader(new FileInputStream(fileName));
  83. //读入多个字符到字符数组中,charread为一次读取字符数
  84. while ((charread = reader.read(tempchars))!=-1){
  85. //同样屏蔽掉r不显示
  86. if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != ’r')){
  87. System.out.print(tempchars);
  88. }else{
  89. for (int i=0; i<charread; i++){
  90. if(tempchars[i] == ’r'){
  91. continue;
  92. }else{
  93. System.out.print(tempchars[i]);
  94. }
  95. }
  96. }
  97. }
  98. } catch (Exception e1) {
  99. e1.printStackTrace();
  100. }finally {
  101. if (reader != null){
  102. try {
  103. reader.close();
  104. } catch (IOException e1) {
  105. }
  106. }
  107. }
  108. }
  109. /**
  110. * 以行为单位读取文件,常用于读面向行的格式化文件
  111. * @param fileName 文件名
  112. */
  113. public static void readFileByLines(String fileName){
  114. File file = new File(fileName);
  115. BufferedReader reader = null;
  116. try {
  117. System.out.println(“以行为单位读取文件内容,一次读一整行:”);
  118. reader = new BufferedReader(new FileReader(file));
  119. String tempString = null;
  120. int line = 1;
  121. //一次读入一行,直到读入null为文件结束
  122. while ((tempString = reader.readLine()) != null){
  123. //显示行号
  124. System.out.println(“line ” + line + ”: ” + tempString);
  125. line++;
  126. }
  127. reader.close();
  128. } catch (IOException e) {
  129. e.printStackTrace();
  130. } finally {
  131. if (reader != null){
  132. try {
  133. reader.close();
  134. } catch (IOException e1) {
  135. }
  136. }
  137. }
  138. }
  139. /**
  140. * 随机读取文件内容
  141. * @param fileName 文件名
  142. */
  143. public static void readFileByRandomAccess(String fileName){
  144. RandomAccessFile randomFile = null;
  145. try {
  146. System.out.println(“随机读取一段文件内容:”);
  147. // 打开一个随机访问文件流,按只读方式
  148. randomFile = new RandomAccessFile(fileName, ”r”);
  149. // 文件长度,字节数
  150. long fileLength = randomFile.length();
  151. // 读文件的起始位置
  152. int beginIndex = (fileLength > 4) ? 4 : 0;
  153. //将读文件的开始位置移到beginIndex位置。
  154. randomFile.seek(beginIndex);
  155. byte[] bytes = new byte[10];
  156. int byteread = 0;
  157. //一次读10个字节,如果文件内容不足10个字节,则读剩下的字节。
  158. //将一次读取的字节数赋给byteread
  159. while ((byteread = randomFile.read(bytes)) != -1){
  160. System.out.write(bytes, 0, byteread);
  161. }
  162. } catch (IOException e){
  163. e.printStackTrace();
  164. } finally {
  165. if (randomFile != null){
  166. try {
  167. randomFile.close();
  168. } catch (IOException e1) {
  169. }
  170. }
  171. }
  172. }
  173. /**
  174. * 显示输入流中还剩的字节数
  175. * @param in
  176. */
  177. private static void showAvailableBytes(InputStream in){
  178. try {
  179. System.out.println(“当前字节输入流中的字节数为:” + in.available());
  180. } catch (IOException e) {
  181. e.printStackTrace();
  182. }
  183. }
  184. public static void main(String[] args) {
  185. String fileName = ”C:/temp/newTemp.txt”;
  186. ReadFromFile.readFileByBytes(fileName);
  187. ReadFromFile.readFileByChars(fileName);
  188. ReadFromFile.readFileByLines(fileName);
  189. ReadFromFile.readFileByRandomAccess(fileName);
  190. }
  191. }
  192. 二、将内容追加到文件尾部
  193. import java.io.FileWriter;
  194. import java.io.IOException;
  195. import java.io.RandomAccessFile;
  196. /**
  197. * 将内容追加到文件尾部
  198. */
  199. public class AppendToFile {
  200. /**
  201. * A方法追加文件:使用RandomAccessFile
  202. * @param fileName 文件名
  203. * @param content 追加的内容
  204. */
  205. public static void appendMethodA(String fileName,
  206. String content){
  207. try {
  208. // 打开一个随机访问文件流,按读写方式
  209. RandomAccessFile randomFile = new RandomAccessFile(fileName, ”rw”);
  210. // 文件长度,字节数
  211. long fileLength = randomFile.length();
  212. //将写文件指针移到文件尾。
  213. randomFile.seek(fileLength);
  214. randomFile.writeBytes(content);
  215. randomFile.close();
  216. } catch (IOException e){
  217. e.printStackTrace();
  218. }
  219. }
  220. /**
  221. * B方法追加文件:使用FileWriter
  222. * @param fileName
  223. * @param content
  224. */
  225. public static void appendMethodB(String fileName, String content){
  226. try {
  227. //打开一个写文件器,构造函数中的第二个参数true表示以追加形式写文件
  228. FileWriter writer = new FileWriter(fileName, true);
  229. writer.write(content);
  230. writer.close();
  231. } catch (IOException e) {
  232. e.printStackTrace();
  233. }
  234. }
  235. public static void main(String[] args) {
  236. String fileName = ”C:/temp/newTemp.txt”;
  237. String content = ”new append!”;
  238. //按方法A追加文件
  239. AppendToFile.appendMethodA(fileName, content);
  240. AppendToFile.appendMethodA(fileName, ”append end. n”);
  241. //显示文件内容
  242. ReadFromFile.readFileByLines(fileName);
  243. //按方法B追加文件
  244. AppendToFile.appendMethodB(fileName, content);
  245. AppendToFile.appendMethodB(fileName, ”append end. n”);
  246. //显示文件内容
  247. ReadFromFile.readFileByLines(fileName);
  248. }
  249. }


发表评论

电子邮件地址不会被公开。 必填项已用 * 标注

*

您可以使用这些 HTML 标签和属性: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

(Spamcheck Enabled)