程序博客网 > 死亡扳机2网络通信失败

Java读取文件

来源：互联网 发布：死亡扳机2网络通信失败 编辑：程序博客网 时间：2024/05/17 03:49
一、File 类关注的是文件在磁盘上的存储，而FileInputStream流类关注的是文件的内容。
二、关于InputStream和Reader；
InputStream提供的是字节流的读取，使用InputStream读取出来的是byte数组，而非文本读取，用Reader读取出来的是char数组或者String，这是InputStream和Reader类的根本区别。
InputStreamReader可以将读如stream转换成字符流方式，是reader和stream之间的桥梁.
Reader类及其子类提供的字符流的读取char（16位,unicode编码），inputStream及其子类提供字节流的读取byte（8位），所以FileReader类是将文件按字符流的方式读取，FileInputStream则按字节流的方式读取文件；
FileInputStream以字节为单位（非 unicode ）的流处理。字节序列即：二进制数据。与编码无关，不存在乱码问题。
FileInputStream ：以字节流方式读取；
FileReader ：把文件转换为字符流读入；
三、常用的Reader类
 FileReader ，InputStreamReader ，BufferedReader
 FileReader 与 InputStreamReader 涉及编码转换，可能在不同的平台上出现乱码现象。
 （FileInputStream 以二进制方式处理，不会出现乱码现象。）
FileReader是InputStreamReader 类的子类。
InputStreamReader 的构造函数参数为InputStream 和编码方式，当要指定编码方式时，必须使用 InputStreamReader 类。
FileReader 构造函数的参数与 FileInputStream 同，为 File 对象或表示 path 的 String。
1、FileReader的用法
FileReader fr = new FileReader("file.txt");
char[] buffer = new char[1024];
int ch = 0;
while((ch = fr.read())!=-1 )
{
　 System.out.print((char)ch);
}
2、InputStreamReader的用法
InputStreamReader isr = new InputStreamReader(new FileInputStream("file.txt"));
while((ch = isr.read())!=-1)
{
　System.out.print((char)ch);
}
3、BufferedReader的用法。
BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取分行文本很适合，BufferedReader是针对Reader的，不直接针对文件，也不是只针对文件读取。
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("file.txt")));
String data = null;
while((data = br.readLine())!=null)
{
　System.out.println(data);
}
一、File 类关注的是文件在磁盘上的存储，而FileInputStream流类关注的是文件的内容。
二、关于InputStream和Reader；
InputStream提供的是字节流的读取，使用InputStream读取出来的是byte数组，而非文本读取，用Reader读取出来的是char数组或者String，这是InputStream和Reader类的根本区别。
InputStreamReader可以将读如stream转换成字符流方式，是reader和stream之间的桥梁.
Reader类及其子类提供的字符流的读取char（16位,unicode编码），inputStream及其子类提供字节流的读取byte（8位），所以FileReader类是将文件按字符流的方式读取，FileInputStream则按字节流的方式读取文件；
FileInputStream以字节为单位（非 unicode ）的流处理。字节序列即：二进制数据。与编码无关，不存在乱码问题。
FileInputStream ：以字节流方式读取；
FileReader ：把文件转换为字符流读入；
三、常用的Reader类
 FileReader ，InputStreamReader ，BufferedReader
 FileReader 与 InputStreamReader 涉及编码转换，可能在不同的平台上出现乱码现象。
 （FileInputStream 以二进制方式处理，不会出现乱码现象。）
