扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Java IO流学习总结之文件传输基础
  • 913

0
分享到

Java IO流学习总结之文件传输基础

2024-04-02 19:04:59 913人浏览 八月长安

Python 官方文档：入门教程 => 点击学习

摘要

目录一、Java io流总览二、File类2.1 常用api2.2 遍历目录三、RandoMaccessFile类四、字节流4.1 FileInputStream4.2 FileOu

一、Java IO流总览

IO流总览

二、File类

2.1 常用API


package pkg1;

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


public class FileDemo {
    public static void main(String[] args) {
        // 了解构造函数，可查看API
        File file = new File("d:\\javaio\\cook");
        // 设置分隔符，不同系统也可以认识
        //File file=new File("d:"+File.separator);

        //System.out.println(file.exists());
        if (!file.exists()) {
            file.mkdirs();
        } else {
            file.delete();
        }

        //  是否是一个目录，如果是目录返回true,如果不是目录或目录不存在返回false
        System.out.println(file.isDirectory());
        // 如果是一个文件
        System.out.println(file.isFile());

        //File file2 = new File("d:\\javaio\\日记1.txt");
        File file2 = new File("d:\\javaio", "日记1.txt");
        if (!file2.exists()) {
            try {
                file2.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            file2.delete();
        }

        // 常用File对象的api
        System.out.println(file);// file.toString()的内容
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getName());
        System.out.println(file2.getName());
        System.out.println(file.getParent());
        System.out.println(file2.getParent());
        System.out.println(file.getParentFile().getAbsolutePath());
    }
}

测试结果：

在这里插入图片描述

其他API：


package pkg1;

import java.io.*;
import java.util.RandomAccess;


class FileDemo2 {
    public static void main(String[] args) {
        File file = new File("d:\\javaio\\example");
        if (!file.exists()) {
            file.mkdir();
        }

        

        

        File[] files = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                System.out.println(pathname);
                return false;
            }
        });
        for (File fileName : files) {
            System.out.println(fileName.toString());
        }

    }

}

测试：

在这里插入图片描述

2.2 遍历目录


package pkg2;

import java.io.File;


public class FileUtils {
    
    public static void listDirectory(File dir) throws IllegalAccessException {
        if (!dir.exists()) {
            throw new IllegalArgumentException("目录:" + dir + "不存在");
        }
        if (!dir.isDirectory()) {
            throw new IllegalArgumentException(dir + "不存在");
        }

        // list()用于列出当前目录下的子目录（不包含子目录下的内容）和文件。返回的是字符串数组。
        



        // 若要遍历子目录下的内容，就要构造成File对象进行递归操作。File提供了直接返回File对象的API
        File[] files = dir.listFiles();//返回直接子目录（文件）的抽象
        
        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isDirectory()) {
                    // 递归
                    listDirectory(file);
                } else {
                    System.out.println(file);
                }
            }
        }
    }
}

测试类：


package pkg2;

import java.io.File;

public class FileUtilsTest {
    public static void main(String[] args) throws IllegalAccessException {
        FileUtils.listDirectory(new File("d:javaio"));
    }
}

测试结果：

在这里插入图片描述

三、RandomAccessFile类


package pkg3;

import java.io.*;
import java.util.Arrays;

public class RafDemo {
    public static void main(String[] args) throws IOException {
        // 若没有指定路径，则表示相对路径，即项目所在路径。
        File demo = new File("demo");
        if (!demo.exists()) {
            demo.mkdir();
        }

        File file = new File(demo, "raf.dat");
        if (!file.exists()) {
            file.createNewFile();
        }

        RandomAccessFile raf = new RandomAccessFile(file, "rw");
        // 查看指针位置
        System.out.println(raf.getFilePointer());// 0

        raf.writeInt('A');// 只写了一个字节
        System.out.println(raf.getFilePointer());
        raf.writeInt('B');

        int i = 0x7fffffff;
        // 用write方法每次只能写一个字节，如果要把i写进去就要写4次
        raf.writeInt(i >>> 24);//高8位
        raf.writeInt(i >>> 16);
        raf.writeInt(i >>> 8);
        raf.writeInt(i);// 低8位
        System.out.println(raf.getFilePointer());

        // 直接写一个int ,与上述4步操作等效
        raf.writeInt(i);

        String s = "中";
        byte[] gbk = s.getBytes("gbk");
        raf.write(gbk);
        System.out.println("raf长度：" + raf.length());


        // 读文件，必须把指针移到头部
        raf.seek(0);
        // 一次性读取，把文件中的内容都读到字节数组汇总
        byte[] buf = new byte[(int) raf.length()];
        raf.read(buf);
        System.out.println(Arrays.toString(buf));
        // 转为字符串
        
        for (byte b : buf) {
            System.out.print(Integer.toHexString(b & 0xff) + " ");
        }

        raf.close();
    }
}

