序列化、打印流（IO补充）、线程

最新推荐文章于 2024-08-29 18:44:48 发布
最新推荐文章于 2024-08-29 18:44:48 发布
阅读量812 收藏 18
点赞数 24
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77165049/article/details/135418267
版权

第一章 序列化

1.概述

java提供了一种对象序列化的机制。用一个字节序列表示一个对象，该字节序列包含对象的数据、对象的类型、对象的属性等..... 字节写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，字节序列还可以从文件中读取回来，重构对象。进行反序列化。对象的数据、类型、属性等信息，都可以用来在内存中创建对象。

2.ObjectOutputStream类 序列化流

可以将java对象的原始数据类型写出到文件，实现对象的持久存储。

序列化操作：相当于是进行加密和解密，让其非正常显示。

        1.一个对象想要被序列化，必须满足两个条件

                1.1: 该类必须实现java.io.Serializable接口，Serializable接口是一个标记接口如果不实现这个接口，不能被序列化或者反序列化，会抛出NotSerializableException异常。

                1.2： 该类的所有属性必须是能序列化的，如果由一个属性不需要可序列化，则该属性必须注明是瞬态的，使用transient关键字修饰；

                瞬态：瞬态属性通常存储临时状态或者临时计算结果，不需要持久存储。

public class Demo01 {
    public static void main(String[] args) throws Exception {
        /**
         * ObjectOutputStream 序列化流构造方法
         */
        FileOutputStream fileOutputStream=new FileOutputStream("a.txt");
        ObjectOutputStream out=new ObjectOutputStream(fileOutputStream);
        Student student=new Student("zhang3","哈尔滨",33);
        out.writeObject(student);//序列化，写入文件
        out.close();
        fileOutputStream.close();
    }
}

3.ObjectInputStream类 反序列化流

public class Demo02 {
    /**
     * ObjectInputStream 反序列化流
     */
public static void main(String[]args)throws Exception{

        Student s=null;
        FileInputStream fileInputStream= new FileInputStream("a.txt");
        ObjectInputStream in=new ObjectInputStream(fileInputStream);
//        读一个对象
        s= (Student) in.readObject();
        in.close();
        fileInputStream.close();
        System.out.println("s = "+s);
    }
}

第二章 打印流

平时控制台打印输出，都是调用print或者println方法，这两个方法都来自于java.io.PrintStream类，该类能够方便的打印各种数据类型的值。是一种便捷输出

public class Demo03 {
    public static void main(String[] args) throws Exception {
        /**
         * PrintStream类  构造方法
         */
        PrintStream printStream = new PrintStream("a.txt");
        /**
         * System.out  就是PrintStream类  只不过他的流向是系统规定的流向控制台，可用set修改
         */
        System.out.println("97");

//      设置系统的打印流走向 ， 输出到a.txt;
        System.setOut(printStream);
        System.out.println(96);
        System.out.println(96);

    }
}

上述代码会将 '97' 输出到控制台，将两个 '96' 写到  “a.txt” 文件中，因为用了System.setOut(printStream);改变流向。

第三章 多线程

之前写代码 如果没有跳转语句都是从上到下的执行，那么现在想要设计一个程序， 边打游戏边听歌，怎么设计？

解决上面问题，就要使用多线程或者多进程解决。

 1.并发与并行。

- 并行：指两件或者多个事件同一时刻发生（同时执行）。

- 并发：指两件或者多个事情同一个时间段内发生（交替执行）。

 2.进程和线程

- 进程：指内存中运行的应用程序，一个应用程序可以同时运行多个进程，进程也是程序的依次执行的过程。是系统运行程序的基本单位。系统运行一个程序就是进程创建、运行、消亡的过程。

- 线程：进程中的一个执行单元，负责当前进程中程序的执行，一个进程至少有一个线程。一个进程如果有多个线程，这个应用程序就称之为多线程程序。

 3.线程类

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

       java 使用java.lang.Thread 类代表线程，所有线程对象都必须是Thread或者其子类的实例。

每个线程的作用是完成一定的任务，其实就是执行一段程序或者代码。

java中通过继承Thread类来创建并启动多线程。

步骤：

        1.定义Thread类的子类，重写该类中的run方法，run方法的方法体中内容就代表了线程需要完成的任务。

         2.创建Thread子类的实例，也就是创建了线程对象。

         3.调用线程对象的start方法启动线程。

public class MyThread extends Thread{

//    定义指定线程名称的构造方法
    public MyThread(String name){
//    调用父类的String参数的构造方法，可以执行线程名称
        super(name);
    }
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"正在运行"+i);

        }
    }
}

public class Demo04 {
    public static void main(String[] args) {
    MyThread myThread=new MyThread("我的线程");
        myThread.start();
        for (int i = 0; i < 99; i++) {
            System.out.println("main线程"+i);
        }
    }
}

