1. 字节流：InputStream,OutputStream(抽象类)

2. EOF = End 读到-1就读到结尾

3. 输入流基本方法

   int b = in.read();读取一个字节无符号填充到int低八位。-1是EOF

   in.read(byte[] buf);读取数据填充到字节数组buf

   in.read(byte[] buf,int start,int size);读取数据导字节数组buf，从buf的start位置开始存放size长度的数据

4. 输出流基本方法

   out.write(int b) 写出一个byte到流，b的低8位

   out.write(byte[] buf) 将buf字节数组都写入到流

   out.write(byte[] buf,int start,int size)

5. FileInputStream--->具体实现了在文件上读取数据
   

import os

import os.path

import re

pattern=r"\.\w+$"
def bianli(i):
    if os.path.isdir(i):
        for ii in os.listdir(i):
            ii=i+"\\"+ii
            if os.path.isfile(os.path.abspath(ii)):
                try:
                    s = re.search(pattern, ii).group()
                    print(ii, "-----------是一个%s文件" % s)
                except:
                    print(ii)
            elif os.path.isdir(os.path.abspath(ii)):
                print(ii)
                bianli(ii)
    elif os.path.isfile(i):
        print(i,"是一个文件")
bianli(r"C:\Python27")

Java.IO.File类表示文件或目录，只用于表示文件或目录得信息，不能用于文件的访问。 常用的API： 1.创建File对象：File file=new File(String path);注意：File.seperater();获取系统分隔符，如：”\“. 2.boolean file.exists();是否存在. 3.file.mkdir();或者file.mkdirs();创建目录或多级目录。 4.file.isDirectory()或者file.isFile()判断是否是目录或者是否是文件。 5.file.delete();删除文件或目录。 6.file.createNewFile();创建新文件。 7.file.getName()获取文件名称或目录绝对路径。 8.file.getAbsolutePath()获取绝对路径。 9.file.getParent();获取父级绝对路径。 10.file.getSize();获取文件大小。 11.file.getFormat();获取文件格式名。

gbk编码 中文占2个字节，英文占1个字节 utf-8编码 中文占3个字节 英文占1个字节 utf-16be中文占用2个字节 英文占用也是2个字节。 当你的字节序列是某种编码的时候，这个时候想把字节序列变成字符串，也需要用这种编码方式，否则会出现乱码。 public static void main(String[] args)throws Exception//抛出异常 String s="ABC"; byte[] bytes= s.toBytes("UTF-8"); String s2=new String(bytes,"UTF-8");

序列化中，子类和父类构造函数的调用问题

一个类实现了序列化接口，那么其子类都可以进行序列化

//序列化递归调用了父类的构造函数

//对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用

private transient int stuage;  //被transient修饰时，默认不会被序列化

private void writeObject(java.io.ObjectOutputStream s)

        throws java.io.IOException{

    s.defaultWriteObject();//把jvm（虚拟机）能默认序列化的元素进行序列化操作

    s.writeInt(stuage);//自己完成stuage的序列化

}

