泛型 File对象 IO流

已于 2023-03-03 11:10:15 修改
阅读量233 收藏
点赞数
文章标签： java mvc 开发语言 spring maven
于 2022-04-20 02:25:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xzh_java/article/details/124287905
版权

泛型

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

使用泛型

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

public class Demo01 {
    public static void main(String[] args) throws IOException {
        //没有指定类型  可以存放任意类型数据
        List list = new ArrayList();
        list.add("java1");
        list.add("java2");
        list.add("java3");
        list.add("java4");
        //获取数据需要强制转换
        String a = (String) list.get(0);
        System.out.println(a);

    }
}
===================================================================
public class Demo02 {
    public static void main(String[] args) {
        //jdk1.7以后new后<>可以省略
        //限制了集合中每个数据的类型
        List<String> list = new ArrayList<>();
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        //在获取集合中元素时，默认就是相应的类型 无需在进行转换
        String s = list.get(0);
        System.out.println(s);

        //<K,V>  K表示键的泛型 V 表示值的泛型
        Map<String,Integer> map = new HashMap<>();
        map.put("小明",12);

    }
}

自定义泛型类

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

}

例：定义坐标 

public class Demo03 {
    public static void main(String[] args) {
        //在创建泛型类对象时没有指定相应泛型类型，默认为Ob
        Point<String> point = new Point();
        point.setX("12");
        point.setY("12");
        point.show();

    }
}
class Point<T>{
    private T x;
    private T y;

    public void show(){
        System.out.println("x轴坐标"+x+"y轴坐标"+y);
    }

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

File对象

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

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

创建File对象

1. 在磁盘准备一个目录AAA。对文件得操作都放在该目录下。

public class Demo04 {
    public static void main(String[] args) throws IOException {
        //创建File对象
        File file = new File("D:/AAA/aaa.txt");
        //第二种  File.separator
        File file1 = new File("D:"+File.separator+"AAA"+File.separator);
        

    }
}

增加操作

        file.createNewFile();//创建文件

        File file2 = new File("D:/AAA/aaa");
        file2.mkdir();//创建目录 make directory  单机目录

        File file3 = new File("D:/AAA/aaa/bbb");
        file3.mkdirs();//多级目录

 删除操作

public class Demo05 {
    public static void main(String[] args) throws InterruptedException {
        File file = new File("D:/AAA/aaa.txt");
        file.delete();//删除空目录

        File file1 = new File("D:/AAA/aaa/bbb");

        file1.deleteOnExit();//程序退出时删除
        Thread.sleep(5000);//程序休眠5s
    }
}

修改操作

public class Demo06 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/AAA/a.txt");
        file.createNewFile();

        file.setReadable(false);//设置该文件的权限为不能读
        file.setWritable(false);//设置文件不能写
        file.setReadOnly();//设置只读权限

        file.renameTo(new File("C:/AAA/c.txt"));
    }
}

查询操作

public class Demo07 {
    public static void main(String[] args) {
        File file = new File("D:/AAA/c.txt");
        String name = file.getName();//获取文件名称
        System.out.println(name);
        String parent = file.getParent();//获取父级目录名称
        System.out.println(parent);
        String path = file.getPath();//获取文件路径的名称
        System.out.println(path);

        boolean file1 = file.isFile();//判断是否是文件类型
        System.out.println(file1);
        boolean directory = file.isDirectory();//判断是否是目录类型
        System.out.println(directory);

        File file2 = new File("D:/AAA");
        String[] list = file2.list();
        System.out.println(Arrays.toString(list));//列出AAA下所有子目录的名称
        File[] files = file2.listFiles();
        //System.out.println(Arrays.toString(files));//列出AAA下所有目录文件对象

        for (File f:files
             ) {
            System.out.println(f);
        }
    }
}

经典题目:

获取指定目录下所有文件

递归调用

public class Demo08 {
    public static void main(String[] args) {
        show("D:/AAA");
    }
    public static void show(String path){
        File file = new File(path);
        //判断文件是否存在 目录是否存在
        if (!file.exists()||!file.isDirectory()){
            return;
        }
        File[] files = file.listFiles();

        for (File f:files
             ) {
            if (f.isDirectory()){
                System.out.println(f.getPath()+"dir");
                show(f.getPath());
            }else {
                System.out.println(f.getPath());
            }
        }
    }
}

IO流

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

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

 (1)根据流的方向:
    ---输入流: 程序可以从中读取数据的流。
    ---输出流: 程序能向其中写入数据的流。
    
 (2)根据流的单位:
    ---字节流: 以字节为单位传输数据的流
    ---字符流: 以字符为单位传输数据的流
 
 (3)根据功能
    ---节点流: 直接和文件进行交互
    ---处理流: 不是直接作用在文件上。
    
