文章目录

• • @[TOC](文章目录)
• File
• 递归
• IO流
• • 字节流
  • • FileInputStream
    • FileOutputStream
    • BufferedInputStream
    • BufferedOutputStream
  • 字符流
  • • FileReader
    • FileWriter
    • BufferedReader
    • BufferedWriter
  • 字节流字符流转换
  • • 字节转字符
    • 字符转字节
• 序列化
• 反序列化
• 泛型

File

public class TestFile {
    public static void main(String[] args) throws Exception{
        //方式一：public File(String pathname)
        File file =new File("E:\\Test\\1.txt");
        //File file =new File("E:/Test/1.txt"); 也可以这样写路径
        System.out.println(file);   //重写了toString()方法
        //当没有打印内存地址，都是重写了toString()方法

        //方式二
        File file1=new File("E:\\Test","1.txt");	//(父路径，子路径)
        //方式三
        File parent=new File("E:\\Test");
        File file2=new File(parent,"1.txt");

        System.out.println(file.length());	//获取文件的长度（以字节为单位）
        System.out.println(file.exists());  //文件是否存在
        System.out.println(file.isFile());  //是否是文件
        System.out.println(file.isDirectory()); //是否是目录
        System.out.println(file.getName()); //获取名字
        System.out.println(file.getParent());   //获取文件父路径
        System.out.println(file.getAbsolutePath()); //获取文件的绝对路径

        //创建更新功能
        File file3;
        file3 = new File("E:\\Test\\1.txt");
        System.out.println(file.createNewFile());   //创建新的文件
        file3 =new File("E:\\Test\\m");
        System.out.println(file.mkdir());   //创建失败，父目录不存在
        file3 =new File("E:\\Test1\\m");
        System.out.println(file.mkdirs());  //创建成功，连父目录文件一起创建
        System.out.println(file3.renameTo(new File("E:\\Test1\\M")));    //重命名
        /*
        mkdir()和mkdirs()：
        	方法都是用于创建指定路径名称对应的目录(文件夹)
        	都是无参数，返回值都为boolean类型
        	使用 mkdir ()方法创建时，父目录必须存在，否则无法创建成功
        	使用 mkdirs()方法创建时，如果父目录不存在，则会连父目录一起创建
        */

        File file4 =new File("E:\\Test");
        String [] list=file4.list();
        System.out.println(Arrays.toString(list));	//返回子路径的目录列表
        File [] file5=file4.listFiles();
        System.out.println(Arrays.toString(file5));	//返回父路径和子路径的目录列表
    }
}

递归

  递归三要素：
  	1.递归的结束条件
  	2.递归的函数关系 
  	3.调用自身