打印输出“我的线程”和“main线程”交替打印

4.Thread类Api

Thread类：

  构造方法：

        * public Thread(): 分配一个新的线程对象

        * public Thread(String name): 分配一个指定名字的新的线程对象

        * public Thread(Runnable target): 分配一个带有指定目标的新的线程对象

        * public Thread(Runnable target,String name) :分配一个带有指定目标的新的线程对象并指定名字

   常用方法：

        * public String getName(): 获取当前线程的名字

        * public void start(): 让此线程开始执行

        * public void run(): 此线程执行任务的代码在此定义

        * public static void sleep(long millis): 当前在在执行的线程以指定的毫秒数暂停

        * public static Thread currentThread(): 返回对当前正在执行的线程对象。

    5.实现接口方式创建线程

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 99; i++) {
            System.out.println(Thread.currentThread().getName() + "  " + i);

        }
    }
}
public class Demo06 {
    public static void main(String[] args) {
//        创建自定义类对象    线程任务对象
        MyRunnable mr =new MyRunnable();
//        创建线程对象
        Thread t =new Thread(mr,"小强");
//        开启线程
        t.start();
        for (int i = 0; i < 99; i++) {
            System.out.println("main"+i);
        }
    }
}

6.匿名内部类方式


/**
 * 使用匿名内部类方式  方便创建对象或实现接口
 */
public class Demo07 {
    public static void main(String[] args) {
        Runnable r=
           new Runnable(){
            public void run(){
                for (int i = 0; i <99 ; i++) {
                    System.out.println("kfc"+i);
                }
            }
        };
//        少用一个变量承接
        new Thread(new Runnable(){
            public void run(){
                for (int i = 0; i <99 ; i++) {
                    System.out.println("wwwwwww"+i);
                }
            }
        }).start();
//        main线程
        for (int i = 0; i <99 ; i++) {
            System.out.println("main线程"+i);

        }
    }
}

第四章 线程安全

1.线程安全概述

比如 现在有多个线程同时运行，所有线程都需要操作同样的变量。如果程序每次运行结果和单线程运行结果是一样的，而且变量的值也和预期一样，就是线程安全的。

代码模拟四个窗口同时售卖100张票：

public class MyRunnalbe01 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
//        窗口永远开启
        while (true) {
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
            }
        }
    }
}

public class Demo08 {
    public static void main(String[] args) {
//        创建线程任务对象
        MyRunnalbe01 myRunnalbe01 =new MyRunnalbe01();
//        创建4个窗口对象
        Thread  t1 =new Thread(myRunnalbe01,"窗口01");
        Thread  t2 =new Thread(myRunnalbe01,"窗口02");
        Thread  t3 =new Thread(myRunnalbe01,"窗口03");
        Thread  t4 =new Thread(myRunnalbe01,"窗口04");

//        同时卖票
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

会发现结果打印出现多个窗口卖了同一张票的情况：

窗口02正在卖：10

窗口04正在卖：10

窗口04正在卖：7

窗口01正在卖：7

窗口02正在卖：7

窗口03正在卖：7

发现程序出了问题，这种问题称为线程不安全。

线程安全问题 都是由全局变量或者静态变量引起的。若每个线程对变量只是读操作，没有写操作，一般来说都是安全的。如果多个线程同时执行写操作，就要考虑线程安全。

2.线程同步

如果要解决多线程并发访问一个资源的安全性问题，也就是票存在还是不存在的问题 ，java中提供了同步机制(synchronized)来解决。

根据案例简述：

例如窗口1线程进入操作的时候，窗口2和窗口3只能在外等待，窗口1结束，窗口1，2，3才有机会去执行，也就是说某个线程修改共享资源时，其他线程不能修改这个资源。等修改完毕之后，才能去抢夺资源。

上述问题有三种解决方法：

1.同步代码块。

2.同步方法。

3.锁机制。

3.同步代码块

- 同步代码块：sychronized 关键字 可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

- 格式：

synchronized(同步锁){

        需要同步操作的代码

}

同步锁：对象的同步锁是一个概念，可以想象为在对象上标记了一个锁。

1.锁对象 可以是任意类型。

2.多个线程对象，要使用同一把锁。

任何时候，最多只需一个线程拥有同步锁，谁拿到锁谁就能进入到代码块，其他的线程只能在外等待（Blocked）

使用同步代码块解决代码：

public class MyRunnalbe01 implements Runnable {
    private int ticket = 100;
    Object lock =new Object();
    @Override
    public void run() {
        // 窗口永远开启
        while (true) {
            synchronized (lock){
                if (ticket > 0) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
                }
            }
        }
    }
}

4.同步方法：

- 同步方法：使用synchronized修饰的方法叫做同步方法，保证一个线程执行该方法的时候 其他线程只能在方法外等待，

public class MyRunnalbe02 implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            sellTicket();
        }
    }
    private synchronized void sellTicket() {
        if (ticket > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
        }
    }
}

