Java的学习——泛型和Io流

已于 2022-04-27 09:51:13 修改
阅读量320 收藏
点赞数
分类专栏： JAVA  文章标签： intellij-idea java
于 2022-04-19 21:35:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ysuhang/article/details/124281609
版权

1.集合的回顾

2.正文

1.泛型

2.file对象

3.Io流

3.泛型

3.1什么是泛型

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

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

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

3.2 如何使用泛型

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

package com.666.test1;

import java.util.*;

/**
 * @unthor : YSH
 * @date : 19:50 2022/4/19
 */
public class Test1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//这里就限制了集合中每个元素的类型
        list.add("张三");
        list.add("李四");//集合中只能添加String类型
        list.add("王五");

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

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

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

3.3自己定义泛型类

定义坐标类:

 public static void main(String[] args) {
        //在创建泛型类对象时没有指定相应得泛型类型。则默认为Object类型
        Point p1=new Point();
        p1.setX(15);
        p1.setX("北纬50度");

        //这里得泛型必须都是对象类型
        Point<Integer> p2=new Point<Integer>() ;
        p2.setX(25);
        p2.setY(65);
        Integer x = p2.getX();
        Integer y = p2.getY();
        p2.show();

        Point<String> p3=new Point<>();
    }
}
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;
    }
}

4.File对象

4.1File类

4.1.1File类简介

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

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

4.1.2Flie对象创建

1 前期准备
1 前期准备
    在电脑的非系统盘 创建一个 test文件夹 今天所有的操作都在这个文件夹中

2 创建
    @Test
    public void test() {

        /*  path 路径
          Creates a new <code>File</code> instance by converting the given
          pathname string into an abstract pathname.  If the given string is
          the empty string, then the result is the empty abstract pathname
          File(String) 参数为String类型的目标文件路径名
         */
        File file = new File("D:\\aaa\\123.txt");

        /*  路径分割符
         *  D:\yyy\666\123.mp4    称之为路径  其中 \ 就是路径分割符 代表的是 下级目录
         *  在windows系统中 路径分割符为  \   在 Linux 和 Mac 中 路径分割符是 /
         *  我们写的java代码  需要跨平台 多环境运行   开发环境：windows   生成环境：Linux
         *  此时就会出现一个问题  如果我们的路径分隔符 写成 \  在 windows中好使 到了 Linux就不识别
         *  所以我们可以使用以下两种方式解决：
         *
         * */
        /* 方式1 ：  windows不仅支持 \ 还支持/ */
        File file1 = new File("D:/aaa/666.txt");

        /* 方式2：   使用动态识别的常量  */
        // ;
        System.out.println(File.pathSeparator);
        // \ 
        System.out.println(File.separator);
       
        File file2 = new File("D:" + File.separator + "aaa" + File.separator + "123.txt");
    }

4.1.3增加操作

package com.666.test2;

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

/**
 * @unthor : YSH
 * @date : 20:03 2022/4/19
 */
public class Test {
    public static void main(String[] args) throws IOException {
        File file1 = new File("D:/0419AAA/666.txt");//创建file对象
        file1.createNewFile();//创建相应的文件

        File file02 = new File("D:/0419AAA/6969");
        file02.mkdir();//创建目录 make directory

        File file03 = new File("D:/0419AAA/6969/6666");
        file03.mkdirs();//创建多层目录

        File file04 = new File("D:/0419AAA/666");
        file04.createNewFile();
        //根据你调用的方法不同  而创建不同的类型
    }
}

4.1.4删除操作

package com.666.test2;

import java.io.File;

/**
 * @unthor : YSH
 * @date : 20:15 2022/4/19
 */
public class Test2 {
    public static void main(String[] args) throws InterruptedException{
        File file01 = new File("D:/0419AAA/666.txt");
        file01.delete();//删除文件

        File file02 = new File("D:/0419AAA/666");
        file02.deleteOnExit();//当程序退出后 删除
        Thread.sleep(5000);//休眠5秒

        File file03 = new File("D:/0419AAA/6969/6666");
        file03.delete();//删除空目录（当前目录为空才可以删除）
    }
}

4.1.5修改操作

package com.666.test2;

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

