泛型 File 对象 与 IO流

已于 2022-04-21 10:43:50 修改
阅读量219 收藏
点赞数
分类专栏： java 文章标签： java
于 2022-04-20 13:47:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53625788/article/details/124295507
版权

1.泛型

1.1什么是泛型

1.泛型就是限制我们的数据类型、

2.为什么使用泛型？

//集合没有使用泛型
        List list = new ArrayList();
        list.add("小明");
        list.add("小红");

        //指定下标获取元素  需要进行强制类型转换
        String s = (String) list.get(0);
        System.out.println(s);

 获取元素时，不方便对元素进行相应的其他操作。

1.2如何使用泛型

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

//限制每个集合中的元素类型
        List<String> list = new ArrayList();
        //集合中只能添加String类型
        list.add("小明");
        list.add("小红");
        list.add("小黑");
        //在获取元素时  默认都是相应的类型所以不用在进行调换了
        String s = list.get(1);
        System.out.println(s);

        //<k , v> k: 表示键的 泛型   v: 表示值的 泛型
        HashMap<String , Integer> pp = new HashMap<>();
        pp.put("name",1);
        pp.put("age",2);
        System.out.println(pp);

1.3自己能否定义泛型类型

肯定可以

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

}

定义坐标类

public static void main(String[] args) {
        //在创建泛型类对象时没有指定相应得泛型类型。则默认为Object类型
        Coords c = new Coords();
        c.setX("北纬34°");
        c.setY("东经113°");
        c.coords();
        //这里得泛型必须都是对象类型
        Coords<Integer> a = new Coords<>();
        a.setX(15);
        a.setY(30);
        Integer x = a.getX();
        Integer y = a.getY();
        a.show();
    }
}
class Coords<E> {
    private E x;
    private E y;

    public void show() {
        System.out.println("x的坐标为"+x+" y的坐标为"+y);
    }
    public void coords() {
        System.out.println("金水区的坐标为"+x+y);
    }

    public E getX() {
        return x;
    }

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

    public E getY() {
        return y;
    }

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

2.File 对象

2.1file的简绍

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

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

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

2.2创建File对象

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

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

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

2.3增加操作

package ketang20220419.two;/*
 * @author     : zzz
 * @date       : 2022/4/19 22:19
 * @description: some description
 */

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

public class Test1 {
    public static void main(String[] args) throws IOException {
        //创建File对象
        File file = new File("E:/qy151/AAA/aaaa.txt");
        //创建相应的文件
        file.createNewFile();

        File file1 = new File("E:/qy151/AAA/bbbbb");
        //创建目录 make directory 单层目录
        file1.mkdir();

        File file2 = new File("E:/qy151/AAA/ttt/aaa");
        //创建多层目录
        file2.mkdirs();

        File file3 = new File("E:/qy151/AAA/ee");
        file3.createNewFile();
        //使根据你调用得方法不同 而创建不同得类型
    }
}

2.4删除操作

 public static void main(String[] args) throws InterruptedException {
        File file = new File("E:/qy151/AAA/wjcj/a.txt");
        //删除文件
        file.delete();

        File file1 = new File("E:/qy151/AAA/wjcj/q");
        //当程序退出后删除
        file1.deleteOnExit();

        Thread.sleep(5000);//休眠五秒。

        File file2 = new File("E:/qy151/AAA/wjcj/qq");
        //删除空目录
        file2.delete();
    }

2.5修改操作

public static void main(String[] args) throws IOException {

        File file = new File("E:/qy151/AAA/ccc/bb.txt");
        file.createNewFile();

        //设置文件的权限为不能读取
        file.setReadable(false);

        //设置文件不能写
        file.setWritable(false);

        //设置只读取权限
        file.setReadOnly();

        //重命名
        file.renameTo(new File("E:/qy151/AAA/ccc/a.txt"));

    }

2.6查询操作

public static void main(String[] args) {
        File file = new File("E:/qy151/AAA/bbb/b.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 b1 = file.isFile();
        System.out.println("文件是否为文件类型"+b1);

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

        File file1 = new File("E:/qy151/AAA");

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

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

        File[] files1 = file1.listFiles();
        System.out.println(Arrays.toString(files1));
    }
}

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

public class Test3 {
    public static void main(String[] args) {
       // 显示指定目录下的所有文件。E:/qy151/AAA下所有的文件.
        showAllFiles("E:/qy151/AAA");
    }
    public 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()+" ");
            }
        }
    }
}

3.IO流

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

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

  3. IO流的分类：

(1)根据流的方向:

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

(2)根据流的单位:

---字节流: 以字节为单位传输数据的流
---字符流: 以字符为单位传输数据的流

(3)根据功能