private void readObject(java.io.ObjectInputStream s)

        throws java.io.IOException, ClassNotFoundException {

    s.defaultReadObject();//把jvm（虚拟机）能默认反序列化的元素进行反序列化操作

    this.stuage=s.readInt();//自己完成stuage的反序列化操作

transient有些情况下能够帮助提高性能

分析ArrayList可以发现，ArrayList底层虽然是一个数组，但是数组不一定放满了，没有放满的数组元素是不需要序列化的，所以自己来完成有效元素的序列化和反序列化。所以能够提升性能

字符流操作
1）编码问题
2）认识文本和文本文件
java的文本（char）是16位无符号整数，是字符的unicode编码（双字节编码）
文件是byte byte byte......的数据序列
文本文件是文本（char）序列按照某种编码（utf-8，utf-16be，gbk）序列化为byte的结果
3）字符流（Reader，Writer）---->操作的是文本文件
字符的处理，一次处理一个字符
字符的底层仍然是基本的字节序列
字符流的基本实现
    InputStreamReader  完成byte流解析为char流，按照编码解析  可以自定义编码格式
    OutputStreamWriter    提供char流到byte流，按照编码处理
FileWriter    FileReader    
FileWriter fw = new FileWriter("d:/java/javaIO/copy1.txt",true); //有true的时候追加操作   且无法定义编码类型，在不是gbk编码下会出现乱码
字符流的过滤器
    BufferedReader -->readLine一次读一行
    BufferedWriter/PrintWriter --->写一行
通常用 BufferedReader 和 PrintWriter 组合使用来完成字节流的过滤
BufferedReader br = new BufferedReader( //下面的整个构造（2行）可以用new FileReader("d:/java/javaIO/copy1.txt");
    new InputStreamReader( //InputStreamReader可以自定义编码形式
        new FileInputStream("d:/java/javaIO/copy.txt")));
PrintWriter pw = new PrintWriter("d:/java/javaIO/copy3.txt");

IO流：Java输入输出的基础
字节流、字符流

1.字节流
1）InputStream、OutputStream
    InputStream抽象了应用程序读取数据的方式
    OutputStream抽象了应用程序写出数据的方式
2）EOF = End  读到-1就读到结尾
3）输入流基本方法（应用程序从键盘读入程序写到了File.txt文件中去）
int b = in.read(); 读取一个字节无符号填充到int低八位    -1是EOF（结束）    in代表输入流的对象
in.read (byte[] buf) 读取数据填充到字节数组buf
in.read (byte[] buf,int start, int size)    读取数据到字节数组buf，从buf的start位置开始，存放size长度的数据
4）输出流基本方法
out.write（int b）写出一个byte到流，b的低8位
out.write（byte[] buf）将buf中的字节数组都写出到流
out.write（byte[] buf, int start, int size）字节数组buf从start位置开始写size长度的字节到流
5）FileInputStream-->具体实现了在文件上读取数据（继承了InputStream）
6）FileOutputStream-->具体实现了向文件中写出byte数据的方法（继承了OutputStream）
7）DataOutputStream/DaraInputStream
    对“流”功能的扩展，可以更加方便的读取int、long、字符等类型数据
    DataOutputStream
        writeInt() / writeDouble() / writeUTF()
8）BufferInputStream & BufferOutputStream
这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IOde性能
从应用程序中把输入放入文件，相当于将一缸水倒入到另一个缸中：
FileOutputStream-->write()方法：相当于一滴一滴的把水转移过去
DataOutStream-->writeXxx()方法：相当于一瓢一瓢把水转移过去
BufferedOutStream-->write方法更方便，相当于一瓢一瓢先放入桶中，再转移

IO流：Java输入输出的基础
字节流、字符流

1.字节流
1）InputStream、OutputStream
    InputStream抽象了应用程序读取数据的方式
    OutputStream抽象了应用程序写出数据的方式
2）EOF = End  读到-1就读到结尾
3）输入流基本方法（应用程序从键盘读入程序写到了File.txt文件中去）
int b = in.read(); 读取一个字节无符号填充到int低八位    -1是EOF（结束）    in代表输入流的对象
in.read (byte[] buf) 读取数据填充到字节数组buf
in.read (byte[] buf,int start, int size)    读取数据到字节数组buf，从buf的start位置开始，存放size长度的数据
4）输出流基本方法
out.write（int b）写出一个byte到流，b的低8位
out.write（byte[] buf）将buf中的字节数组都写出到流
out.write（byte[] buf, int start, int size）字节数组buf从start位置开始写size长度的字节到流
5）FileInputStream-->具体实现了在文件上读取数据（继承了InputStream）
6）FileOutputStream-->具体实现了向文件中写出byte数据的方法（继承了OutputStream）
7）DataOutputStream/DaraInputStream
    对“流”功能的扩展，可以更加方便的读取int、long、字符等类型数据
    DataOutputStream
        writeInt() / writeDouble() / writeUTF()

列出File的一些常用操作：过滤、遍历等
isDirectory()方法用于判断File类的对象是否是目录
String[] filenames = dir.list(); //返回的是字符串数组，直接子的名称，不包含子目录下的内容
如果要遍历子目录下的内容就需要构造File对象做递归操作吗，File提供了直接返回File对象的api
File[] files = dir.listFiles(); 返回的是直接子目录（文件）的抽象

if(file.isDirectory())

//递归,最终列出包括其子目录下的所有文件（不包含子目录）

listDirectory(file);

File类的使用
java.io.File类用于表示文件（目录）
File类只用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问

file.mkdir();     //file.mkdirs();    //创建这个文件夹
file.delete();//删除这个文件夹

JAVA I/O 输入输出流
    编码问题
    File类的使用
    RandomAcessFile的使用
    字节流的使用
    字符流的使用
    对象的序列化和反序列化

编码：java默认的编码形式 GBK（中文系统下ANSI编码）
    GBK编码：中文占2字节，英文占1字节
    utf-8编码：中文占3字节，英文占1字节
    utf-16be编码：中文占2字节，英文占2字节
编码是什么格式，解码就要用什么格式，否则会报错
文本文件就是字节序列，可以是任意编码的字节序列
如果我们在中文机器上直接创建文本文件，该文本文件只认识ANSI编码（GBK）
联通、联是一种巧合，他们刚好符合了utf-8编码的规则

import java.io.File;
import java.io.IOException;

public class FileUtilTest1 {
    public static void main(String args[]) throws IOException {
        FileUtil.listDirectory(new File("D:\\360安全浏览器下载\\ceshi"));
    }
}

//列出File的一些常用操作，比如过滤，遍历
public class FileUtil {
    /**
     * 列出指定目录下（包括其子目录）的所有文件
     * @param dir
     */
    public static void listDirectory(File dir) throws IOException {
        if (!dir.exists()){
            throw new IllegalArgumentException("目录："+dir+"不存在");
        }
        if (!dir.isDirectory()){
            throw new IllegalArgumentException(dir+"不是目录");
        }
/*
        String[] filenames = dir.list();//返回字符串数组
        for (String string : filenames){
            //列出该目录下直接的（第一层）文件和目录的名称
            System.out.println(string);
            //列出该目录下直接的（第一层）文件和目录,包括父路径
            System.out.println(dir+"\\"+string);
        }
*/
        //如果要遍历子目录下的内容就需要构造File对象做递归操作，File提供了直接返回File对象
        File[] files = dir.listFiles();//返回的是直接的子目录（文件）的抽象
       //并不会递归
//        for (File file : files){
//            //列出该目录下直接的（第一层）文件和目录,包括父路径
//            System.out.println(file);
//        }

        //列出该目录下所有的文件
        if (files != null && files.length > 0){
            for (File file : files){
                if (file.isDirectory()){
                    //递归
                    listDirectory(file);
                }else {
                    System.out.println(file);
                }
            }
        }
    }
}

4）输出流基本方法

out.write（int b）写出一个byte到流，b的低8位   

out.write（byte[]buf）将buf字节数组都写入到流

out.write（byte[]buf，int start，int size）字节数组buf从start位置开始写size长度的字节到流

IO流（输入流、输出流）字节流、字符流

1.字节流

1）InputStream、OutputStream InputStream抽象了应用程序读取数据的方式OutputStream抽象了应用程序写出数据的方式

2）EOF=End 读到-1就读到结尾

3）输入流基本方法

int b=in.read0；读取一个字节无符号填充到int低八位.-1是EOF in.read（bytel buf）读取数据填充到字节数组buf in.read（byte[]buf，int start，int size）读取数据到字节数组buf从buf的start位置开始存放size长度的数据