/**
 * @unthor : YSH
 * @date : 20:23 2022/4/19
 */
public class Test3 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/0419AAA/Y.txt");
        file.createNewFile();
        //file.setReadable(false);//设置该文件的权限为不能读
        //file.setWritable(false);//设置该文件得到权限为不能写
        //file.setReadOnly();//设置只读的权限


        file.renameTo(new File("D:/0419AAA/YY.txt"));//重命名
    }
}

 4.1.6查询操作

package com.666.test2;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

/**
 * @unthor : YSH
 * @date : 20:33 2022/4/19
 */
public class Test4 {
    public static void main(String[] args){
        File file = new File("D:/0419AAA/6969/YYY/CCC.txt");

        String name = file.getName();//得到文件的名字
        System.out.println("name======"+name);
        File parentFile = file.getParentFile();//得到父级路径的名称
        System.out.println("parentFile======"+parentFile);
        String path = file.getPath();//得到文件的路径名称
        System.out.println("path======"+path);

        boolean f1 = file.isFile();//判断该文件对象是否为文件类型
        System.out.println("f1======"+f1);
        boolean f2 = file.isDirectory();//判断该文件对象是否为目录类型
        System.out.println("f2======"+f2);

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

        File[] files = file1.listFiles();//列出0419AAA目录下的所有文件对象
        for (File f:files){
            System.out.println(f.toString());
        }
    }
}

运行结果:

 4.1.7经典题目:用的方法是递归调用

package com.666.test2;

import java.io.File;

/**
 * @unthor : YSH
 * @date : 20:47 2022/4/19
 */
public class Test5 {
    public static void main(String[] args) {
        showAllFiles("D:/AAA_0419");
    }

    private static void showAllFiles(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>");
                showAllFiles(f.getPath());
            }else{
                System.out.println(f.getPath()+"");
            }
        }
    }
}

运行结果:

5.Io流

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

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

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

5.字符流

 5.1Writer字符输出流

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

package com.666.test3;

import java.io.FileWriter;
import java.io.Writer;

/**
 * @unthor : YSH
 * @date : 21:07 2022/4/19
 */
