java将字节流解析为svg

File类构造方法

是文件和目录路径名的抽象表示；

文件和目录可以通过file封装成对象；

File类构造方法：
实例

File f1 = new File ("/Users/renshengw/Downloads/被讨厌的勇气.pdf");
        System.out.println(f1);
        File f2 =new File("/Users/renshengw/Downloads","被讨厌的勇气.pdf");
        System.out.println(f2);
        File f3 = new File("/Users/renshengw/Downloads");
        File f4 = new File(f3,"被讨厌的勇气.pdf");
        System.out.println(f4);

File类的创建功能

createNewFile()
如果文件不存在就创建文件，并返回true
如果文件存在就不创建文件，并返回false

mkdir()创建目录
mkdirs()创建多级目录；

public static void main(String[] args) throws IOException {
//      创建一个文件
        File f1 = new File ("/Users/renshengw/Downloads/被讨厌的勇气.txt");
        System.out.println(f1.createNewFile());
//创建一个文件目录
        File f2 = new File("/Users/renshengw/Downloads/被讨厌的勇气");
//        System.out.println(f2.mkdir());
        f2.mkdir();
//创建一个多级目录
        File f3 = new File("/Users/renshengw/Downloads/被讨厌的勇气/来吧");
        System.out.println(f3.mkdirs());

File类的判断和获取功能

File f = new File("myfile\\java.txt");//创建一个文件对象
  //调用file类的相关方法
        System.out.println(f.exists());
        System.out.println(f.isFile());
        System.out.println(f.isDirectory());
        System.out.println(f.getAbsoluteFile());
        System.out.println(f.getPath());
        System.out.println(f.getName());
//创建一个抽象路径名表示的目录路径的对象
               File f2 = new File("/Users/renshengw/Documents/Develop/1209biancheng");
        String[] strArray = f2.list();//调用 list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组；
        //遍历得到目录下的文件名
        for (String str :strArray){
            System.out.println(str);
        }
        //调用istFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组
        File[] fileArray = f2.listFiles();
        for (File file: fileArray){
            System.out.println(file);
            if(file.isFile()){//如果是文件则输出
                System.out.println(file.getName());
            }
        }

删除方法：delete

绝对路径：完整的路径名，不需要其他任何信息就可以定位它所表示的文件
相对路径：需要取自其他路径名的信息进行解释

delete删除方法注意事项：
如果一个目录中有内容（目录、文件），不能直接删除，应先删除目录中的内容，最后才能删除目录

递归

概述：以编程的角度来看，递归指的是方法定义中调用方法本身的现象

递归解决问题的思路：
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来解决；
递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算

递归解决问题需要找到两个内容：
递归出口：否则会出现内存溢出；
递归规则：于原问题相似的规模较小的问题；
求阶乘代码实例：

public static void main(String[] args) {
        int result = fc(5);
        System.out.println(result);

    }
    public static int fc(int n){
        if(n==1){
            return 1;
        }else
            {
        return fc(n-1)*n;
        }
    }

遍历目录代码实例：

public static void main(String[] args) {

        File srcfile = new File("/Users/renshengw/Downloads");
        getallfile(srcfile);
    }
    public static void getallfile(File srcfile){
        File[] files = srcfile.listFiles();
        if(files != null){
            for(File file :files){
                if(file.isDirectory()){//如果得到的是目录
                    getallfile(file);//调用获得目录下所有内容
                }else{
                    System.out.println(file.getAbsolutePath());
                }
            }
        }

    }

字节流（input/output）

流：是一种抽象概念，是对数据传输的总称。数据在设备间的传输称为流。

输入流：读数据
输出流：写数据
字节流写数据

InputString、OutputString

InputString这个抽象类是表示输入字节流的所有类的超类
OutputString这个抽象类是表示输入字节流的所有类的超类
子类名称都是以其父类名做后缀的

FileOutputString：文件输出流 ，用于将数据写入File

//        创建对象，让字节输出流对象指向文件
       FileOutputStream fos = new FileOutputStream("1209/file.txt");//这里相当会同时执行new File的动作；
//       写数据
       fos.write(90);
//       释放资源，必备，关闭此输出流
       fos.close();

写数据的3个方法，write(byte[]b,int off, int len)，off是从

Tips：String的一个方法，根据字符串得到一个字节数组：byte[] getBytes()

FileInputString 从文件中读数据

int read()
从该输入流读取一个字节的数据。
int read(byte[] b)
从该输入流读取最多 b.length个字节的数据到一个字节数组。
int read(byte[] b, int off, int len)
从该输入流读取最多 len个字节的数据到字节数组。

FileInputStream fis = new FileInputStream("1209/file2.txt");
        int by =fis.read();
        System.out.println(by);
        //从该输入流读取最多 b.length个字节的数据到一个字节数组
        byte[] byt = new byte[100];
        int some = fis.read(byt);
        System.out.println(some);
        //从该输入流读取最多 len个字节的数据到字节数组。
        System.out.println(new String(byt,0,10));

读数据，到最后一个数据时的返回值是：-1；

用遍历的方式读完所有数据：

//定义一个输入流
        FileInputStream fis = new FileInputStream("1209/file.txt");
        //第一种遍历方式，运用了没有数据返回值是-1这个特点
        int by =fis.read();
        while (by != -1) {
            System.out.print((char) by);//强制将int转换成char，便于阅读
            by = fis.read();
        }
//改进后的第二种遍历方式，定义条件只要写一次
        int bys ;
        while((bys=fis.read())!= -1){
            System.out.print((char)bys);
        }
//释放资源
        fis.close();

字节流写数据换行和追加写入

字节流写数据实现换行符号：
windows \r\n
linux \n
Mac \n

追加写入：
FileOutputStream(String name, boolean append）
在 第二个参数写true，就可以追加了

finally：在异常处理时提供finally块来执行所有清楚操作，比如IO流中的释放资源
特点：被finally控制的语句一定会执行，除非JVM退出；

复制文本文件

同样可用于读文本和图片

FileInputStream fis = new FileInputStream("1209/file.txt");
        FileOutputStream fos = new FileOutputStream("1209/output.txt");
        byte[] byt = new byte[1024];
        int len;
        while((len= fis.read())!= -1){
            fos.write(byt,0,len);
        }
        fos.close();
        fis.close();

字节缓冲流-目的提高字节处理的效率

BufferedOutputString
可以向底层数据输出流写入字节，而不必为写入的每个字节导致底层系统的调用，减少底层调用资源。
BufferedInputString
创建BufferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节。 mark操作会记住输入流中的一个点，并且reset操作会导致从最近的mark操作读取的所有字节在从包含的输入流中取出新字节之前重新读取。

字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作
所以构造方法要传递字节流的对象，其方法与字节流一致

缓冲输出流代码实例：

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("1209/file.txt"));
        bos.write("11".getBytes());
        bos.close();

缓冲输入输出文件copy实例：

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("1209/file.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("1209/output.txt"));
        byte[] byt = new byte[1024];
        int len;
        while ((len = bis.read(byt)) != -1) {
            bos.write(byt, 0, len);
        }
        bos.close();
        bis.close();