IO笔记总结

在计算机中数据存在两种操作：读和取，对于数据的操作采用流的方式，而计算机只能识别0、1，所以对于任意的文件都可以使用称为字节流的对象来操作。而对于我们操作更多的文本文件，由于各国的码表的不同，对于同一个0、1字串可能得到不同的文字，所以在处理文本的时候必须指定使用哪个码表，于是，为了方便用户，Java为用户提供了封装有码表的字符流。

    常用字符流、字节流的基类：
    字符流--Reader，Writer
    字节流--InputStream，OutputStream

    对于文件的操作，可能会存在操作失败，因此一定要进行异常处理，一种是抛出异常，另一种是try...catch...

    写文件时，我们只是将数据写入流中，要想将数据写入文件，我们需要使用flush()方法将数据真正写入文件，当然还有另一种方式，调用close()方法。flush()方法与close()方法的区别在于，close()方法将数据写入文件后同时将流资源关闭，而flush()方法不关闭流资源。

    还有一点，操作结束后，一定要关闭所有流资源~~~~~

我感觉，学习编程，自己动手用代码实践下学习的内容才能真的学会，变成自己的东西。看到题目或代码要先想到看自己能否用代码实现。下面是我最近浏览csdn论坛时发现的帖子，执行了下，没错。但是，自己感觉在编写代码时就算是自己动手写的别人的代码也比只听或看强的多，希望对朋友们有点帮助吧。

一、多种方式读文件内容。

1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

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("以字节为单位读取文件内容，一次读多个字节：");
      //一次读多个字节
      byte[] tempbytes = new byte[100];
      int byteread = 0;
      in = new FileInputStream(fileName);
      ReadFromFile.showAvailableBytes(in);
      //读入多个字节到字节数组中，byteread为一次读入的字节数
      while ((byteread = in.read(tempbytes)) != -1){
       System.out.write(tempbytes, 0, byteread);
      }
     } catch (Exception e1) {
      e1.printStackTrace();
     } finally {
      if (in != null){
       try {
        in.close();
       } catch (IOException e1) {
       }
      }
     }
  }
  /**
     * 以字符为单位读取文件，常用于读文本，数字等类型的文件
     * @param fileName 文件名
     */
  public static void readFileByChars(String fileName){
     File file = new File(fileName);
     Reader reader = null;
     try {
      System.out.println("以字符为单位读取文件内容，一次读一个字节：");
      // 一次读一个字符
      reader = new InputStreamReader(new FileInputStream(file));
      int tempchar;
      while ((tempchar = reader.read()) != -1){
       //对于windows下，/r/n这两个字符在一起时，表示一个换行。
       //但如果这两个字符分开显示时，会换两次行。
       //因此，屏蔽掉/r，或者屏蔽/n。否则，将会多出很多空行。
       if (((char)tempchar) != '/r'){
        System.out.print((char)tempchar);
       }
      }
      reader.close();
     } catch (Exception e) {
      e.printStackTrace();
     }
     try {
      System.out.println("以字符为单位读取文件内容，一次读多个字节：");
      //一次读多个字符
      char[] tempchars = new char[30];
      int charread = 0;
      reader = new InputStreamReader(new FileInputStream(fileName));
      //读入多个字符到字符数组中，charread为一次读取字符数
      while ((charread = reader.read(tempchars))!=-1){
       //同样屏蔽掉/r不显示
       if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != '/r')){
        System.out.print(tempchars);
       }else{
        for (int i=0; i<charread; i++){
         if(tempchars[i] == '/r'){
          continue;
         }else{
          System.out.print(tempchars[i]);
         }
        }
       }
      }
      
    } catch (Exception e1) {
      e1.printStackTrace();
     }finally {
      if (reader != null){
       try {
        reader.close();
       } catch (IOException e1) {
       }
      }
     }
  }
  /**
     * 以行为单位读取文件，常用于读面向行的格式化文件
     * @param fileName 文件名
     */
  public static void readFileByLines(String fileName){
     File file = new File(fileName);
     BufferedReader reader = null;
     try {
      System.out.println("以行为单位读取文件内容，一次读一整行：");
      reader = new BufferedReader(new FileReader(file));
      String tempString = null;
      int line = 1;
      //一次读入一行，直到读入null为文件结束
      while ((tempString = reader.readLine()) != null){
       //显示行号
       System.out.println("line " + line + ": " + tempString);
       line++;
      }
      reader.close();
     } catch (IOException e) {
      e.printStackTrace();
     } finally {
      if (reader != null){
       try {
        reader.close();
       } catch (IOException e1) {
       }
      }
     }
  }
  /**
     * 随机读取文件内容
     * @param fileName 文件名
     */
  public static void readFileByRandomAccess(String fileName){
     RandomAccessFile randomFile = null;
     try {
      System.out.println("随机读取一段文件内容：");
      // 打开一个随机访问文件流，按只读方式
      randomFile = new RandomAccessFile(fileName, "r");
      // 文件长度，字节数
      long fileLength = randomFile.length();
      // 读文件的起始位置
      int beginIndex = (fileLength > 4) ? 4 : 0;
      //将读文件的开始位置移到beginIndex位置。
      randomFile.seek(beginIndex);
      byte[] bytes = new byte[10];
      int byteread = 0;
      //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
      //将一次读取的字节数赋给byteread
      while ((byteread = randomFile.read(bytes)) != -1){
       System.out.write(bytes, 0, byteread);
      }
     } catch (IOException e){
      e.printStackTrace();
     } finally {
      if (randomFile != null){
       try {
        randomFile.close();
       } catch (IOException e1) {
       }
      }
     }
  }
  /**
     * 显示输入流中还剩的字节数
     * @param in
     */
  private static void showAvailableBytes(InputStream in){
     try {
      System.out.println("当前字节输入流中的字节数为:" + in.available());
     } catch (IOException e) {
      e.printStackTrace();
     }
  }
   
 public static void main(String[] args) {
     String fileName = "C:/temp/newTemp.txt";
     ReadFromFile.readFileByBytes(fileName);
     ReadFromFile.readFileByChars(fileName);
     ReadFromFile.readFileByLines(fileName);
     ReadFromFile.readFileByRandomAccess(fileName);
  }
  }
  二、将内容追加到文件尾部
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.RandomAccessFile;// 将内容追加到文件尾部
  public class AppendToFile {
  public static void appendMethodA(String fileName, String content){
     try { // 打开一个随机访问文件流，按读写方式
      RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
        long fileLength = randomFile.length();  // 文件长度，字节数
       randomFile.seek(fileLength);   //将写文件指针移到文件尾。
      randomFile.writeBytes(content);
      randomFile.close();
     } catch (IOException e){
      e.printStackTrace();
     }
  }
  public static void appendMethodB(String fileName, String content){
     try {
      //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
      FileWriter writer = new FileWriter(fileName, true);
      writer.write(content);
      writer.close();
     } catch (IOException e) {
      e.printStackTrace();
     }
  }
  public static void main(String[] args) {
     String fileName = "C:/temp/newTemp.txt";
     String content = "new append!";
     //按方法A追加文件
     AppendToFile.appendMethodA(fileName, content);
     AppendToFile.appendMethodA(fileName, "append end. /n");
     //显示文件内容
     ReadFromFile.readFileByLines(fileName);
     //按方法B追加文件
     AppendToFile.appendMethodB(fileName, content);
     AppendToFile.appendMethodB(fileName, "append end. /n");
     //显示文件内容
     ReadFromFile.readFileByLines(fileName);
  }
  }
  