泛型 File IO流

wmd13164306712

已于 2022-04-21 13:10:31 修改

阅读量555

点赞数

文章标签： java

于 2022-04-20 16:33:02 首次发布

本文链接：https://blog.csdn.net/wmd13164306712/article/details/124295194

版权

1.1 什么是泛型？

1. 泛型就是限制我们得数据类型。

2.为什么使用泛型?
我们原来在定义集合时，是如下得定义方式：
List list=new ArrayList();//该集合没有使用泛型
list.add("java01");
list.add("java02");

String str= (String) list.get(0);//获取元素需要进行强制类型转换
System.out.println(str);
获取元素时，不方便对元素进行相应得其他操作。

1.2 如何使用泛型

List<类型> list=new ArrayList<类型>(); 只能在该集合中存储指定得类型

  public static void main(String[] args) {
        List<String> list=new ArrayList<>();//这里就限制了集合中每个元素的类型为字符串类型。
        list.add("java01");
        list.add("hello"); //因为集合中只能添加String类型
        list.add("world"); //因为集合中只能添加String类型

        String s = list.get(0); //在获取元素时 默认就是相应得数据类型 而无需在进行转换

        //<K,V>:K:表示键的泛型  V:表示值的泛型
        HashMap<String,Integer> map=new HashMap<>();
        map.put("name",15);
        map.put("age",25);

        Set<String> keys = map.keySet();
    }

1.3 我们自己定义泛型类

public  class 类名<标识,标识....> {
     标识  变量名;
     
     public 标识 方法名(){
        
     }
     
     public void 方法名(标识 参数名){
     
     
     }
     .........

}

设置坐标的例子：

public class Point1 <T>{//定义坐标类型
    private T x;
    private T y;

    public Point1(T x, T y) {
        this.x = x;
        this.y = y;
    }

    public Point1() {
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "Point1{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
    public void show(){
        System.out.println("x轴坐标为"+this.x+"y轴坐标为"+this.y);
    }
}

测试一下

public class Test1 {
    public static void main(String[] args) {
        Point1 <String> p1 = new Point1<String>();//定义为字符串类型
        p1.setX("50度");
        p1.setY("60度");
        String s1 = p1.getX();
        System.out.println(s1);
        String s2 = p1.getY();
        System.out.println(s2);
        p1.show();
        Point1 <Integer> p2 = new Point1<Integer>();//定义为整数类型
        p2.setX(30);
        p2.setY(20);
        int i1 = p2.getX();
        int i2 = p2.getY();
        System.out.println(i1+" "+i2);
        p2.show();
    }
}

2.1File对象

File 类就是当前系统中文件或者文件夹的抽象表示

通俗的讲就是使用File对象来操作我们电脑系统中的文件或者文件夹

学习File类其实就是学习如果通过file对象对系统中的文件/文件夹进行增删改查

2.2 创建File对象

 public static void main(String[] args) {
        //创建一个File对象 并指定文件得路径  \转移字符串
        File file01 = new File("D:\\AAA\\aaa.txt");

        /*
           \\目录层级  在window系统下层级分割符为\  但是在linux和mac系统上分割符为 /
           我们得java代码是一种跨平台得语言。 我们得开发在window  但是我们项目得部署在linux.
           我们使我们得代码能在任意系统下来用。 我们有两种解决办法
           (1)第一种 因为window 兼容 / 和 \
         */
        File file02 = new File("D:/AAA/bbb.txt");


        // 第二种 File.separator根据当前代码所在得系统自动获取相应得分割符 

        System.out.println(File.separator); // \因为我们当前在window下
        File file03 = new File("D:"+File.separator+"AAA"+File.separator+"ccc.txt");


    }

2.3 增加操作

File f1 = new File("D:/AAA/CCC/EEE.txt");
        f1.createNewFile(); //增加单个文件
        File f2 = new File("D:/AAA/BBB");
        f2.mkdirs();//增加多个文件夹
        File f3 = new File("D:/AAA/DDD");
        f3.mkdir();//增加单个文件夹

2.4删除

  File f5 = new File("D:/AAA/HH/JJ");
        f5.mkdirs();
        f1.delete();//只能删除空文件夹或者单个的文件

2.5 修改

 File f6 = new File("D:/AAA/789.txt");
        f6.createNewFile();
        f6.setWritable(false); //设置不能改写
        f6.setReadble(false);  //设置他人不能读
        f6.setReadOnly();    //设置为只读模式

2.6 查询