四个基本的流: 其他的流都是在这四个流的基础上进行扩展的
        字节输入流
        字节输出流 
    
        字符输入流
        字符输出流

 

Writer字符输出流

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

public class TestWriter {
    public static void main(String[] args) throws IOException {
        //字符输出流   指定对哪个文件(路径)进行操作
        //true 表示对内容进行追加到文件
        Writer writer = new FileWriter("D:/AAA/b.txt",true);
        String str ="BBBB";
        writer.write(str);

        writer.flush();//刷新
        writer.close();//关闭
    }
}

Reader字符输入流

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

public class TestReader {
    public static void main(String[] args) throws IOException {
        Reader reader = new FileReader("D:/AAA/b.txt");

        //char read = (char) reader.read();//每次读取一个字符 返回读取的内容
        //System.out.println(read);

        char[] chars = new char[20];
        int read = reader.read(chars);
        String str = new String(chars);
        //System.out.println(read);
        //System.out.println(Arrays.toString(chars));
        System.out.println(str);


    }
}
public class Demo09 {
    public static void main(String[] args) throws IOException {
        Reader reader = new FileReader("D:/AAA/d.txt");
        int count= 0;
        char[] chars = new char[10];
        //int read = reader.read(chars);//读取字符的个数  将读取到的字符存入数组
        while ((count = reader.read(chars))!=-1){
            String str = new String(chars,0,count);
            System.out.print(str);
        }


    }
}

完成文件内容的复制

public class Demo02 {
    @Test
    public void test01() throws IOException {
        //创建一个字符输入流
        FileReader fr = new FileReader("D:/AAA/a.txt");

        //创建一个字符输出流

        FileWriter fw = new FileWriter("E:/AAA/f.txt");

        int c = 0; //读取字符的个数

        char[] chars = new char[10];

        while ((c = fr.read(chars))!= -1){

            fw.write(chars,0,c);
            fw.flush();
        }
        fr.close();
        fw.close();
    }

上面只能进行字符的赋值， 咱们能不能复制一个电影 图片 压缩文件等

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

它只能对文本进行操作。

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

字节流

字节输出流--OutputStream

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

@Test
    public void test() throws IOException {
        //字节输出流
        OutputStream fo = new FileOutputStream("D:/AAA/l.txt");
        String str = "abcd";
        //通过getBytes()
        byte[] bytes = str.getBytes();
        fo.write(bytes);
        fo.flush();
        fo.close();
    }

字节输入流---InputStream

public class DemoInputStream {
    //字节输入流
    @Test
    public void test01() throws IOException {
        InputStream fs = new FileInputStream("D:/AAA/a.txt");
        byte[] bytes = new byte[10];
        int a = fs.read(bytes);
        System.out.println(bytes+"===>"+a);
        a = fs.read(bytes);
        System.out.println(bytes+"===>"+a);
        a = fs.read(bytes);
        System.out.println(bytes+"===>"+a);
        //读取没有内容了 返回-1
        a = fs.read(bytes);
        System.out.println(bytes+"===>"+a);
    }
    @Test
    public void test02() throws IOException {
        InputStream fs = new FileInputStream("D:/AAA/a.txt");

        int c = 0;
        byte[] b = new byte[10];
        while ((c = fs.read(b))!=-1){
            String str = new String(b,0,c);
            System.out.print(str);
        }
        fs.close();
    }

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

@Test
    public void testCopy() throws Exception{
            //1.创建字节输入流 视频
            InputStream is=new FileInputStream("D:/AAA/1.jpg");
           //2.字节输出流
           OutputStream fos=new FileOutputStream("E:/AAA/2.jpg");
           byte[] bytes=new byte[10];
           int c=0;
           while( (c=is.read(bytes)) !=-1 ){
                 fos.write(bytes,0,c);
           }
           is.close();
           fos.close();
    }

缓存流

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

public class TestBuffer {
    @Test
    public void test() throws IOException {
        OutputStream out = new FileOutputStream("D:/AAA/j.txt");
        //缓冲流作用于在基础流上  默认缓冲8192个字节 可以自定义缓冲池字节
        BufferedOutputStream bf = new BufferedOutputStream(out);
         String str = "abcdefghijklmn";
         byte[] bytes = str.getBytes();
         bf.write(bytes);
         bf.flush();//刷新缓冲池 将缓冲池内容输入到文件中
         bf.close();//关闭 先刷新缓冲池在关闭流资源
    }
}

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

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

public class TestObject {
    @Test
    public void test1() throws IOException {
        OutputStream out = new FileOutputStream("D:/AAA/2.txt");
        ObjectOutputStream os  = new ObjectOutputStream(out);
        //使用对象输出流调用输出方法 输出的类对象 该类必须实现 Serializable==>序列化接口
        Game game = new Game("王者荣耀","小明",12);
        os.writeObject(game);
        os.close();
    }

