黑马程序员技术交流社区

标题: java输入流 [打印本页]

作者: stormdzh 时间: 2013-8-5 16:12
标题: java输入流
java.io包       java.io包中的类使得读写文件和处理数据流非常容易.

字节流       要读写字节,程序应使用字节流,即java.io包中InputStream类和OutputStream类的派生类.
            InputStream类和OutputStream类分别为输入流(读取字节的流)和输出流(写入字节的流)提供API和部分实现.

字符流       java.io中字符流的抽象父类是Reader和Writer,读取和写入的类.

输入流       输入流在创建时会自动打开,而用close()方法显式关闭.如图2.2所示的输入流的类的关系:

InputStream    最常见的方法:
            1. int read()    它从输入流读取下一个字节.字节是作为0至255之间的一个int返回的,如果已经达到流的结尾,则返回-1.
            2. long skip(long) 它会跳过和丢弃此输入流的指定数目的字节.返回实际跳过的字节数.
               如果为负数则没有跳过任何字节.

FileInputStream       三种构造函数:
            1.将文件名视为字符串:    FileInputStream f=new FileInputStream("C:/temp.txt");
            2.将File对象视为其参数: FileInputStream f=new FileInputStream(new File("C:/temp.txt"));
            3.将FileDescriptor对象视为其参数 FileInputStream f=new FileInputStream(new FileDescriptor());

ByteArrayInputStream       将字节数组用作源,并在该数组中执行读操作.(两种构造函数)
            1.将字节数组用作参数: ByteArrayInputStream b=new ByteArrayInputStream(buf[]);
            2.从指定的字节数组来创建: ByteArrayInputStream b=new ByteArrayInputStream(buf[],off,len);
               其中 off是要读取的第一个字节的偏移,len是要读入数组的字节数

StringBufferInputStream       与ByteArrayInputStream很相似,不同的是内部缓冲器中的是字符串数组而不是字节数组.

输出流       OutputStream类是抽象类,提供输出流的最小编程接口和部分实现.OutputStream的体系如下:

OutputStream       最常见的方法:
            1. void write(int) 将指定字节写入输出流,被写入的字节参数的八个低位比特,高位比特被忽略.
            2. void close()       关闭此输出流并释放与这个流相关联的资源.
            3. void flush()       刷新此输出流,强制写出任何缓冲输出字节.

FileOutputStream    此类创建文件(如果文件不存在),并将数据写入文件. (四种构造函数)
            1. 将文件名作为字符串: FileOutputStream f=new FileOutputStream("C:/temp.txt");
            2. 将File对象作为其参数: FileOutputStream f=new FileOutputStream(new File("C:/temp.txt"));
            3. 将FileDescriptor对象作为参数 FileOutputStream f=new FileOutputStream(new FileDescriptor());
            4. 将文件名为第一参数,将布尔值作为第二参数.

作者: What/ 时间: 2013-8-8 15:55
有没有详细的代码说明呢？

作者: 赵国刚 时间: 2013-8-9 18:45

  */
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) throws IOException {
//将a。txt封装成file对象。可以将已有的和为出现的文件或者文件夹封装成对象
      File f=new File("a.txt");
      File f2=new File("C:\\ABC","a.txt");
      File d=new File("C:\\ABC");
      File f3=new File(d,"c.txt");
      //在File类中封装的是什么酒打印什么。
      System.out.println(f);
      System.out.println(f2);
      System.out.println(f3);
      //目录分隔符
      method_1();//创建文件
}
//创建文件
public static void method_1() throws IOException{
File file=new File("file.txt");
System.out.println("create:"+file.createNewFile());
}
//删除文件
public static void method_2(){
File file=new File("file.txt");
System.out.println("delete:"+file.delete());
file.deleteOnExit();
}
//文件是否可执行。文件是否存在
public static void method_3() {
File file=new File("file.txt");
System.out.println("execute:"+file.canExecute());
System.out.println("execute:"+file.exists());
}
//创建文件夹
public static void method_4(){
File dir=new File("aa\\dd\\cc");
System.out.println("mkdir:"+dir.mkdir());
System.out.println("mkdir:"+dir.mkdirs());
}
//判断是文件还是文件夹
public static void method_5(){
File file=new File("file.txt");
//记住：在判断文件对象是否是文件或是目录是，必须先判断该文件对象封装的内容是否存在
//通过  exists判断
System.out.println("create:"+file.isDirectory());
System.out.println("create:"+file.isFile());
}
//获取文件路径，重命名
public static void method_6() {

File file=new File("file.txt");
System.out.println("path:"+file.getPath());
System.out.println("path:"+file.getParent());
System.out.println("path:"+file.getAbsolutePath());
File file2=new File("D:\\file2.txt");
System.out.println("path:"+file.renameTo(file2));
}
//获取有效盘符
public static void method_7() {
File[] files=File.listRoots();
for(File f : files){
System.out.println(f);
}}
//获取指定路径下的文件及文件名，包含隐藏文件
      public static void method_8() {
File f=new File("C:\\");
String[] files=f.list();
for(String f1 : files){
System.out.println(f1);
}}
//过滤文件
   public static void method_9() {
  File dir=new File("C:\\");
            String[] arr=dir.list(new FilenameFilter(){
public boolean accept(File dir, String name) {
return name.endsWith(".java");
}
         });
for(String f1 : arr){
System.out.println(f1);
}}}
应用举例：
列出指定文件中的所有文件，包括文件夹中的文件夹下的所有文件。
思路：因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
   在列出过程中出现的还是目录的话，还可以再一次调用本功能，也就是
   函数自身调用自身。这种表现形式，或者变成手法称作递归。
递归要注意：
      1.限定条件。
   2.要注意递归的次数，尽量避免内存溢出。
