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. 将文件名为第一参数,将布尔值作为第二参数.

真不晓得这哥们在说啥。总结输入流的类？

很不错的知识总结，收了

  */
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 表示其他输入流的逻辑串联。它从 输入流的有序集合开始，
        并从第一个输入流开始读取， 直到到达文件末尾，接着从第二个输入流读取，
        依次类推，直到到达包含的最后一个输入流的文件末尾为止

有没有详细的代码说明呢？