//实现斐波那契数列1，2，3，5，8，13，21
public static void main(String[] args) {
    System.out.println(method(6));
public static int method(int n){
	if(n==0) return 1;
	if(n==1) return 2;
	return f(n-1)+f(n-2);
    }

//递归实现阶乘
public static void main(String[] args) {
    System.out.println(method(5));	
public static int method(int i){
        if (i==1) return 1;
        return i*method(i-1);
    }

//递归实现数列 2，3，4，9，8，27，16，81
public static void main(String[] args) {
    System.out.println(method(7));
}
public static int method(int i){
	if(i==0) return 2;
    if(i==1) return 3;
    if (i%2==0) {
        return method2(i-2)*2;
    }
	return 3*method2(i-2);

//递归目录
public class MuLu {
    public static void main(String[] args) {
        File file=new File("E:\\Test");
        diguiFolder(file);
    }
    public static void diguiFolder(File file){
        //判断当前File是否存在，如果不存在，则提前结束此方法
        if (!file.exists()){
            System.out.println("文件或目录不存在");
            return; //当return无返回值，表示提前结束循环
        }
        //文件存在，判断是否为文件，是文件则输出（无下级，结束方法），
        if (file.isFile()){
            System.out.println("文件没有下级");
            return;
        }
        //不是文件则递归获取文件夹目录下所有的子文件子目录，组成一个file数组
        File[] files=file.listFiles();
        //遍历数组中的每一个对象,数组中元素可能是文件也可能是目录
        for (int i = 0; i < files.length; i++) {
            if (files[i].isFile()){
                System.out.println(files[i]+"文件");
            }else {
                //是目录，先输出，在递归
                System.out.println(files[i]);
                diguiFolder(files[i]);
            }
        }
    }
}

//复制文件
 public static void main(String[] args) throws Exception{
	//复制文件内容到另一个文件中
	String s="E:\\Test\\m\\11.txt";	//需要复制的文件位置
	String t="E:\\Test\\m\\22.txt";	//写入的文件的位置
	FileInputStream in=new FileInputStream(s);
	FileOutputStream out=new FileOutputStream(t);
	int i;
	while ((i=in.read()) !=-1){//此处避免了跳跃读写
		out.write(i);
	}
	out.close();
	in.close();
	System.out.println("复制完成");
}

IO流

  输入流（硬盘到Java程序）：
  			字节输入流  InputStream  （万能流） byte
  			FileInputStream：文件字节输入流，BufferedInputStream：缓冲字节输入流
  			字符输入流  Reader  char  （只能处理记事本能打开的且能正常显示的）
  			FileReader：文件字符输入流，BufferedReader：缓冲字符输入流
  输出流（Java程序到硬盘）：
  			字节输出流  OutputStream （万能流） byte
  			FileOutputStream：文件字节输出流，BufferedOutputStream：缓冲字节输出流
  			字符输出流  Writer  char  （只能处理记事本能打开的且能正常显示的）
  			FileWriter：文件字符输出流，BufferedWriter：缓冲字符输出流

字节流

FileInputStream

public class InDemo {
    public static void main(String[] args) throws Exception{
        //创建FileInputStream对象，并指定对象
        FileInputStream in=new FileInputStream("E:\\Test\\m\\11.txt");
        //调用字节输入流对象读数据的方法，将文件的数据读取到程序中
        //通过read方法读文件中的一个字节
        System.out.println(in.read());  //ASCII码
        System.out.println((char)in.read()); //返回char值
        //要返回文件中全部内容，使用循环（不知道循环多少次，用while）
        int i;
        while ((i=in.read()) !=-1){
            System.out.println((char) i);
        }
        in.close();	//关流
    }
}

FileOutputStream

public class OutDemo {
    public static void main(String[] args) throws Exception{
        //创建一个FileOutputStream指向指定文件
        //方式一
        /*File file=new File("E:\\Test\\m\\11.txt");
        FileOutputStream out=new FileOutputStream(file);*/
        //方式二	一般使用方式二
        FileOutputStream out=new FileOutputStream("E:\\Test\\m\\11.txt",false);
        //调用字节输出流对象写数据的方法，将数据写入文件当中
        //传入int型数值，返回对应ASCII码值
        out.write(65);//A
        out.write("\r\n".getBytes());	// \r\n用于换行

        //传入byte型数组，输出数组中的字节数据
        byte [] b={'a','b','c'}; //abc
        out.write(b);
        out.write("\r\n".getBytes());

        //将字符串转成数组，再写出byte数组中的所有数据
        out.write("123".getBytes()); //123
        out.write("\r\n".getBytes());

        //byte类型数组，从哪个下标开始的多少长度的，输出byte数组中的一部分字节
        out.write("hellojava".getBytes(),0,5); //hello
        out.close();
        System.out.println("数据写出成功，关闭流");
    }
}

BufferedInputStream

public class FISDemo {
    public static void main(String[] args) throws Exception{
        //创建FileInputStream对象，指向指定文件
        FileInputStream fis=new FileInputStream("E:\\Test\\m\\11.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);
        //通过BufferedInputStream读方法读取数据
        int i;
        while ((i=bis.read()) !=-1){
            System.out.println((char) i);
        }
        bis.close();
    }
}

BufferedOutputStream

public class BOSDemo {
    public static void main(String[] args) throws Exception{
        //创建BufferedOutputStream字节缓冲输出流对象
        OutputStream os=new FileOutputStream("E:\\Test\\m\\11.txt");
        BufferedOutputStream bos=new BufferedOutputStream(os);
        //调用写数据的方法，写数据到指定文件中
        //输出单个字节,方式一
        bos.write(65);
        bos.write('\r');
        bos.write('\n');
        //方式二：byte类型数组
        byte[] bs={'a', 'c','\r','\n'};
        bos.write(bs);
        bos.close();
    }
}

字符流

FileReader

public class FileReaderDemo {
    public static void main(String[] args) throws Exception{
        //创建FileReader字符输入流对象，读取指定文件中内容
        /*//方式一，通过File对象
        File file=new File("E:\\Test\\m\\33.txt");
        FileReader fr=new FileReader(file);*/
        //方式二
        FileReader fr=new FileReader("E:\\Test\\m\\33.txt");
        int i;
        while ((i=fr.read()) !=-1){
            System.out.print((char) i);
        }
        fr.close();
    }
}

FileWriter

public class FileWriterDemo {
    public static void main(String[] args) throws Exception{
        //创建FileWriter字符输出流对象
        /*//方式一
        File file=new File("E:\\Test\\m\\22.txt");
        FileWriter fw=new FileWriter(file);*/
        //方式二：
        FileWriter fw=new FileWriter("E:\\Test\\m\\22.txt",true);
        //调用写数据方法write（int b）
        fw.write(65);
        fw.write(66);
        fw.write('\r');
        fw.write('\n');
        //write（char[] ch）
        char[] ch={'c','d'};
        fw.write(ch);
        //write(char[] ch,0,1),数组的一部分
        fw.write("0123456789".toCharArray(),0,6);
        //write(String str)
        fw.write("helloworld\r\n");
        //write(String str,0,5),字符串的一部分
        fw.write("helloworld\r\n",0,5);
        fw.flush();	//强制刷新并写入
        fw.close();
    }
}

BufferedReader

public class BufferedReaderDemo {
    public static void main(String[] args) throws Exception{
        Reader r=new FileReader("E:\\Test\\m\\44.txt");
        BufferedReader br=new BufferedReader(r);
        System.out.println((char) br.read());
        System.out.println(br.readLine());
        String i;
        while((i=br.readLine())!=null) {	
        //BufferedReader特殊方法readLine表示读取一行
            System.out.println(i);
        }
        br.close();
    }
}

BufferedWriter

public class BufferedWriterDemo {
    public static void main(String[] args) throws Exception{
        //创建BufferedWriter缓冲区的字符输出流
        Writer fw=new FileWriter("E:\\Test\\m\\33.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        //调用写数据方法write（int b）
        bw.write(65);
        bw.write(66);
        bw.newLine();//Buffered特有方法，换行
        //write（char[] ch）
        char[] ch={'c','d'};
        bw.write(ch);
        //write(char[] ch,0,1),数组的一部分
        bw.write("0123456789".toCharArray(),0,6);
        //write(String str)
        bw.write("helloworld");
        bw.newLine();
        //write(String str,0,5),字符串的一部分
        bw.write("helloworld",0,5);
        bw.newLine();	//表示换行
        
        bw.flush();
        bw.close();
    }
}

字节流字符流转换

字节转字符

public static void main(String[] args) throws Exception{
        //通过FileWriter字符输出流往文件中写数据的时候，默认字符集为GBK
        FileWriter writer=new FileWriter("E:\\Test\\1.txt",true);
        							//true表示在文件内容后追加新内容
        System.out.println(writer.getEncoding());//UTF8
        writer.write("平亿近人");
        writer.close();
        System.out.println("成功写入");
    }

字符转字节

 public static void main(String[] args) throws Exception{
        //创建一个FileOutputStream字节输出流对象，指向指定文件
        FileOutputStream fos=new FileOutputStream("E:\\Test\\1.txt",true);
        //通过OutputStreamReader将字节流转成字符流，并指定字符集为utf-8
        OutputStreamWriter writer=new OutputStreamWriter(fos,"utf-8");
        //写数据
        writer.write("甜崽，你好");
        writer.flush();
        fos.close();
        System.out.println("成功写出");
    }

序列化

   ObjectOutputStream类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。
  需要序列化的类必须实现 java.io.Serializable 接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出异常
  该类中如果有属性不需要序列化的，则该属性必须使用transient 关键字修饰

public class XuLieHua {
   // 将对象序列化到磁盘文件中
    public static void main(String[] args) throws Exception{
        //创建ObjectOutputStream流对象，用于序列化Java对象
        FileOutputStream fos=new FileOutputStream("E:\\Test\\Student.ser");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //创建Student对象，将对象序列化到磁盘中
        Student stu1=new Student("tom",24);
        //开始序列化
        oos.writeObject(stu1);
        //关流
        oos.close();
        System.out.println("序列化完成");
    }
}
class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override	//重新toString方法
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

反序列化

  ObjectInputStream类可将字节序列从文件中读取回来，重构对象

public class FanXuLieHua {
    //将二进制文件反序列化为内存中的对象
    public static void main(String[] args) throws Exception{
        //创建ObjectInputStream对象流，用于反序列化二进制文件到内存中重新形成对象
        InputStream fis=new FileInputStream("E:\\Test\\Student.ser");
        ObjectInputStream ois=new ObjectInputStream(fis);
        //将序列化的磁盘文件转成Java对象
        Object o=ois.readObject();//编译向左看，运行向右看
        Student student=(Student) o;//强转
        //测试Java对象
        System.out.println(student.toString());
    }
}

泛型

  泛型可以使用在集合上，<E>Element:元素    <K,V>Key：键，value：值  <N>Number：数值    <？>：表示不确定类型
  泛型可以使用在方法上，<T>Type：类型   T是对参数的描述
  泛型可以使用在类或接口上，<T>Type：类型    修饰符 class 类名<T>{}

public class FanXingDemo {
    public static void main(String[] args) {
        Integer[] arr={1,2,3};
        Double[] arr1={1.1,2.2,3.3};
        String[] arr2={"a","b","c"};
        new  Method<Integer>().tostr(arr);
        new  Method<Double>().tostr(arr1);
        new  Method<String>().tostr(arr2);
     //泛型方法
    public static <T>void printArr(T[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
class Method<T>{	//因为泛型在类中作用于整个类中，所以声明方法时可不写，但参数需要写
    public void tostr(T[] arr){
        System.out.println(Arrays.toString(arr));
    }
}

  小贴士

  	流使用完需要用close关闭流

  	缓冲流的效率高比其他流高

  	InputStream，Reader，OutputStream，Writer类都是抽象类，不可以创建对象

  	InputStream是所有字节输入流的父类

  	OutputStream是所有字符输出流的父类

  	Reader是读取字符流所有类的父类

  	Writer是写出字符流所有类的父类

  	如果文件中的数据和写入的数据的字符集编码不同，就会出现乱码

  	泛型在类中作用范围是整个类