5.Lock锁

Lock机制 提供了一个比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块、同步方法具有的功能Lock都有，除此之外更加强大，更体现了面向对象。

Lock锁也叫做同步锁，加锁和释放锁方法化了，

- public void lock(): 加同步锁

- public void unlock();释放同步锁

public class MyRunnalbe03 implements Runnable {
    private int ticket = 100;
    Lock lock=new ReentrantLock();
    @Override
    public void run() {
//        窗口永远开启
        while (true) {
            lock.lock();
            if (ticket > 0) {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
            }
            lock.unlock();
        }
    }
}

第五章 线程状态

1.概述

在线程的生命周期中一共有6种状态：

        * new（新建）刚被创建还没启动

        * Runnable（可运行状态）线程在java虚拟机中的运行状态,可能在运行自己的代码,也可能没有,取决于操作系统。

         * Blocked (锁阻塞)当一个线程试图获取一个对象锁,但是对象锁被其他线程持有,则该线程进入所阻塞状态。持有锁的线程是Runnable状态。

         *Waiting(无限等待)一个线程在等待另一个线程执行一个唤醒动作,该线程进入  Waiting状态。这个状态不能自动唤醒,必须等待另一个线程调用notify或者notifyAll方法才能够唤醒

        * TimedWaiting(记时等待） 同waiting状态,这个状态一直保存到唤醒动作或者超时。         *Teminated(被终止）因为run方法正常退出而死亡,或者因为没有捕获到异常终止了run方法而死亡。

2.睡眠sleep方法

public static void sleep(long time) 让当前线程进入到睡眠状态，到毫秒值后自动醒来继续执行

3.等待和唤醒

Object类的方法

public void wait（）：让当前线程进入到等待状态，这个方法必须锁对象调用。

public class Demo09 {
    public static void main(String[] args) throws InterruptedException {
//    步骤1：子线程开启，进入无限等待状态，如果没有被唤醒  将无法继续运行。
        Runnable r = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("beagin wait ....");
                    synchronized ("") {
                        "".wait();
                    }
                    System.out.println("over");
                } catch (Exception e) {

                }
            }
        };
        new Thread(r).start();
//    步骤2：加入如下代码，3秒之后会执行notify方法，唤醒wait中的线程
        Thread.sleep(3000);
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized ("") {
                    System.out.println("唤醒");
                    "".notify();
                }
            }
        }).start();
    }
}

4.多线程小练习

题目要求：利用多线程求解某范围素数,每个线程负责 1000范围：线程1找1-1000；线 程 2 找 1001-2000；线程 3 找 2001-3000。编程程序将每个线程找到的素数及时打印。所有的素数输出完毕后，再输出素数的总数；

分析：由题可知需要一个类实现Runnable接口，在重写run方法中表明查找素数需求且传入参数为线程负责范围，因为三线程负责范围没有交集，所以不需要锁对象。