public class Test1 {
    public static void main(String[] args) throws Exception{
        //字符输出流 ---指定对那个文件 （路径） 进行写操作
        Writer writer = new FileWriter("D:/0419AAA/S.txt");

        String str ="hello AAA 今天要下雨";
        writer.write(str);

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

 上面每次往文件中写内容时 就会把原来的内容覆盖了。 如何追加内容

package com.666.test3;

import java.io.FileWriter;
import java.io.Writer;

/**
 * @unthor : YSH
 * @date : 21:18 2022/4/19
 */
public class Test2 {
    public static void main(String[] args) throws Exception{
        //字符输出流 ---指定对哪个文件（路径）进行写操作
        //true:表示允许追加内容到文件中
        Writer writer = new FileWriter("D:/0419AAA/S.txt",true);

        String str ="明天是晴天";
        writer.write(str);

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

5.2Reader字符输入流

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

5.3完成文件内容的复制

要求:从 "D:/AAA0420/a.txt"复制到"C:/AAA0420/a.txt"

/*
     完成文件内容的复制功能
     */ 

@Test
    public void FZ() throws Exception{
        //1.创建一个字符输入流
        FileReader fr =new FileReader("D:/AAA0420/a.txt");
        //2.创建一个字符输出流
        FileWriter fw = new FileWriter("C:/AAA0420/a.txt");

        int c = 0;//读取到字符的个数
        char[] cs =new char[10];//每次读取的内容放入该数组中

        while ((c=fr.read(cs)) !=-1){
            fw.write(cs,0,c);
            fw.flush();
        }
        fw.close();
        fr.close();
    }

大家思考: 咱们能不能复制一个电影 图片 压缩文件等 上面的字符流没法对图片和电影 或压缩文件等进行操作。 它只能对文本进行操作。 因为视频图片 这些都属于二进制。 

6.字节流

6.1字节输出流--OutputStream

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


 //测试字节输出流
    @Test
    public void testOutStream() throws Exception{
        OutputStream outputStream = new FileOutputStream("D:/AAA0420/b.txt");
        String str = "abcd";
        //把字符串转换为字节数组
        byte[] bytes = str.getBytes();

        outputStream.write(bytes);

        outputStream.flush();
        outputStream.close();
    }

6.2字节输入流--InputStream

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

//字节输入流
    @Test
    public void testInputStream() throws Exception{
        InputStream is = new FileInputStream("D:/AAA0420/b.txt");

        byte [] bytes = new byte[3];
        int c = is.read(bytes);//一次读取三个字节 并把读取的内容放入字节数组中 返回读取到的字节的个数
        System.out.println(bytes+"==========>个数:"+c);
        c = is.read(bytes);//一次读取三个字节 并把读取的内容放入字节数组中 返回读取到的字节的个数
        System.out.println(bytes+"==========>个数:"+c);
        c = is.read(bytes);//一次读取三个字节 并把读取的内容放入字节数组中 返回读取到的字节的个数
        System.out.println(bytes+"==========>个数:"+c);
        is.close();

    }
    //如果文件内容非常大  使用循环来读取
    @Test
    public void testInputStream2() throws Exception{
        InputStream is =new FileInputStream("D:/AAA0420/b.txt");
        byte[] bytes = new byte[300];
        int c=0;//d读取到的个数
        while((c= is.read(bytes))!=-1){
            //把byte数组转化为字符串
            String str = new String(bytes,0,c);
            System.out.println(str);
        }
        is.close();
    }

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

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

7.缓存流

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

  @Test
    public void TestBuffer() throws Exception{
        OutputStream out = new FileOutputStream("D:/AAA0420/c.txt");
        BufferedOutputStream bos = new BufferedOutputStream(out);//缓存流要作用在基础流上
        String str ="abcdefghijk";
        byte[] bytes = str.getBytes();
        bos.write(bytes); //因为你写的内容 暂时放入缓存池中  并没有直接放入文件中。 所以文件中没有你的内容。
        //bos.flush();//刷新缓存池---把池子中的内容输入到文件上
        bos.close(); //关闭----先刷新缓冲池 再关闭流资源
    }

8.对象流--对Java对象进行IO操作

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

package com.666.test1;

import org.junit.Test;

import java.io.*;

/**
 * @unthor : YSH
 * @date : 19:45 2022/4/20
 */
public class DemoTest2 {

    @Test  //存档: ----列序化
    public void testObjectStream() throws Exception{
        OutputStream out = new FileOutputStream("D:/AAA0420/d.txt");
        //对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(out);

        //使用对象输出流调用输出方法 输出的类对象 该类必须实现Serializable 序列化接口
        Role r = new Role("吕布","7级",001,"大战三英");
        oos.writeObject(r);
        oos.close();
    }

    //测试 读档: ----反序列化:
    @Test
    public void testObjectStream2() throws Exception{
        InputStream input = new FileInputStream("D:/AAA0420/d.txt");
        ObjectInputStream ois = new ObjectInputStream(input);
        Object o = ois.readObject();

        System.out.println(o);
        ois.close();
    }

}

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

9.总结

 1.  通过字符流完成文件的复制---->它只能复制文本文件
2.  字节流:---字节输入流和字节输出流。
3.  字节流 我们也可以完成文件的复制功能---它可以复制任意类型的文件.
4.  缓存流--->它基本流的基础上 添加了一个缓存池
5.  对象流: ObjectInputStream  ObjectOutputStream
     序列化:把内存中的java对象存储到磁盘[网盘]的过程。
         ---java对象所属的类必须实现序列化接口.implements Serializable
     反序列化:把磁盘中的内容读取到java对象内存中的过程。

本章内容到此结束，谢谢观看！！！！！

不想秃头的小杨
关注
专栏目录
Java中的IO流
学习java的小学僧的博客
02-03 275
Java中的IO流
Java知识点总结——IO流框架
mxy2404830的博客
12-11 352
IO框架 一、流的概念 概念：内存与存储设备之间传输数据的通道。 二、流的分类 按方向分类： 输入流：将<存储设备>中的内容读入到<内存>中 输出流：将<内存>中的内容读入到<存储设备>中 内存：内存是一种用于暂时存放[CPU]中的运算数据和外部储存器交换数据的随机储存器。 存储：一般可分为机械[硬盘]和[固态硬盘]，是一种储存硬件，用于存放数据。 按单位进行划分： 字节流：以字节为单位，可以读写所有数据。 字符流：以字符为单位，只
Java——泛型和Io流
qq_55682798的博客
04-19 765
目录 1.泛型 2.File对象 3.IO流 1泛型 1.1什么是泛型 1. 泛型就是限制我们得数据类型。 2.为什么使用泛型? 我们原来在定义集合时，是如下得定义方式： List list=new ArrayList();//该集合没有使用泛型 list.add("java01"); list.add("java02"); String str= (String) list.get(0);//获取元素 需要进行强制类型转换
JAVA 中的IO流
huxiao@javaeye
09-30 311
一、流的概念        流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。       一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。        流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流...
java学习教程——简洁易懂，一步步跟随即可上手学习
02-22
以上内容涵盖了Java学习的基本路线，通过逐步学习和实践，你将能够掌握Java编程技能，并具备开发实际项目的能力。在学习过程中，可以参考`default.html`和`index.html`等文档，它们可能包含了教程的目录结构和内容...
黑马程序员java学习笔记——IO流
魏天翔的博客
06-08 510
IO流     概述     流的特点     IO流用于处理设备之间的数据传输；     java对数据的操作是通过流的方式；     java用于操作留的对象都放在IO包中；     流按操作数据分为两种：字节流和字符流；     按流向分为：输入流和输出流；     字符流对相融合了编码表。     流常用基类     字节流的抽象基类：输入流InputS
Java笔记——Lambda表达式和Stream流
最新发布
weixin_44853206的博客
11-24 736
/ 测试类 public class Demo03LambdaBase {// 匿名内部类的方式 fun(new MyFunctionalInter() {System . out . println("匿名内部类的方式！");} });// Lambda表达式的标准格式的方式 fun(() -> {System . out . println("Lambda表达式的标准格式的方式");});
java面试——南京-软通动力-Java中级.zip
09-26
这份资料“java面试——南京-软通动力-Java中级.zip”包含了一份详细的PDF文档，旨在帮助求职者准备相关的面试问题。以下是基于Java中级面试可能会涉及的一些核心知识点的详细阐述： 1. **Java基础** - **数据类型...
java中的IO流
GuessHat的博客
07-10 5144
java中的IO流 IO流主要分为input 流和output 流，对于不同的操作方式分为字节流操作和字符流操作，以下为java中主要用来IO流操作的类 1.输出流 OutputStream（字节流） 基本信息： 包：java.io 类型：抽象类 子类：FileOutputStream 子类构造方法： 传入一个File类型进行输出FileOutputStream(File file)(默认都是将流覆盖原始的文件) 传入一个String类型进行输出FileOutputStream(String n
java中的io流
m0_66689823的博客
07-19 9951
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 。
Java IO _字节流与字符流
韩世雷 程序员专栏
08-23 1324
1.掌握流的概念 2.掌握字节流与字符流的作用 3.掌握文件的标准操作步骤 4.掌握字节与字符操作的区别 1、流的概念 程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。 2、字节流与字符流 内容操作就四个类：OutputStream、InputStream、writer、Rader 使用 File 类操作的时候一定要有路
JavaIO流
热门推荐
Switch的博客
11-09 1万+
IO流 文件--基本概念 文件是数据源(保存数据的地方)的一种，比如大word文档、jpg文件、MP4文件...都是文件。文件最主要的作用就是保存数据，它既可以保存一张图片，也可以保存视频、声音...等   文件流--基本概念 文件在程序中是以流的形式来操作的。 流：数据在数据源(文件)和程序(内存)之间经历的路径 输入流：数据从数据源(文件)到程序(内存)的路径 输出
Java中IO流
Demolist的博客
08-11 318
Java中对应IO流的操作以及总结
IO操作与泛型集合实战教程
"本文档深入探讨了Java中的IO操作、泛型和集合的概念及其在实际编程中的应用。首先，通过'IO2+泛型+集合'的主题，作者引导读者理解基础的I/O（Input/Output）功能，这是任何Java程序与外部数据交互的基础，如文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值