IO-2

/**
 * 
 */
package com.qfedu.Day20.IO.InandOutStream;

import java.io.*;

public class InAndOutDemo {
    public static void main(String[] args) {
        //1.将当前磁盘中的文件读取到内存
        InputStream is = null;
        //2.将内存中数据再次写入到磁盘中
        OutputStream os = null;
        try {
            is = new FileInputStream(new File("D:\\123\\1.jpg"));
            os = new FileOutputStream(new File("img/1.jpg"));
            
            //现在使用的文件字节输入输出流 --> 字节
            //读写流程
            //1.字节数组存储当前数据 一次就是1KB  乘4  乘 8
            byte[] buf = new byte[1024];
            //ps:read方法是有返回值的:实际读取内容的长度
            //若读取到文件的末尾 -1 没有读取到-1继续读取
            int len = 0; //用来存储实际读取额长度
            while( (len = is.read(buf))!=-1) {
                //写出数据
                os.write(buf, 0, len);
            }
            os.flush();
            System.out.println("老子写完了!!!");
    
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
             if(is != null) {
                 try {
                    is.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
             }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
        }

    }

}

/**
 * 
 */
package com.qfedu.Day20.IO.InandOutStream;

import java.io.*;

public class InAndOutDemo2 {
    public static void main(String[] args)throws Exception {
        //1将文件夹中的数据过滤出来
        File srcFile = new  File("Java");
        File desFile = new  File("test");
        File[] files = srcFile.listFiles(new FilenameFilter() {
            /*
             * dir 对应的就是srcFile中的文件路径
             * name 对应的是srcFile中文件路径下的文件名
             */
            @Override
            public boolean accept(File dir, String name) {
                
                return name.endsWith(".java") && new File(dir,name).isFile();
            }
        });
        //2拿到文件的路径,将对应路径的文件写入到新的文件中
        for(File file : files) {
            //构建流对象 输入(读) 输出(写) 
            InputStream is  = new FileInputStream(file);
            OutputStream os = new FileOutputStream(new File(desFile,file.getName()));
             byte[] buf = new byte[1024];
             int len = 0;
             while((len = is.read(buf))!=-1) {
                 os.write(buf, 0, len);
             }
             os.flush();
             System.out.println("老子写完了!!!!");
             //最后完成的流先关闭
             os.close();
             is.close();
        }

    }

}

/**
 * 
 */
package com.qfedu.Day20.IO.Reader;

import java.io.*;

public class ReaderDemo {
    public static void main(String[] args) {
        //1.创建流对象 -->流的流向 (读)
        Reader reader = null;
        try {
            reader = new FileReader("dir/file.txt");
            
            //2.流中数据类型是什么 ---> char类型
            char[] cbuf = new char[1024];
            //实际读取内容的长度
            int len =  0;
            while((len = reader.read(cbuf))!=-1) {
                System.out.println(new String(cbuf,0,len));
            }
            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            if(reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }

}

/**
 * 
 */
package com.qfedu.Day20.IO.Writer;

import java.io.*;

public class WriterDemo {

    public static void main(String[] args) {
        //1.构建流对象 --> 写出去(输出流)
        String str1 = "饿了!";
        String str2 = "今天早饭就吃了一个三明治\n";
        String str3 = "经过了1个半小时 饿了...真的饿\n";
        String str4 = "吃饭去吧!!!!";
        Writer writer = null;
        try {
            //FileWriter和FileInputStrea类似
            //都提供了一个构造方法 这个方法可以在文件的末尾追加新的数据
            //参数是boolean 默认值是false代表不追加 ,若需要追加请使用true
            writer = new FileWriter("dir/饿了么.txt");
            //提供一个特有方法 参数是字符串 将字符串写出去
            writer.write(str1);
            writer.write(str2);
            writer.write(str3);
            writer.write(str4);
            //append 正常使用的效果和wirter是一样的
            //除非使用了 可以追加 不然,一般情况下是不会会使用这个方法
            writer.append("拜拜!!!");
            //出上面这些方法外最常用的就是write(cbuf, off, len);
            writer.flush();
            System.out.println("写完了");
    
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            if(writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    
    }

}

/**
 * 
 */
package com.qfedu.Day20.IO.ReaderAndWriter;

import java.io.*;

public class ReaderAndWriterDemo {
    public static void main(String[] args) {
         //1.构建流对象 --> 流的流向(输入,输出)
         //2.流中的数据应该是 字符
        Reader reader = null;
        Writer writer = null;
        try {
            reader = new FileReader("D:\\123\\2.jpg");
            writer = new FileWriter("img/2.jpg");
            
            //明确了流中的数据是字符
            //创建字符数组存储内容并读取大小
            char[] cbuf = new char[1024];
            //定义变量存储实际读取的长度
            int len = 0;
            while( (len = reader.read(cbuf)) != -1) {
                writer.write(cbuf, 0, len);
            }
            writer.flush();
            System.out.println("写完了!!!!");
        
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            if(writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }

}

/**
 * 
 */
package com.qfedu.Day20.IO.SystemInAndOut;

import java.io.*;

public class SystemInAndOutDemo{
      public static void main(String[] args) {
           //既然要改变流的流向
          //1.就要创建流的流向
          //先构建system.in的流向和构建System.out的流向
          //1.7之后Java提供的新try...catch语法 可以直接释放对象
          //ps若有多个对象使用;隔开,若只有一个对象就不需要分号了
          try(InputStream is = new FileInputStream("src/com/qfedu/Day20/IO/ReaderAndWriter/ReaderAndWriterDemo.java");
                  PrintStream ps = new PrintStream(new File("dir/newJava.java"))){
              //修改当前标准输输出流的流向
              System.setIn(is);//此时System.in就不会在控制台上获取数据了,而是从你定义的流中获取数据
              System.setOut(ps);//此时System.out就不会打印到控制台上了,打印你所定义的流位置
              
              //当前的流都属于字节流
              byte[] buf = new byte[1024];
              int len = 0;
              while((len = System.in.read(buf))!=-1) {
                  System.out.write(buf, 0, len);
              }
             
              //标准输入输出流改变会控制台
              
              //改变流的流向
              
              //1.需要使用
              /*
               * FileOutputStream(FileDescriptor fdObj) 创建一个向指定文件描述符处写入数据的输出文件流
               * 参数是一个文件描述符 ---> 文件句柄
               * 帮组我们将已经改的原有标准输入输出流改回系统
               * 需要两个静态字段(属性)
               * static FileDescriptor in 标准输入流的句柄。 
               * static FileDescriptor out 标准输出流的句柄 
               * 当前流对象就已经获取了系统输出的标准
               */
            PrintStream  ps1 = new PrintStream(new FileOutputStream(FileDescriptor.out));
             System.setOut(ps1);
             System.out.println("老子写完了!!!!!");//不能打印到控制台上,因为改变了流的流向
            
              System.out.flush();
              
          }catch(IOException e) {
              e.printStackTrace();
          }
        
    }
}

/**
 * 
 */
package com.qfedu.Day20.IO.InputStreamReader;

import java.io.*;
import java.nio.charset.Charset;

public class InputStreamReaderDemo {

    public static void main(String[] args) {
        //1.先明确使用的流 流向 (读取 In/read)
        //ps:一定一定要注意,创建流对象时,参数传递的是什么
        //当前就是创建了一个转换流对象,此时就是将字节输入流转换为字符输入流
        //当前是字节转换字符流的基本写法 --->使用的是默认编码GBK
        //  ctrl + / 批量注释
//        InputStreamReader isr = null;
//        try {
//            isr = 
//                    new InputStreamReader(
//                            new FileInputStream(
//                                    new File("src/com/qfedu/Day20/IO/Reader/ReaderDemo.java")));
//            //可以获取当前文件的字符编码
//            //几乎与用不了,这个方法只能在程序运行起来后才能获得当前文件的编码
//            System.out.println("当前文件的字符编码时:"+isr.getEncoding());
//            //2.当前流中的 数据是什么  char字符
//            char[] cbuf = new char[1024];
//            int len = 0;
//            while((len = isr.read(cbuf))!=-1) {
//                 System.out.println(new String(cbuf,0,len));
//            }
//            
//        } catch (FileNotFoundException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        } catch (IOException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }finally {
//            if(isr != null) {
//                try {
//                    isr.close();
//                } catch (IOException e) {
//                    // TODO Auto-generated catch block
//                    e.printStackTrace();
//                }
//            }
//        }
        
        //使用编码集的形式来读取数据
        //当前file1.txt文件的编码时UTF-8
        //此时创建的转换流对象使用的是UTF-8编码集
        try(InputStreamReader isr = 
                new InputStreamReader(
                        new FileInputStream(
                                new File("dir/file1.txt")),Charset.forName("UTF-8"))){
            System.out.println("当前文件编码是:"+isr.getEncoding());
            char[] cbuf = new char[1024];
            int len = 0;
            while((len = isr.read(cbuf))!=-1) {
                //全转换为大写
                System.out.println(new String(cbuf,0,len).toUpperCase());
            }
            
        }catch(IOException e) {
            e.printStackTrace();
        }
        
    }

}

/**
 * 
 */
package com.qfedu.Day20.IO.InputStreamReader;

import java.io.*;
import java.nio.charset.Charset;

public class InputStreamReaderDemo {

    public static void main(String[] args) {
        //1.先明确使用的流 流向 (读取 In/read)
        //ps:一定一定要注意,创建流对象时,参数传递的是什么
        //当前就是创建了一个转换流对象,此时就是将字节输入流转换为字符输入流
        //当前是字节转换字符流的基本写法 --->使用的是默认编码GBK
        //  ctrl + / 批量注释
//        InputStreamReader isr = null;
//        try {
//            isr = 
//                    new InputStreamReader(
//                            new FileInputStream(
//                                    new File("src/com/qfedu/Day20/IO/Reader/ReaderDemo.java")));
//            //可以获取当前文件的字符编码
//            //几乎与用不了,这个方法只能在程序运行起来后才能获得当前文件的编码
//            System.out.println("当前文件的字符编码时:"+isr.getEncoding());
//            //2.当前流中的 数据是什么  char字符
//            char[] cbuf = new char[1024];
//            int len = 0;
//            while((len = isr.read(cbuf))!=-1) {
//                 System.out.println(new String(cbuf,0,len));
//            }
//            
//        } catch (FileNotFoundException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        } catch (IOException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }finally {
//            if(isr != null) {
//                try {
//                    isr.close();
//                } catch (IOException e) {
//                    // TODO Auto-generated catch block
//                    e.printStackTrace();
//                }
//            }
//        }
        
        //使用编码集的形式来读取数据
        //当前file1.txt文件的编码时UTF-8
        //此时创建的转换流对象使用的是UTF-8编码集
        try(InputStreamReader isr = 
                new InputStreamReader(
                        new FileInputStream(
                                new File("dir/file1.txt")),Charset.forName("UTF-8"))){
            System.out.println("当前文件编码是:"+isr.getEncoding());
            char[] cbuf = new char[1024];
            int len = 0;
            while((len = isr.read(cbuf))!=-1) {
                //全转换为大写
                System.out.println(new String(cbuf,0,len).toUpperCase());
            }
            
        }catch(IOException e) {
            e.printStackTrace();
        }
        
    }

}

/**
 * 
 */
package com.qfedu.Day20.IO.NeiCun;

import java.io.*;

public class Demo {
    public static void main(String[] args)throws Exception{
        //showByteArray();
        //1.数据写入字符串流中
        StringWriter writer = new StringWriter();
        writer.write("小龙是什么地方的人?");
        writer.write("河南人");
        writer.write("B哥是什么地方的人?");
        writer.write("火星人");
        
        StringReader reader = new StringReader(writer.toString());
        char[] buffer = new char[1024];
        int len = 0;
        while((len = reader.read(buffer))!=-1) {
            System.out.println(new String(buffer,0,len));
        }
        

    }
    public static void showByteArray()throws Exception {
        //因为,需要将数据先存储到内存数据中然后才能使用内存流将数据读取出来
                //创建字节内存输出流 程序-->内存 写入数据
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                bos.write("ABCDEFG".getBytes());//将数据写入到内存
                //要使用数组来保存数据
                byte[] buffer = bos.toByteArray();
                
                //读取  内存中数据将数据在读取到 --> 程序中
                //参数是一个数组 --> 存储着写入到写入到内存中的数据
                ByteArrayInputStream bis = new ByteArrayInputStream(buffer);
                  byte[] bs = new byte[5];
                  int len = 0;
                  while((len = bis.read(bs))!=-1) {
                      System.out.println(new String(bs,0,len));
                  }
                bis.close();
                bos.close();
                //CharArrayReader 和 CharArrayWriter 使用方式和 byte是一样的 改变数组数据类型即可
    }

}

/**
 * 
 */
package com.qfedu.Day20.IO.BufferedInputStream;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import com.qfedu.Day20.IO.SystemInAndOut.SystemInAndOutDemo;

public class BufferedInputStreamDemo {    
    public static void main(String[] args) {
        //再碰到异常一样要抓取
        //参数是一个字节输入流对象
        try(BufferedInputStream bis = 
                new BufferedInputStream(
                        new FileInputStream(
                                new File("src/com/qfedu/Day20/IO/BufferedInputStream/BufferedInputStreamDemo.java")))){
            //判断当前流对象是否支持mark标记 --> true 支持 false 不支持
            System.out.println("判断是否支持标记:"+bis.markSupported());
            bis.mark(1);//字节个数,给了什么数那么下次读取就在什么位置开始
            byte[] buf = new byte[1024];
            int len = 0;
            while((len = bis.read(buf))!=-1) {
                System.out.println(new String(buf,0,len));
                
            }
            System.out.println("----------------------再次重新读取文件的内容-------------------------");
            bis.reset();//重启标记
            while((len = bis.read(buf))!=-1) {
                System.out.println(new String(buf,0,len));
                
            }
            //一次读取一个节
            /*
             * hello
             * bis.read() --> h
             * bis.read() --> e
             * bis.mark(3) 对多可以读取几个字节
             * bis.read() --> l
             * bis.read() --> l
             * bis.read() --> o
             * bis.reset();
             * bis.read() //llo
            
             * 
             */
            
        }catch(IOException e) {
            e.printStackTrace();
        }

    }

}


/**
 * 
 */
package com.qfedu.Day20.IO.BufferedOutputStream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class BufferedOutputStreamDemo {
    public static void main(String[] args)throws Exception {
        //在控制台上获取数据-->bis流对象就可以在控制台上获取数据
        //ps:Scanner --> 在控制台上获取数据
        BufferedInputStream bis = new BufferedInputStream(System.in);
        PrintStream ps = new PrintStream(new FileOutputStream(new File("dir/字节缓冲流输出的数据.txt")));
        System.setOut(ps);
        //构建标准输出流
        BufferedOutputStream bos = new BufferedOutputStream(System.out);
        //在控制台上输入数据输入什么就写入到对应的文件中
        byte[] bs = new byte[1024];
        int len = 0;
        while(true) {
            //获取控制台输入
            len = bis.read(bs);
           //创建一个字符串
            String content = new String(bs,0,len);
            //只要是输入886,这个程序就停止
            if("886".equals(content)) {
                break;
            }
            bos.write(content.getBytes());
            bos.flush();
        }    
        bos.close();
        bis.close();
    
    }

}