 f6.renameTo(new File("D:/AAA/89.txt"));
        System.out.println(f6.getName()); //查询文件名字
        System.out.println(f2.getParent());//查询文件的所有父级目录
        System.out.println(f2.getPath());    //查询文件路径
        System.out.println(f6.isFile());  //查询是否为文件
        System.out.println(f2.isDirectory()); //查询是否为目录

File f7 = new File("D:/AAA");
        String[] list = f7.list();//以字符串数组形式显示所有文件名称
        System.out.println(Arrays.toString(list));
        File[] l = f7.listFiles(); //以数组形式显示所有文件对象
        for(File l2 : l){ //遍历
            System.out.println(l2.toString());
        }

例题要求显示出某文件夹下的所有文件路径

public class Show1 {
    public static void main(String[] args) {
            
        showAllFiles("D:/AAA");//引入成员方法
    }
    public static void showAllFiles(String path){//设置参数
        java.io.File f1 = new java.io.File(path);//创建File对象
        if(!f1.exists() || !f1.isDirectory()){//判断该文件是否存在，是否为目录，
                                                  //如果不是，返回
            return;
        }
        File[] f2 = f1.listFiles();//得到所有文件对象
        for(File f3 : f2){
            if(f3.isDirectory()){ //判断是否为目录
                System.out.println(f3.getPath()+"   dz");
                showAllFiles(f3.getPath()); 
            }else{
                System.out.println(f3.getPath()+" ");
            }
        }


    }
}

3. IO流

1. IO 表示有两个单词的缩写。
I: Input 输入 O: Output 输出

2. IO的作用：就是对文件中的内容进行操作。
输入: 读操作（读取文件的内容）输出: 写操作(往文件中写内容)

3. IO流的分类：

(1)根据流的方向:
---输入流: 程序可以从中读取数据的流。
---输出流: 程序能向其中写入数据的流。

(2)根据流的单位:
---字节流: 以字节为单位传输数据的流
---字符流: 以字符为单位传输数据的流

(3)根据功能
---节点流: 直接和文件进行交互
---处理流: 不是直接作用在文件上。

四个基本的流: 其他的流都是在这四个流的基础上进行扩展的
字节输入流
字节输出流

字符输入流
字符输出流

3.1 Writer字符输出流

它是所有字符输出流的跟类。---FileWriter类

ublic static void main(String[] args) throws IOException {
        Writer w1 = new FileWriter("D:/AAA/123.txt",true);//创建对象“true”不能省略，不然后面再添加的会把前面的覆盖掉
        String s1 = "abcdefg";
        w1.write(s1);//将字符串写进文档中
        w1.flush();//刷新流
        w1.close();//关闭流资源

3.2 Reader字符输入流

它是所有字符输入流的根类它的实现类有很多，我们使用FileReader实现类

 Reader r1 = new FileReader("D:/AAA/123.txt");
        int count = 0; //计算存的次数
        char[] cs = new char[2]; //字符数组 里面有2个长度
        while((count=r1.read(cs)) != -1){ //读取cs 的次数计数，为-1时候，就是读取完了，
            String s2 = new String(cs,0,count); //将读取的字符串计入s2
            System.out.print(s2); //输出
        }

例子：

用字符输入流和字符输出流完成复制文件内容的操作

@Test
    public void c5() throws IOException {
        将D：/ggg.txt 的内容复制到D:/hhh.txt上 读 输入 / 写 输出
        FileWriter fw = new FileWriter("D:/AAA/hhh.txt");// 设置字符输出流
        FileReader fr = new FileReader("D:/AAA/ggg.txt");//设置字符输入流
        int count = 0;  //计算个数
        char[] cs = new char[4]; //将每次读取的字符存放在cs字符数组中
        while((count = fr.read(cs)) !=-1){ //用while循环判断 ，每次计数为读取到的cs 
                                          //当为-1时就是读取完了
            fw.write(cs); //输出（写）如cs
            fw.flush();    //刷新流
        }
        fr.close();        //关闭流
        fw.close();        //关闭流 
    }

咱们能不能复制一个电影图片压缩文件等呢？

上面的字符流没法对图片和电影或压缩文件等进行操作。它只能对文本进行操作。

因为视频图片这些都属于二进制。

4. 字节流

4.1 字节输出流--OutputStream

它可以对任意文件进行操作，对文件进行输出操作。以字节为单位。它是所有字节输出流的父类，
FileOutputStream

一个文字等于3个字节，由于字节数组每次读取的内容有限，所以在读取文字时候会出现乱码

如果要读取的字符串全是文字，可以将字节数组设为3的倍数或者足够大，一次性将内容全部读取完，但是出现文字和字母夹杂在一起的情况就不建议使用这种方法了.如：“窗前明a月光”,这种情况用字符输出流比较合适。

 //InPutStream(读) OutPutStream (写)在D:/AAA/123.txt中输入和输出内容
        OutputStream os = new FileOutputStream("D:/AAA/123.txt");
        String s1 = new String("123456789");
        byte[] b =s1.getBytes(); //将字符串内容转为字节后才能输出
        os.write(b); 
        os.flush();
        os.close();

4.2 字节输入流---InputStream

它可以对任意文件进行读操作，以字节为单位，它是所有字节输入流的父类，子类有FileInputStream

 InputStream is = new FileInputStream("D:/AAA/123.txt");
        int count = 0;  
        byte[] bs = new byte[2]; //字节数组用来存读到的内容
        while((count = is.read(bs)) !=-1){ //文件内容比较多的时候适合用这种方法来读
            String s2 = new String(bs,0,count);
            System.out.print(s2);
        }
        is.close();

使用字节输入和输出流完成文件的复制功能:

字节输入输出流可以完成图片或视频的复制：

@Test
    public void IO5() throws IOException {
        //使用字节输入输入完成图片的复制 输出 写 /输入 读
        //将D:/AAA/aaa/5.jpg复制到D:/AAA/bbb/6.jpg
        InputStream is = new FileInputStream("D:/AAA/aaa/5.jpg"); //设置字节输入
        OutputStream os = new FileOutputStream("D:/AAA/bbb/6.jpg");//设置字节输出
        int count = 0; // 计数初始化 
        byte[] bytes = new byte[3]; //设置字节数组
        while((count = is.read(bytes)) !=-1){ //数字用来计算每次存放的读到的数字，为-1时候
                                               //就是读取完了
            os.write(bytes); //将读到的字节写出来
            os.flush();   //刷新流
        }
        is.close();  //关闭流
        os.close();
    }
}

5. 缓存流

缓存流是在基础流[InputStream OutputStream Reader Writer]之上添加了一个缓存池功能.
BufferInutStream BufferOutputStream BufferReader BufferWriter 提高IO的效率，降低IO的次数。