---节点流: 直接和文件进行交互
---处理流: 不是直接作用在文件上。

四个基本的流: 其他的流都是在这四个流的基础上进行扩展的

    字节输入流
    字节输出流 

    字符输入流
    字符输出流

3.1 Writer字符输出流

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

public static void main(String[] args) throws IOException {
        //字符输出流 ---指定对哪个文件（路径）进行写操作
        Writer writer = new FileWriter("E:/qy151/AAA/bb.txt");

        String s = "hello 今天是个大晴天";
        writer.write(s);

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

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

public static void main(String[] args) throws IOException {
        //字符输出流 ---指定对哪个文件（路径）进行写操作
        Writer writer = new FileWriter("E:/qy151/AAA/bb.txt",true);

        String s = "我们去公园散步吧";
        writer.write(s);

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

3.2 Reader字符输入流

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

Reader reader=new FileReader("E:/qy151/AAA/bb.txt");

        char[] cs =new char[2]; //每次读取2个字符放入该数组中。
        int c=reader.read(cs);// 每次读取两个字符放入cs数组中 返回读取的个数
        System.out.println(c);
        System.out.println(cs);
        String s=new String(cs,0,c);//把字符数组转换为字符串。
        System.out.println(s);

        c = reader.read(cs);
        System.out.println(c); //
        System.out.println(cs); // [a,b]-->[c,b]
        String s1=new String(cs,0,c);
        System.out.println(s1);

        c = reader.read(cs);
        System.out.println(c);
        System.out.println(cs); // [a,b]-->[c,b]

回顾

1. 泛型: 限制类中属性或方法的数据类型。 再创建集合对象时限制该集合中元素的类型.
    例如: List<String> list=new ArrayList();//该集合中的元素只能存放String数据类型。

2. File文件类: 对我们系统上的文件和文件夹的一种抽取。
       (1)创建该类对象时的方法: File file=new File("文件的路径");
       (2)方法: 
             list();列出该目录下所有的子文件名.
             listFiles()；列出该目录下所有的子文件对象
             getPath():得到文件的路径
             createNewFile()：创建文件
             mkdir();创建单层目录
             mkdirs():创建多层目录
             exists():判断文件是否存在。
             isDirectory():判断是否该文件为目录.
             delete():删除文件
             
3. IO: 就是通过IO流对文件的内容进行操作。   
      IO按照方向: 输入流和输出流
      IO按照内容: 字节流和字符流。
      IO功能： 节点流和处理流
      
4.IO中的4个基类:
      InputStream:字节输入流
      OutputStream:字节输出流
      Reader: 字符输入流
      Writer: 字符输出流

5. 字符输出和输入流

3.2完成文件内容的复制

 

import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;

public class Copy {
    @Test
    public void test() throws Exception {
        //创建一个字符输入流
        FileReader fileReader = new FileReader("E:/qy151/AAA/bb.txt");
        //创建一个字符输出流
        FileWriter fileWriter = new FileWriter("E:/qy151/mulu/ppp.txt");

        //读取到字符的个数
        int a = 0;
        //把读取的内容放到数组当中
        char[] c = new char[10];
        while ((a = fileReader.read(c)) !=-1) {
            fileWriter.write(c,0,a);
            //刷新
            fileWriter.flush();
        }
        fileWriter.close();
        fileReader.close();
    }
}

4.字节流

4.1字节输出流--OutputStream

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

//测试字节输出流
@Test
    public void test() throws Exception {
        OutputStream out = new FileOutputStream("E:/qy151/AAA/bb.txt");
        String str = "asdfghjkl123456";
        //把字符串装换为字节数组
        byte[] bytes = str.getBytes();
        out.write(bytes);
        out.flush();
        out.close();
    }

4.2 字节输入流---InputStream

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

public class In {
    //如果文件内容非常大  就使用循环来读
    @Test
    public void test1() throws Exception {
        InputStream in = new FileInputStream("E:/qy151/AAA/bb.txt");
        byte[] bytes = new byte[200];
        //读取到的个数
        int c = 0;
        while ( (c = in.read(bytes)) !=-1){
            //把byte数组转换为字符串
            String s = new String(bytes,0,c);
            System.out.println(s);
        }
        in.close();
    }





    @Test
    public void test() throws Exception{
        InputStream in = new FileInputStream("E:/qy151/AAA/bb.txt");
        byte[] b = new byte[5];
        //一次读取五个字节  并把读取到的字节的内容放入到字节数组中  返回读取到字节的个数
        int c = in.read(b);
        System.out.println(b+"---------->个数: "+c);
        //一次读取五个字节  并把读取到的字节的内容放入到字节数组中  返回读取到字节的个数
        c = in.read(b);
        System.out.println(b+"---------->个数: "+c);
        //一次读取五个字节  并把读取到的字节的内容放入到字节数组中  返回读取到字节的个数
        c = in.read(b);
        System.out.println(b+"---------->个数: "+c);




    }
}

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

@Test
    public void Test() throws Exception {
        //1.创建字节输入流 视频
        InputStream in = new FileInputStream("E:/qy151/AAA/tu.jpg");
        //2.字节输出流
        OutputStream out = new FileOutputStream("E:/qy151/mulu/tu1.jpg");

        byte[] b = new byte[10];
        int c = 0;
        while ( (c = in.read(b)) !=-1 ) {
            out.write(b,0,c);
        }
        in.close();
        out.close();
    }

5.缓存流

        缓存流是在基础流[InputStream OutputStream Reader Writer]之上 添加了一个缓存池功能.

        BufferInutStream BufferOutputStream BufferReader BufferWriter 提高IO的效率，降低IO的次数。

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

 

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

为什么需要对象流

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

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

import org.junit.Test;


import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;

public class Myobjeat implements Serializable {
    private String name;//姓名
    private String property;//属性
    private String estate;//等级
    private int id;
    private String other;//其他属性


    public Myobjeat() {
    }

    @Override
    public String toString() {
        return "Myobjeat{" +
                "name='" + name + '\'' +
                ", property='" + property + '\'' +
                ", estate='" + estate + '\'' +
                ", id=" + id +
                ", other='" + other + '\'' +
                '}';
    }

    public Myobjeat(String name, String property, String estate, int id, String other) {
        this.name = name;
        this.property = property;
        this.estate = estate;
        this.id = id;
        this.other = other;
    }

    public String getName() {
        return name;
    }

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

    public String getProperty() {
        return property;
    }

    public void setProperty(String property) {
        this.property = property;
    }

    public String getEstate() {
        return estate;
    }

    public void setEstate(String estate) {
        this.estate = estate;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getOther() {
        return other;
    }

    public void setOther(String other) {
        this.other = other;
    }
}


import org.junit.Test;

import javax.management.relation.Role;
import java.io.*;

public class MyTest {
    @Test //存档：----序列化:
    public void testObjectStream() throws Exception {
        OutputStream out = new FileOutputStream("E:/qy151/AAA/bb.txt");
        //对象输出流
        ObjectOutputStream ob = new ObjectOutputStream(out);

        //使用对象输出流调用输出方法 输出的类对象 该类必须实现Serializable 序列化接口
        Myobjeat m = new Myobjeat("张飞","战士","99级",1,"老三");
        ob.writeObject(m);
        ob.close();
    }
  //测试 读档: ----反序列化:
    @Test
    public void test() throws Exception {
        InputStream in = new FileInputStream("E:/qy151/AAA/bb.txt");
        ObjectInputStream oob = new ObjectInputStream(in);
        Object o = oob.readObject();
        System.out.println(o);
        oob.close();
    }

}


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

总结:

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

 

阿磊学不会001
关注
专栏目录
File对象和IO流
m0_58380757的博客
04-19 251
目录 1.File对象 1.1file的介绍 1.2创建File对象 1.3增加操作 1.4删除操作 1.5修改操作 1.6查询操作 1.7经典题目: 用的方法的递归调用 2 IO流 2.1IO流介绍 2.2Writer字符输出 2.3Reader字符输入流 1.File对象 1.1file的介绍 File 类 就是当前系统中 文件或者文件夹的抽象表示 通俗的讲 就是 使用File对象 来操作我们电脑系统中的文件或者文件夹 学习File类 其实就是学习 如果通过...
IO流的总结和File类的总结
weixin_43447266的博客
08-19 193
IO流 一.为什么要学习IO流? 我们以前的数据都是存放在内存里的—程序一旦关闭,数据就会丢失. 我们可以通过IO远程传输数据(网络编程). 内存:不能永久存储数据,断电后(或关闭程序后),内存的数据就会被擦除. 硬盘:数据存储的一种介质,只要硬盘不坏,数据就会永久保存. File类 用来描述文件(或者文件夹),文件是否是可执行文件,文件是否可读,是否只写,文件多少个字节,文件的名称,文件的绝对路径,还可以操作文件或者文件夹 新建文件,新建文件夹.等等…File类只能操作文件或者文件夹本身(修改名称,创
JAVA——文件（File)对象与IO流
weixin_54204139的博客
04-20 1058
目录 1、File对象 2、File对象的使用 2.1 创建File对象 2.2 添加文件 2.3 删除操作 2.4 修改文件 2.5 查询文件 3、IO流 3.1 IO流概念 3.2 IO流的分类 3.3 Writer字符输出流 3.4 Reader字符输入流 1、File对象 File 类 就是当前系统中文件或者文件夹的抽象表示 ，通俗的讲就是使用File对象，来操作我们电脑系统中的文件或者文件夹。 File类 其实就是通过file对象，...
IO流与File对象基本操作
张叔的博客
10-17 726
一、IO流 1、IO流中的基本概念 IO流：用来处理设备之间的数据传输。 设备：各种存储设备 IO：用于处理设备上的数据的技术。设备：内存、硬盘、光盘等 流：系统资源，window系统本身就可以操作这些设备，各种语言只是使用系统平台上的这个资源。 并对外提供了各种语言自己的操作功能，这些功能最终调用的是系统资源。 流使用完一定要释放！ 流的分类： 字节流与字符流 操作的数据
Java中的File类和IO流
热门推荐
Jack
08-19 1万+
概述： 1.File：翻译是文件，用于表达java中的路径名。 2.路径：用于表示文件或者文件夹在当前系统中的位置 3.路径的分类： 绝对路径 相对路径 4.绝对路径：没有任何的歧义，也没有任何的前提条件 Windows，从盘符开始的路径，例如"D:/a/b/c/d/a.txt" ...
泛型 File对象 和IO流
m0_69719993的博客
04-20 204
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流
Luckydogs3036的博客
04-20 71
泛型 1. 什么是泛型？ 1. 泛型就是限制我们得数据类型。 2.为什么使用泛型? 我们原来在定义集合时，是如下得定义方式： List list=new ArrayList();//该集合没有使用泛型 list.add("java01"); list.add("java02"); String str= (String) list.get(0);//获取元素 需要进行强制类型转换 System.out.println(str...
泛型、File对象和IO流
m0_63515769的博客
04-19 281
目录 1. 泛型 2. File对象 3. IO流 1.泛型 1.1 什么是泛型 1、泛型是限制我们的数据类型。 2、为什么要使用泛型？ ​ 在未使用泛型时，我们定义集合默认是Object类型，可以放入任何数据类型，但是在使用集合内的数据时，需要强制转换为我们需要的类型，不方便对元素进行其他的操作。 List list = new ArrayList(); list.add("星期一"); list.add("星期二"); list.add("星期三"); String s = (String) lis
JAVA泛型、File对象、IO流
hzk_niubi1313的博客
04-19 218
1.泛型 1.1什么是泛型？ 1.泛型就是限制我们的数据类型。 2.为什么使用泛型？ 我们原来在定义集合时，是如下的定义方式： List list = new ArrayList();//该集合没有使用泛型 list.add(“李白”); list.add(“杜甫”); String str = (String) list.get(0);//获取元素，需要进行强制类型转换 System.out.println(str); 获取元素时，不方便对元素进行相应的其他操作。 1.2如何使用泛型 List&
多线程精品资源--Java教程，包括多线程，泛型，反射，IO，容器类,注解.zip
02-17
Java编程语言以其强大的功能和广泛的应用领域而备受程序员青睐，特别是在多线程、泛型、反射、输入/输出（IO）以及容器类和注解等方面的深入理解和应用，能够提升程序的性能和可维护性。本资源包聚焦于这些关键知识...
JavaTutorial, Java教程，包括多线程，泛型，反射，IO，容器类,注解.zip
09-17
Java的IO系统提供了丰富的类和接口来处理输入和输出，包括File类、InputStream和OutputStream类族、Reader和Writer类族等。NIO（New IO）是Java 1.4引入的改进，提供了一种非阻塞I/O模型，可以提高性能，特别是在...
580.578.JAVA基础教程_泛型与File-File类的课后练习(580).rar
11-09
Java编程语言是软件开发领域广泛使用的工具，尤其在企业级应用...通过这个Java基础教程的泛型与File类部分，你将能够更加自如地应对实际项目中的文件操作和类型安全问题。不断实践和总结，你的编程能力将得到显著提升。
565.563.JAVA基础教程_泛型与File-为什么要使用泛型(565).rar
11-09
5. **文件I/O操作：** 虽然File类本身并不直接进行文件的读写，但它可以与其他I/O流结合使用，如`new FileInputStream(file)`和`new FileOutputStream(file)`。 了解并熟练运用泛型和File类是每个Java开发者的基本...
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 362
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 737
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 246
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 1058
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
面试突击-多线程和IO专题(至尊典藏版)
人生若只初相见@的博客
09-18 1813
金九银十多线程和IO大厂面试专题
《Java 语言程序设计》实验报告：泛型、集合和IO流的使用 实验06
本次实验的目的是为了让学生们对泛型、集合以及 Java IO 流等概念有更深入的理解，并学习并掌握相关的类及其方法的使用。通过本次实验，学生将能够应用泛型动态数组作为工具，使用课本195页的File对象及其方法，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值