FileReader是InputStreamReader 类的子类。
InputStreamReader 的构造函数参数为InputStream 和编码方式，当要指定编码方式时，必须使用 InputStreamReader 类。
FileReader 构造函数的参数与 FileInputStream 同，为 File 对象或表示 path 的 String。
1、FileReader的用法
FileReader fr = new FileReader("file.txt");
char[] buffer = new char[1024];
int ch = 0;
while((ch = fr.read())!=-1 )
{
　 System.out.print((char)ch);
}
2、InputStreamReader的用法
InputStreamReader isr = new InputStreamReader(new FileInputStream("file.txt"));
while((ch = isr.read())!=-1)
{
　System.out.print((char)ch);
}
3、BufferedReader的用法。
BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取分行文本很适合，BufferedReader是针对Reader的，不直接针对文件，也不是只针对文件读取。
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("file.txt")));
String data = null;
while((data = br.readLine())!=null)
{
　System.out.println(data);
}
一、File 类关注的是文件在磁盘上的存储，而FileInputStream流类关注的是文件的内容。
二、关于InputStream和Reader；
InputStream提供的是字节流的读取，使用InputStream读取出来的是byte数组，而非文本读取，用Reader读取出来的是char数组或者String，这是InputStream和Reader类的根本区别。
InputStreamReader可以将读如stream转换成字符流方式，是reader和stream之间的桥梁.
Reader类及其子类提供的字符流的读取char（16位,unicode编码），inputStream及其子类提供字节流的读取byte（8位），所以FileReader类是将文件按字符流的方式读取，FileInputStream则按字节流的方式读取文件；
FileInputStream以字节为单位（非 unicode ）的流处理。字节序列即：二进制数据。与编码无关，不存在乱码问题。
FileInputStream ：以字节流方式读取；
FileReader ：把文件转换为字符流读入；
三、常用的Reader类
 FileReader ，InputStreamReader ，BufferedReader
 FileReader 与 InputStreamReader 涉及编码转换，可能在不同的平台上出现乱码现象。
 （FileInputStream 以二进制方式处理，不会出现乱码现象。）
FileReader是InputStreamReader 类的子类。
InputStreamReader 的构造函数参数为InputStream 和编码方式，当要指定编码方式时，必须使用 InputStreamReader 类。
FileReader 构造函数的参数与 FileInputStream 同，为 File 对象或表示 path 的 String。
1、FileReader的用法
FileReader fr = new FileReader("file.txt");
char[] buffer = new char[1024];
int ch = 0;
while((ch = fr.read())!=-1 )
{
　 System.out.print((char)ch);
}
2、InputStreamReader的用法
InputStreamReader isr = new InputStreamReader(new FileInputStream("file.txt"));
while((ch = isr.read())!=-1)
{
　System.out.print((char)ch);
}
3、BufferedReader的用法。
BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取分行文本很适合，BufferedReader是针对Reader的，不直接针对文件，也不是只针对文件读取。
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("file.txt")));
String data = null;
while((data = br.readLine())!=null)
{
　System.out.println(data);
}
java中多种方式读文件

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

阅读全文
0 0
死亡扳机2网络通信失败 死亡扳机2网络通信失败
原创粉丝点击
热门IT博客
小米手机如何迁移数据小米手机如何迁移数据
莫扎特 知乎莫扎特 知乎
哪里买域名
淘宝棉衣女装新款
尼古拉的遗嘱 知乎
软件狗软件怎么破解
手机淘宝装修日记
农村淘宝面试几天
加钱不发顺丰 淘宝
python远程监控服务器
孤岛惊魂4 低端优化
淘宝是不是搜索引擎
记入成绩的软件
encore制谱软件
ubuntu ssh安装包下载
大数据舆情分析是什么
做淘宝什么最赚钱
淘宝上新率是什么
淘宝女装尺码表模板
淘宝导购系统
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 阴茎发育小怎么办 脸上长包怎么办 脸上起包怎么办 裤裆突出怎么办 冬天要穿正装怎么办 西装粘毛怎么办 西装太大了怎么办 哺乳期感冒发烧怎么办 哺乳期重感冒怎么办 汽车发动机漏油怎么办 avgigi打不开怎么办 艺考落榜怎么办 火锅店没生意怎么办 火锅店生意差怎么办 初期怀孕怎么办 多发性脂肪瘤怎么办 脂肪瘤是恶性怎么办 皮肤脂肪粒怎么办 月经过后肚子痛怎么办 内脏脂肪偏高怎么办 上唇太厚怎么办 方舟生病了怎么办 发现大蟒蛇怎么办 肛门有硬块怎么办 肠子不蠕动怎么办 肠子痛怎么办 肠子溃疡怎么办 肠子里有气怎么办 肠子胀气怎么办 肠子痉挛怎么办 肠子粘连怎么办 虐缘怎么办 系统资源不足怎么办 小儿夜惊怎么办 小孩夜惊症频繁怎么办 宝宝夜惊怎么办 孩子夜惊怎么办 小孩不吃东西怎么办 种子下不动怎么办 种子下不了怎么办 苹果没有迅雷怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里