    //测试读档  反序列化
    @Test
    public void test2() throws IOException, ClassNotFoundException {
        InputStream is = new FileInputStream("D:/AAA/2.txt");
        ObjectInputStream os = new ObjectInputStream(is);
        Object o = os.readObject();
        System.out.println(o);
    }

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

总结：

1.  通过字符流完成文件的复制---->它只能复制文本文件
2.  字节流:---字节输入流和字节输出流。
3.  字节流 我们也可以完成文件的复制功能---它可以复制任意类型的文件.
4.  缓存流--->它基本流的基础上 添加了一个缓存池 
5.  对象流: ObjectInputStream  ObjectOutputStream
     序列化:
     反序列化:

一个小哑巴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaDemo.rar
05-20
包含有关file、IO流、集合和泛型相关基础知识代码
泛型 File对象 和IO流
m0_69719993的博客
04-20 192
1泛型 1.1什么是泛型 泛型就是限制我们的数据类型 1.2为什么使用泛型 ArrayList arrayList = new ArrayList(); arrayList.add("java01"); arrayList.add("张三"); //获取元素 需要进行强制类型转换 String a = (String) arrayList.get(0); //获取元素时不方便对元素进行相应的其他操作 System.out.println(a); ...
泛型 File 对象 与 IO流
qq_53625788的博客
04-20 205
1.泛型 1.1什么是泛型 1.泛型就是限制我们的数据类型、 2.为什么使用泛型？ //集合没有使用泛型 List list = new ArrayList(); list.add("小明"); list.add("小红"); //指定下标获取元素 需要进行强制类型转换 String s = (String) list.get(0); System.out.println(s); 获取元素时，不.
第十章-----Java泛型 File类 IO流 缓存流 对象流
BUG专业户
04-19 203
Java基本使用-----泛型 File类 IO流 (字符输入流 字符输出流 字节输入流 字节输出流)缓冲流 对象流
泛型、File对象以及IO流
Luckydogs3036的博客
04-20 61
泛型 1. 什么是泛型？ 1. 泛型就是限制我们得数据类型。 2.为什么使用泛型? 我们原来在定义集合时，是如下得定义方式： List list=new ArrayList();//该集合没有使用泛型 list.add("java01"); list.add("java02"); String str= (String) list.get(0);//获取元素 需要进行强制类型转换 System.out.println(str...
面向对象技术与UML课件及源代码-by 南邮-陈杨
06-06
本书为中南大学精品教材立项项目，分为上下两篇共21章，涵盖了面向对象技术中Java开发环境配置、程序设计基础、面向对象原理以及UML的知识。本书使用的开发环境是JDK 1.6+Eclipse 3.3+Rational Rose 2003，逐步引领...
java.xmind
12-06
java基础总结：内含java概述，java基本语法，面向对象，内部类匿名内部类，常用API，正则表达式，集合与泛型，单元测试，反射，网络编程，多线程，IO流，FILE类，异常处理
Java 基础核心总结 +经典算法大全.rar
11-08
节点流和处理流 Java IO 的核心类 File Java IO 流对象 字节流对象InputStream OutputStream 字符流对象Reader Writer 字节流与字符流的转换新潮的 NIO 缓冲区(Buffer)通道(Channel) 示例:文件拷贝案例 BIO 和 NIO ...
Java基础知识点.html
02-24
ClassLoader 反射 Stream 流 函数式编程 Lambda 表达式 网络编程-协议 网络编程-端口 网络编程-IP 多线程 IO流-字节流 IO流-字符流 IO流-转换流 File Map HashMap 序列化和反序列化 可变参数 类型通配符 泛型 ...
android高斯模糊填充imageview背景
最新发布
cf8833的博客
05-21 225
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1194
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 345
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 432
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1144
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
Android Model引入其他aar包 导致无法打包成aar
qq_27400335的博客
05-16 399
Android Model引入其他aar包 导致无法打包成aar
Java基础——字符串
Kenard的博客
05-17 1002
基本数据类型、包装类 转成字符串，调用String类的public String valueOf(int n)可将int型转换为字符串相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(doubled)、valueOf(boolean b)可由参数的相应类型到字符串的转换。下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。
初识Spring Cloud
u011627218的专栏
05-20 761
一、介绍。
MyBatis从浅入深
Cobrander2_0的博客
05-21 623
Mybatis用于简化Java当中对于JDBC的操作，它将连接数据库，执行SQL命令自动化实现。
java的steam流对泛型是对象的集合去重
07-11
Java的Stream流对泛型是对象的集合去重可以使用`distinct()`方法来实现。`distinct()`方法会根据对象的`equals()`方法来判断对象是否重复，所以需要确保泛型对象已经正确实现了`equals()`方法。 下面是一个示例代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值