import java.io.File;
public class FileLists {
public static void main(String[] args) {
File dir =new File("E:\\Program Files\\audio player\\xml");
showDir(dir);
}
private static void showDir(File dir) {
System.out.println(dir);
File[] files=dir.listFiles();//获取文件数组
for(int x=0;x<files.length;x++){
if(files[x].isDirectory()){
showDir(files[x]);
}else{
System.out.println(files[x]);
}}}}
上面的方法也可以列出目录中的隐藏文件。
2/*删除一个带内存的目
  *  删除原理：在window中，删除目录从里往外删除的。
  *       既然从里往外删除，就需要用到递归。
  */
import java.io.File;
public class RemoverDir {
public static void main(String[] args) {
File file=new File("C:\\");
removeDir(file);
}
public static void removeDir(File dir){
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++){
if(files[x].isDirectory()){
removeDir(files[x]);
}else{
System.out.println(files[x].delete());//删除文件
}}
System.out.println(dir.delete());//删除目录
}}
/* Properties是hashtable子类。
  * 也就是说它具有map集合的特点，而且它里面存储的见值队都是字符串
  * 试剂盒中和IO技术相结合的集合容器
  * 该对象的特点：可以用于键值对形式的配置
  * 那么在加载数据时，需要数据有固定格式：键=值。
  *  演示：如何江流中的数据存储到集合中
  *  想要将info。txt中键值数据存到集合中进行操作。
  *    1。用以各留和info.txt文件关联
  *    2.读取一行数据，并将该行数据用“=”进行切割。
  *    3。等号左边作为键，右边作为值，存到Properties集合中即可
  */
import java.io.*；
import java.util.*；
public class JavaFileList {
public static void main(String[] args) throws IOException {
loadDemo();
  storeDemo();
  loadDemo();
}
//用Properties自带的store();将集合中的数据保存到指定文件中
public static void storeDemo() throws IOException{
Properties prop=new Properties();
FileOutputStream fis=new FileOutputStream("C:\\Users\\esws\\Desktop/info.txt");
prop.setProperty("shaghai", "49");
prop.store(fis," 注释，该注释会保留到文件中，由于其前面有“#”所以不会被Properties加载");
}
//用Properties自带的load();将数据加载到集合中
public static void loadDemo() throws IOException{
Properties prop=new Properties();
FileInputStream fis=new FileInputStream("C:\\Users\\esws\\Desktop/info.txt");
prop.load(fis);
prop.list(System.out);
}
//用自己的方法将数据读入到Properies集合中
public static void setGetP() throws IOException{
BufferedReader bufr=new BufferedReader(new FileReader("C:\\Users\\esws\\Desktop/info.txt"));
String line=null;
Properties prop=new Properties();
while((line=bufr.readLine())!=null){
String[] arr=line.split("=");
         prop.setProperty(arr[0],arr[1]);
}}
//用自己的方法列出Properies集合中的数据
public static void setAndGet(Properties p){
Properties prop=p;
Set<String> names =prop.stringPropertyNames();
for(String s :names){
System.out.println(s+":"+prop.getProperty(s));
}}}
Properies在实际开发中的应用
/*用于记录应用程序运行次数
  * 如果使用次数一到，那么给出注册提示。
  * 即使程序结束，该计数器的值也存在。下次程序启动时会先加载计数器的值并加1后重新存储起来。
  * 通常配置文件使用键值对的形式。这样便于阅读数据，并操作数据。
  * 键值对数据时基于map集合
  * 数据是以文本形式存储，使用IO技术。
  * 那么 map+io-->properties.
  * 配置文件可以实现应用程序数据的共享。
  */
import java.io.*；
import java.util.*；
public class Jishuqi {
public static void main(String[] args) throws IOException {
Properties prop=new Properties();//创建Properties对象
File file=new File("C:\\Users\\esws\\Desktop/count.ini");
      if(!file.exists()){//判断文件是否存在
file.createNewFile();
      }
      FileInputStream fis=new FileInputStream(file);
prop.load(fis);//加载文件
int count=0;
      String value=prop.getProperty("time");  //获取键值
      if(value!=null){
      count=Integer.parseInt(value);
      if(count>=5){
      System.out.print("使用次数已到！请注册！");
      return;
      }}
         count++;
      System.out.print("使用"+count+"次");
      prop.setProperty("time", String.valueOf(count));
   FileOutputStream fos=new FileOutputStream(file);
      prop.store(fos, value);//保存Properties文件
      fos.close();
      fis.close();
}
}
/*打印流：
  * 给流提供了打印方法，可以将各种数据类型的数据都原样答引出来。
  * 字节打印流：
  * PrintStream
  * 构造函数可以接收的参数类型：
  * 1.file对象。file
  * 2.字符串路径。String
  * 3.字节输出流。OutputStream
  * PrintWriter
  * 构造函数可以接收的参数类型：
  * 1.file对象。file
  * 2.字符串路径。String
  * 3.字节输出流。OutputStream
  * 4.字符输出流。Writer
  */
总结：

   1. 用来将文件或者文件夹封装成对象。方便对文件与文件夹的属性信息进行操作、
      对文件的处理就是 .创建文件之后就是对文件的增删改查等操作。

   2. Properties是hashtable子类。
      也就是说它具有map集合的特点，而且它里面存储的见值队都是字符串
      试剂盒中和IO技术相结合的集合容器，map+io-->properties.

   3.SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，
      并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，
      依次类推，直到到达包含的最后一个输入流的文件末尾为止

作者: jiahui108 时间: 2013-8-21 08:54
很不错的知识总结，收了

作者: swolice 时间: 2013-8-21 13:58
真不晓得这哥们在说啥。总结输入流的类？

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2