 @Test
    public void b1() throws IOException {
        //缓存流需要作用在基础流上面 ，缓存池中每次可以最多存放
        OutputStream os = new FileOutputStream("D:/AAA/123.txt",true);
        BufferedOutputStream bos = new BufferedOutputStream(os);
        String s = new String("abcdefg");
        byte[] bytes = s.getBytes();
        bos.write(bytes);//此时字节存放在缓存流中，文档中并没有内容
        bos.flush();        //需要进行刷新将文字放出来
        bos.close();        //关闭流同时有刷新流和关闭流两个功能

    }

    /*
    public BufferedOutputStream(OutputStream out) {
        this(out, 8192); //最多可以缓存8192个字节。
    }
     */

6. 对象流--对java对象进行IO操作

为什么需要对象流
我们现在操作IO流的时候都是将字符串读写操作可不可以将java对象在文件中进行读写呢？可以的 Student st=new Student();对象
将java对象进行读写操作意义在于持久化信息例如：游戏存档。

// 因为运行的时候所有的数据都是在运行内存中的持久化将运行内存的数据保存到硬盘上存档（写）读档(读)

public class ObjectIO1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//对象流是作用在基础流上的
//存档部分
        OutputStream os = new FileOutputStream("D:/AAA/123.txt");
        ObjectOutputStream oos = new ObjectOutputStream(os);
        Player1 p1 = new Player1("孙悟空",20,"吃桃","抓妖怪");
        oos.writeObject(p1);
        oos.close();
//读档部分
        InputStream is = new FileInputStream("D:/AAA/123.txt");
        ObjectInputStream ois = new ObjectInputStream(is);
        Object o= ois.readObject(); //读到的内容存在Object类 o中
        System.out.println(o);   //打印o
        ois.close();
    }
}

import java.io.Serializable;

public class Player1 implements Serializable {
//存档内容要连接 可续化接口
//设置基本属性
    private String name;
    private int age;
    private String hobby;
    private String gongNeng;

    public Player1(String name, int age, String hobby, String gongNeng) {
        this.name = name;
        this.age = age;
        this.hobby = hobby;
        this.gongNeng = gongNeng;
    }

    public Player1() {
    }

    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;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    public String getGongNeng() {
        return gongNeng;
    }

    public void setGongNeng(String gongNeng) {
        this.gongNeng = gongNeng;
    }

    @Override
    public String toString() {
        return "Player1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", hobby='" + hobby + '\'' +
                ", gongNeng='" + gongNeng + '\'' +
                '}';
    }

}

1. 序列化: 把内存中的java对象存储到磁盘[网盘]的过程。
---java对象所属的类必须实现序列化接口.implements Serializable
2. 反序列化: 把磁盘中的内容读取到java对象内存中的过程。