public class FindPrimesTask implements Runnable{
    private int start;
    private int end;
    // 创建一个集合用于存储各线程找到的素数
    List<Integer> primeNumbers = new ArrayList<>();
    // 定义一个任务，用于查找指定范围内的素数并将其添加到集合中
    public FindPrimesTask(int start, int end) {
        this.start = start;
        this.end = end;
    }
    @Override
    public void run() {
        for (int num = start; num <= end; num++) {
            if (isPrime(num)) {
                System.out.println(Thread.currentThread().getName()+"找到素数"+num);
                primeNumbers.add(num);
            }
        }
        System.out.println(Thread.currentThread().getName()+"素数总数：" + primeNumbers.size());
    }
    // 判断一个数是否为素数
    public static boolean isPrime(int num) {
        if (num < 2) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
}

public class Demo10 {
    public static void main(String[] args) {

        // 创建三个线程，每个线程负责1000范围内的素数查找
        FindPrimesTask task1 = new FindPrimesTask(1, 1000);
        FindPrimesTask task2 = new FindPrimesTask(1001, 2000);
        FindPrimesTask task3 = new FindPrimesTask(2001, 3000);

        // 启动线程
        Thread thread1 = new Thread(task1,"线程1");
        Thread thread2 = new Thread(task2,"线程2");
        Thread thread3 = new Thread(task3,"线程3");

        // 等待所有线程完成任务
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

李哈哈哈切
关注
  • 24
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java语言基础六之(IO流、多线程)
bier_zm的博客
08-15 1639
1、IO流 io ==> input & output分类 按读写数据的基本单位分类 -- 字节流 和 字符流。 其中字节流主要指以字节为单位进行数据读写的流，可以读写任意类型的文件。 其中字符流主要指以字符(2个字节)为单位进行数据读写的流，只能读写文本文件。 按照读写数据的方向不同分类 -- 输入流 和 输出流（站在程序的角度） 其中输入流主要指从文件中读取数据内容输入到程序中，也就是读文件。 其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。
Java中序列化和打印流
ONESTARの博客
07-12 2792
目录 一、对象序列化和反序列化 1、概述 2、对象序列化ObjectOutputStream和反序列化ObjectInputStream 二、序列化注意事项 1、静态不能序列化 2、瞬态 transient 关键字 3、Serializable 接口的含义 4、序列化中的序列号冲突问题 三、打印流 1、打印流特点 2、打印流常用的方法 3、打印流开启自动刷新 4、打印流复...
Java笔记：序列化、反序列化、ObjectOutputStream类、ObjectInputStream类
sc179的博客
11-02 273
目录1 概述2 ObjectOutputStream类2.1 构造方法2.2 序列化条件2.3 写出对象方法3 ObjectInputStream类3.1 构造方法3.2 读入对象方法3.3 反序列化异常及处理4 练习：序列化集合4.1 案例分析4.2 案例实现 1 概述 Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。 反之，该字节序列还可以从文件中读取回来，
java 序列化流、打印流
myjess’s blog
02-13 419
文章目录第一章 序列化1.1 概述1.2 ObjectOutputStream类1.3 ObjectInputStream类1.4 练习：序列化集合第二章 打印流2.1 概述2.2 PrintStream类 第一章 序列化 1.1 概述 Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据 、对象的类型和对象中存储的属性 等信息。字节序列写出到文件之后，...
java 如何序列化打印对象_对象序列化控制输入输出
weixin_39825872的博客
02-24 663
前面学习了如何控制基本数据的输入输出，本节主要讲解如何输入输出对象数据。对象数据是很复杂的，我们可以利用对象序列化来实现。对象序列化是什么对象序列化(Serialize)指将一个 Java 对象写入 IO 流中，与此对应的是，对象的反序列化(Deserialize)则指从 IO 流中恢复该 Java 对象。如果想让某个 Java 对象能够序列化，则必须让它的类实现 java.io.Serializ...
java的序列化流和打印流
weixin_30823001的博客
07-25 67
对象操作流(序列化流) 每次读取和写出的都是JavaBean对象. 序列化:将对象写入到文件中的过程 反序列化:从文件中读取对象到程序的过程 transient: 标识瞬态,序列化的时候,该修饰符修饰的成员不能序列化 ObjectOutputStream 构造方法: public ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStre...
IO流与序列化
05-09
在Java编程语言中，`IO流`（Input/Output Stream）和`序列化`是两个重要的概念，它们在处理数据传输、持久化存储以及对象状态的保存等方面发挥着关键作用。 **IO流**： IO流是Java提供的用于处理输入输出操作的机制...
Java工程师必备面试题【多线程、反射、类加载器、JVM、泛型、异常处理、注解、面向对象编程、集合、IO流、序列化】
07-20
内容概要：以上列出的Java面试题涵盖了Java语言的基础知识、面向对象编程、集合、IO流、多线程、反射、类加载器、JVM、序列化、泛型、异常处理、注解等多个方面。 适用人群：以上Java面试题适用于准备Java开发...
Java中对象序列化与反序列化详解
09-03
3. **进程间通信**：在多线程或者多进程环境中，序列化可以用来在进程间传递对象。 为了实现序列化，对象所属的类需要实现`Serializable`接口。如果一个类实现了`Serializable`接口，那么它的实例就可以被序列化。`...
Java基础下资料集合IO流多线程
11-14
此外，还有缓冲流（BufferedInputStream、BufferedReader等）、转换流（InputStreamReader、OutputStreamWriter）和对象流（ObjectInputStream、ObjectOutputStream），分别用于提高性能、字符编码转换和序列化。...
java 如何序列化打印对象_java中对象的序列化和反序列化
weixin_31209173的博客
02-24 371
【对象的序列化和反序列化 】1.定义：序列化--将对象写到一个输出流中。反序列化则是从一个输入流中读取一个对象。类中的成员必须是可序列化的，而且要实现Serializable接口，这样的类的对象才能被序列化和反序列化。这个接口是一个表示型的接口。serialVersionUID是一个串行化类的通用标示符，反串行化就是使用这个标示符确保一个加载的类对应一个可串行化的对象。自己指定了serialVer...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 3620
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 3649
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 3967
linux上datax 安装以及使用
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 2086
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
操作系统原子操作
zzt_is_me的博客
08-28 2188
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 1791
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 1286
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 2041
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
Java IO操作详解：文件处理、流与序列化
- 打印流（如PrintStream、PrintWriter）用于输出文本到控制台或文件。 - 文件操作流（如FileInputStream、FileOutputStream）用于文件的读写操作。 - 内存操作流（如ByteArrayInputStream、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值