测试结果：

在这里插入图片描述

四、字节流

4.1 FileInputStream


package pkg4;

import java.io.*;

public class IOUtil {
    
    public static void printHex(String fileName) throws IOException {
        // 把文件作为字节流进行操作
        FileInputStream fis = new FileInputStream(fileName);
        int b;
        int i = 1;

        while ((b = fis.read()) != -1) {
            if (b <= 0xf) {
                // 单位数前补0
                System.out.print("0");
            }

            // 将整型b转换为16进制表示的字符串
            System.out.print(Integer.toHexString(b) + " ");
            if (i++ % 10 == 0) {
                System.out.println();
            }
        }
        fis.close();
    }

    public static void printHexByByteArray(String fileName) throws IOException {
        FileInputStream fis = new FileInputStream(fileName);
        

        // 当字节数组容量不够，一次读不完时
        byte[] buf = new byte[8 * 1024];
        int bytes = 0;
        int j = 1;
        while ((bytes = fis.read(buf, 0, buf.length)) != -1) {
            for (int i = 0; i < bytes; i++) {
                // byte是8位，int类型是32位，为了避免数据转换错误，通过&0xff将高24位清零
                System.out.print(Integer.toHexString(buf[i] & 0xff) + " ");
                if (j++ % 10 == 0) {
                    System.out.println();
                }
            }
        }

        fis.close();
    }

    
    public static void copyFile(File srcFile, File destFile) throws IOException {
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("文件：" + srcFile + "不存在");
        }
        if (!srcFile.isFile()) {
            throw new IllegalArgumentException(srcFile + "不是文件");
        }

        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);
        byte[] buf = new byte[8 * 1024];
        int b;
        while ((b = fis.read(buf, 0, buf.length)) != -1) {
            fos.write(buf, 0, b);
            fos.flush();//最好加上这个
        }
        fis.close();
        fos.close();
    }

    
    public static void copyFileByBuffer(File srcFile, File destFile) throws IOException {
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("文件：" + srcFile + "不存在");
        }
        if (!srcFile.isFile()) {
            throw new IllegalArgumentException(srcFile + "不是文件");
        }

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
        int c;
        while ((c = bis.read()) != -1) {
            bos.write(c);
            // 刷新缓冲区。不能省略，否则无法写入
            bos.flush();
        }
        bis.close();
        bos.close();
    }

    
    public static void copyFileByByte(File srcFile, File destFile) throws IOException {
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("文件：" + srcFile + "不存在");
        }
        if (!srcFile.isFile()) {
            throw new IllegalArgumentException(srcFile + "不是文件");
        }

        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        int b;
        while ((b = fis.read()) != -1) {
            fos.write(b);
            fos.flush();
        }
        fis.close();
        fos.close();
    }
}

测试类：


package pkg4;

import java.io.IOException;

public class IOUtilTest1 {
    public static void main(String[] args) {
        try {
            IOUtil.printHex("d:\\javaio\\FileUtils.java");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.2 FileOutputStream


package pkg5;

import pkg4.IOUtil;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutDemo {
    public static void main(String[] args) throws IOException {
        // 如果该文件不存在，则直接创建，如果存在，则删除后创建。若要在后面追加内容，参数中加一个true
        FileOutputStream fos = new FileOutputStream("demo/out.dat");
        // 写入A的低8位
        fos.write('A');
        fos.write('B');
        // write只能写8位，那么写一个int需要4次，每次8位
        int a = 10;
        fos.write(a >>> 24);
        fos.write(a >>> 16);
        fos.write(a >>> 8);
        fos.write(a);
        byte[] gbk = "中国".getBytes("gbk");
        fos.write(gbk);
        fos.close();

        IOUtil.printHex("demo/out.dat");
    }
}

测试类：


package pkg5;

import pkg4.IOUtil;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.IOException;

public class IOUtilTest3 {
    public static void main(String[] args) {
        try {
            IOUtil.copyFile(new File("d:\\javaio\\abc.txt"), new File("d:\\javaio\\abc1.txt"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.3 DataInputStream 、DataOutputStream

输入流：


package pkg6;

import pkg4.IOUtil;

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DisDemo {
    public static void main(String[] args) throws IOException {
        String file = "demo/dos.dat";
        IOUtil.printHex(file);

        DataInputStream dis = new DataInputStream(new FileInputStream(file));
        int i = dis.readInt();
        System.out.println(i);

        i = dis.readInt();
        System.out.println(i);

        long l = dis.readLong();
        System.out.println(l);

        double d = dis.readDouble();
        System.out.println(d);

        String s = dis.readUTF();
        System.out.println(s);

        dis.close();
    }
}

输出流：


package pkg6;

import pkg4.IOUtil;

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DosDemo {
    public static void main(String[] args) throws IOException {
        String file = "demo/dos.dat";
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
        dos.writeInt(10);
        dos.writeInt(-10);
        dos.writeLong(10l);
        dos.writeDouble(10.5);
        // 采用utf-8写入
        dos.writeUTF("中国");
        // 采用utf-16be写入
        dos.writeChars("中国");

        dos.close();
        IOUtil.printHex(file);
    }
}

4.4 字节缓冲流

工具类在4.1小节的IOUtil.java中。

测试类：


package pkg7;

import pkg4.IOUtil;

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

public class IOUtilTest4 {
    public static void main(String[] args) {
        // 效率最高
        try {
            long start = System.currentTimeMillis();
            IOUtil.copyFile(new File("d:\\javaio\\Alpha.mp3"), new File("d:\\javaio\\Alpha1.mp3"));
            long end = System.currentTimeMillis();
            System.out.println("耗时1：" + (end - start));
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 效率居中
        try {
            long start = System.currentTimeMillis();
            IOUtil.copyFileByBuffer(new File("d:\\javaio\\Alpha.mp3"), new File("d:\\javaio\\Alpha2.mp3"));
            long end = System.currentTimeMillis();
            System.out.println("耗时2：" + (end - start));
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 效率最差
        try {
            long start = System.currentTimeMillis();
            IOUtil.copyFileByByte(new File("d:\\javaio\\Alpha.mp3"), new File("d:\\javaio\\Alpha3.mp3"));
            long end = System.currentTimeMillis();
            System.out.println("耗时3：" + (end - start));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

五、字符流

5.1 InputStreamReader、OutputStreamWriter


package pkg8;

import java.io.*;

public class IsrAndOswDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("d:\\javaio\\aa.txt");
        InputStreamReader isr = new InputStreamReader(fis);//未指定编码格式，即按照项目默认编码操作

        FileOutputStream fos = new FileOutputStream("d:\\javaio\\aa.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos);//未指定编码格式，即按照项目默认编码操作

        

        
        char[] buffer = new char[8 * 1024];
        int c;
        while ((c = isr.read(buffer, 0, buffer.length)) != -1) {
            String s = new String(buffer, 0, c);
            System.out.print(s);

            
        }

        isr.close();
        osw.close();
    }
}

5.2 FileReader、FileWriter


package pkg8;

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

public class FrAndFwDemo {
    
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("d:\\javaio\\aa.txt");
        // 指定参数，也可以追加内容：FileWriter(String fileName, boolean append)
        FileWriter fw = new FileWriter("d:\\javaio\\bb.txt");
        char[] buffer = new char[8 * 1024];
        int c;
        while ((c = fr.read(buffer, 0, buffer.length)) != -1) {
            fw.write(buffer, 0, c);
            fw.flush();
        }
        fr.close();
        fw.close();
    }
}

5.3 BufferedReader、BufferedWriter、PrintWriter


package pkg9;

import java.io.*;

public class BrAndBwOrPwDemo {
    public static void main(String[] args) throws IOException {
        // 对文件进行读写操作
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d:\\javaio\\aa.txt")));
        //BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d:\\javaio\\cc.txt")));
        // PrintWriter可以替换BufferedWriter
        PrintWriter pw = new PrintWriter("d:\\javaio\\cc.txt");

        String line;
        while ((line = br.readLine()) != null) {
            // 一次读一行，不能识别换行
            System.out.println(line);
            
            pw.println(line);
            pw.flush();
        }
        br.close();
        //bw.close();
        pw.close();
    }
}

六、对象的序列化、反序列化

6.1 transient关键字、序列化、反序列化

实体类：


package pkg10;

import java.io.Serializable;

public class Student implements Serializable {
    private String stuNo;
    private String stuName;
    // 该元素不会 进行JVM默认的序列化，但可以手动序列化
    private transient int stuAge;

    public Student(String stuNo, String stuName, int stuAge) {
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.stuAge = stuAge;
    }

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public int getStuAge() {
        return stuAge;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuNo='" + stuNo + '\'' +
                ", stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }

    
    private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
        // 把JVM能默认序列化的元素进行序列化操作
        s.defaultWriteObject();
        // 手动完成stuAge的序列化
        s.writeInt(stuAge);
    }

    
    private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
        // 把JVM默认能反序列化的元素进行反序列化操作
        s.defaultReadObject();
        // 手动完成stuAge的反序列化
        stuAge = s.readInt();
    }
}

测试类：


package pkg10;

import java.io.*;
import java.util.ArrayList;

public class ObjectSeriaDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String file = "demo/obj.dat";
        // 1、对象的序列化
        
        // 2、对象的反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        Student stu = (Student) ois.readObject();
        System.out.println(stu);
        ois.close();
    }

}

6.2 序列化、反序列化时，子类、父类构造方法的调用


package pkg11;

import java.io.*;
import java.sql.SQLOutput;

public class ObjectSeriaDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 序列化
        

        // 反序列化
        



        

        



        

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("demo/obj1.dat"));
        Ccc2 ccc2 = (Ccc2) ois.readObject();
        System.out.println(ccc2);
        ois.close();
    }
}


class Foo implements Serializable {
    public Foo() {
        System.out.println("foo...");
    }
}

class Foo1 extends Foo {
    public Foo1() {
        System.out.println("foo1...");
    }
}

class Foo2 extends Foo1 {
    public Foo2() {
        System.out.println("foo2...");
    }
}




class Bar {
    public Bar() {
        System.out.println("Bar...");
    }
}

class Bar1 extends Bar implements Serializable {
    public Bar1() {
        System.out.println("Bar1...");
    }
}

class Bar2 extends Bar1 {
    public Bar2() {
        System.out.println("Bar2...");
    }
}



class Ccc {
    public Ccc() {
        System.out.println("Ccc...");
    }
}

class Ccc1 extends Ccc {
    public Ccc1() {
        System.out.println("Ccc1...");
    }
}

class Ccc2 extends Ccc1 implements Serializable {
    public Ccc2() {
        System.out.println("Ccc2...");
    }
}

Foo2类反序列化时不打印构造方法：

在这里插入图片描述

Bar2类反序列化时打印了Bar的构造方法：

在这里插入图片描述

Ccc2类反序列化时打印了Ccc、Ccc1的构造方法：

在这里插入图片描述

结论（详见导图标红部分）：

对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用。

到此这篇关于Java IO流学习总结之文件传输基础的文章就介绍到这了,更多相关Java IO流文件传输内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: Java IO流学习总结之文件传输基础

本文链接: https://lsjlt.com/news/124192.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Java IO流学习总结之文件传输基础
    目录一、Java IO流总览二、File类2.1 常用API2.2 遍历目录三、RandomAccessFile类四、字节流4.1 FileInputStream4.2 FileOu...
    99+
    2024-04-02
  • Java基础学习之IO流应用案例详解
    目录一、点名器二、集合到文件三、文件到集合一、点名器 需求： 我有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随机点名器 实现步骤： 创建字符缓冲输入流对象创...
    99+
    2024-04-02
  • Java IO 学习总结（三）BufferedInputStream 缓冲流
    Java IO 学习总结（一）输入流/输出流 Java IO 学习总结（二）File 类 Java IO 学习总结（三）BufferedInputStream Java IO 学习总结（四）Buffe...
    99+
    2023-09-15
    java 学习 缓存
  • Spring5学习之基础知识总结
    目录1.概述2.入门Demo3.源码1.概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、 Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部...
    99+
    2024-04-02
  • MySQL学习之基础操作总结
    目录1.库的操作2.表的操作创建表查看表结构删除表修改表1.库的操作 查看当前mysql数据库下默认有哪些库 show databases; 创建一个库 create databas...
    99+
    2024-04-02
  • Java基础学习之字符串知识总结
    目录一、前言二、String 类（字符串常量）2.1 String 类实例的创建2.2 String 对象的比较2.3 String对象的空值2.4 字符串拼接三、StringBui...
    99+
    2024-04-02
  • Java IO 学习总结（四）BufferedReader 缓冲字符流
    Java IO 学习总结（一）输入流/输出流 Java IO 学习总结（二）File 类 Java IO 学习总结（三）BufferedInputStream Java IO 学习总结（四）Buffe...
    99+
    2023-09-27
    java 学习 缓存
  • C++基础学习之输入输出流详解
    目录1. 输入输出流2. 文件输入输出3. 格式化输入输出4. 字符串输入输出5. 空格处理C++是一种广泛应用的编程语言，其输入和输出是程序所必须的基本操作之一。输入是指从外部获取...
    99+
    2023-05-17
    C++输入输出流 C++输入流 C++输出流
  • CISP-PTE学习总结之基础练习题（二）
    文章目录 基础题目一：SQL注入0x01 题目要求0x02 解题过程 基础题目二：文件上传突破0x01 题目要求0x02 解题过程 基础题目...
    99+
    2023-10-03
    数据库 sql mysql
  • Java基础学习之运算符相关知识总结
    1.算术运算符 +表示加法运算符 -表示减法运算符 *表示乘法运算符 /表示除法运算符 %表示取模/取余运算符 package com...
    99+
    2024-04-02
  • Java基础学习之方法的重载知识总结
    目录一、什么是方法的重载？二、构成方法重载的条件三、重点一、什么是方法的重载？ 方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配...
    99+
    2024-04-02
  • MySQL学习之基础命令实操总结
    目录启动mysql服务连接mysql常用命令DatabaseTable启动mysql服务 （以管理员身份运行cmd） net start mysql 连接mysql mysql -...
    99+
    2024-04-02
  • python基础学习之生成器与文件系统知识总结
    目录一、生成器二、文件系统一、生成器 首先解释迭代器。 能以一种一致的方式对序列进行迭代（比如列表中的对象或文件中的行）是Python的一个重要特点。这是通过一种叫做迭代器协议（it...
    99+
    2024-04-02
  • C++之IO类,文件输入输出,string流练习题
    目录前面已经在用的IO库设施IO类IO对象不能拷贝或赋值条件状态管理输出缓冲文件输入输出fstream特有的操作文件模式string流stringstream特有的操作练习练习1练习...
    99+
    2024-04-02
  • python基础学习之组织文件
    目录一、Shutil 模块1.1 复制文件和文件夹1.2 移动文件和文件夹1.3 删除文件和文件夹二、遍历文件三、压缩文件3.1 创建和添加ZIP文件3.2 读取ZIP文件3.3 解...
    99+
    2024-04-02
  • python基础学习之递归函数知识总结
    目录一、递归函数使用注意点二、递归的效率问题三、递归函数引入四、递归的深度五、通过缓存解决递归限制六、递归函数使用示例一、递归函数使用注意点 递归函数一定要编写终止条件，否则将产生无...
    99+
    2024-04-02
  • Java基础学习之Swing事件监听
    目录一、初始代码架构二、需求分析2.1 写监听器2.2 发现问题2.3 使用匿名内部类优化代码2.4 优化完之后发现还是不是很优雅2.5 使用Lambda表达式再优化2.6 最终的代...
    99+
    2024-04-02
  • python基础之文件处理知识总结
    目录一、open()方法二、read()方法三、readlines()方法四、seek()方法五、tell()函数  一、open()方法 python open...
    99+
    2024-04-02
  • Java基础学习之字符缓冲流的应用
    目录一、字符缓冲流二、字符缓冲流复制Java文件三、字符缓冲流特有功能四、字符缓冲流特有功能复制Java文件一、字符缓冲流 字符缓冲流介绍： BufferedWriter：将文本写入...
    99+
    2024-04-02
  • Python基础之元组与文件知识总结
    目录大纲Python文件类型及汇总一、元组二、文件三、pickle存储和读取python对象四、类型汇总大纲 Python文件类型及汇总 一、元组 1 特征 1.任意对象的有序集...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作