Java学习日志（九）——IO流

最新推荐文章于 2022-12-14 08:46:24 发布
最新推荐文章于 2022-12-14 08:46:24 发布
阅读量232 收藏
点赞数
分类专栏： JAVA 文章标签： java 字符串 shell 大数据 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FFFPAG/article/details/108618516
版权

文章目录

异常

异常的分类：

  • 异常（Exception）：合理的应用程序可能需要捕获的问题 （可预料）
  • 错误（Error）：合理的应用程序不应该试图捕获的问题 （不可预料）

异常的处理方式：

  • try……catch（finally）：捕获，自己处理
try{
	//尝试执行的代码
}catch(Exception e){
	//出现可能的异常之后的处理代码
}finally{
	//一定会执行的代码，如关闭资源
}
  • throw：抛出，交给调用者处理，执行程序后，程序不再执行
public void 方法名() throws Exception{

}
//处理方法1：接着抛出
//处理方法2：try……catch{}

IO流概述

  • 按数据流分类：输入流，输出流
  • 按操作方式分类：
    字节流：
    InputStream(FileInputStream , BufferedInputStream) ,
    OutputStream(FileOutputStream , BufferedOutputStream)
    字符流：
    Reader(FileReader , BufferReader)
    Writer(FileWriter , BufferWriter)

File类

构造方法：

  • File(String pathname)
  • File(String parent,String child)
  • File(File parent,String child)

成员方法：

  • createNewFile():创建文件
  • mkdir()和mkdirs():创建目录
  • isDirectory():判断File对象是否为目录
  • isFile():判断File对象是否为文件
  • exists():判断File对象是否存在
  • getAbsolutePath():获取绝对路径（C:/1.txt）
  • getPath():获取文件的相对路径（1.txt）
  • getName():获取文件名
  • list():获取指定目录下的所有文件（夹）名称数组
  • listFiles():获取指定目录所有文件（夹）File数组

Test类：（创建和判断功能）

package File类;

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

public class Test {
    public static void main(String[] args) throws IOException {
        //需求：将C:\PAG\1.txt封装成File对象
        //方式一：根据字符串形式的路径获取File对象
        //File file1 = new File("C:\\PAG\\1.txt");
        File file1 = new File("C:/PAG/1.txt");
        System.out.println("file1:" + file1);

        //方式二：根据字符串形式的父目录以及子目录创建File对象
        File file2 = new File("C:/PAG/","1.txt");
        System.out.println("file2:" + file2);

        //方式三：根据父目录对象，以及字符串形式的子目录来获取File对象
        File file3 = new File("C:/PAG/");
        File file4 = new File(file3,"1.txt");
        System.out.println("file4:" + file4);
        System.out.println("----------------------------");

        System.out.println("测试建立功能");
        //需求：在C盘PAG文件中创建一个2.txt文件
        File file5 = new File("C:/PAG/2.txt");
        boolean flag1 = file5.createNewFile();
        System.out.println("flag1:" + flag1);

        //需求：在C盘下创建a文件夹
        File file6 = new File("C:/a");
        boolean flag2 = file6.mkdir();              //make directory,创建单级目录
        System.out.println("flag2:" + flag2);

        //需求：在C盘下创建a/b/c文件夹
        File file7 = new File("C:/a/b/c");
        boolean flag3 = file7.mkdirs();             //创建多级目录，也可创建单级目录
        System.out.println("flag3:" + flag3);
        System.out.println("----------------------------");


        System.out.println("测试判断功能");
        File file8 = new File("C:/PAG/1.txt");
      /*  boolean flag4 = file8.isDirectory();
        System.out.println("测试File8是否是文件夹：" + flag4);*/
        System.out.println("测试file8是否是文件夹：" + file8.isDirectory());
        System.out.println("测试file8是否是文件：" + file8.isFile());
        System.out.println("测试file8是否存在：" + file8.exists());
    }
}

运行结果：

file1:C:\PAG\1.txt
file2:C:\PAG\1.txt
file4:C:\PAG\1.txt
----------------------------
测试建立功能
flag1:true
flag2:true
flag3:true
----------------------------
测试判断功能
测试file8是否是文件夹：false
测试file8是否是文件：true
测试file8是否存在：true

Process finished with exit code 0

Test（获取功能）：

package File类;

import java.io.File;

public class Test2 {
    public static void main(String[] args) {
        File file1 = new File("lib/1.txt");

        //获取文件的绝对路径
        String path1 = file1.getAbsolutePath();
        System.out.println("绝对路径：" + path1);

        //获取文件的相对路径
        String path2 = file1.getPath();
        System.out.println("相对路径：" + path2);

        //获取文件名
        String file1Name = file1.getName();
        System.out.println("文件名：" + file1Name);

        System.out.println("---------------------------");
        //获取lib文件下的所有文件（夹）的：名称数组String[]
        File file2 = new File("lib");
        String[] names = file2.list();
        for (String name :names){
            System.out.println(name);
        }

        System.out.println("---------------------------");
        //获取lib文件下的所有文件（夹）的：File对象数组File[]
        File[] files = file2.listFiles();
        for (File file : files){
            System.out.println(file);
        }
    }
}

运行结果：

绝对路径：C:\Users\PAG\Desktop\Java\lib\1.txt
相对路径：lib\1.txt
文件名：1.txt
---------------------------
1.txt
a
---------------------------
lib\1.txt
lib\a

字符流读写文件

读文件

  • 创建字符流读文件对象：Reader reader = new FileReader（"readma.txt"）;

  • 调用方法读取数据：int data = reader.read(); 读取一个字符，返回该字符代表的整数，若到达流的末尾，返回-1

  • 调用方法读取数据：char [] chs = new char[2048];int len = r.read(chs);读取字符到数组中，返回读取的字符数，若达到流的末尾，返回-1

  • 异常处理：throw IOException

  • 关闭资源：reader.close();

Test1:（每次读取一个字符）

package 字符流;


import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

//1.txt内为abc
public class Test {
    public static void main(String[] args) throws IOException {
        //需求：通过字符流读取数据
        //1.创建字符流输入流对象
        Reader reader = new FileReader("lib/1.txt");
        //2.读取数据
/*        int ch1 = reader.read();
        System.out.println(ch1);            //97*/
        int ch;
        /*
            (ch =reader.read()) != -1
            1.执行reader.read(),去文件中读取一个字符
            2.执行ch = reader.read(),将读取到的字符赋值给变量
            3.(ch =reader.read()) != -1，用读取到的字符（内容）和-1进行比较
        */
        while ((ch =reader.read()) != -1){
            //ch = reader.read();
            System.out.println(ch);   //结果为97,98,99
        }
        //3.释放资源
        reader.close();
    }
}

Test2:（每次读取一个字符数组）

package 字符流;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

//1.txt内为abcdefg
public class Test1 {
    public static void main(String[] args) throws IOException {
        //需求：通过字符流读取数据，一次读取一个字符数组
        //1.创建字符输入流对象
        Reader reader = new FileReader("lib/1.txt");
        //2.读取数据
 /*       char[] chs = new  char[3];
        int len1 = reader.read(chs);
        System.out.println(chs);        //a,b,c
        System.out.println(len1);       //3

        int len2 = reader.read(chs);
        System.out.println(chs);        //d,e,f
        System.out.println(len2);       //3

        int len3 = reader.read(chs);
        System.out.println(chs);        //g,e,f
        System.out.println(len3);       //1

        int len4 = reader.read(chs);
        System.out.println(chs);        //g,e,f
        System.out.println(len4);       //-1*/
        //定义字符数组
        char[] chs = new char[3];
        //定义一个变量，记录读取到的有效字符数
        int len;
        while ((len = reader.read(chs)) != -1){
            //将读取到的内容，转换成字符串，然后打印
            /*
                chs:表示要操作的数组
                0:表示起始索引
                len:表示要操作的字符的个数
            */
            String s = new String(chs,0,len);
            System.out.println(s);      //运行结果：abc def g
        }
        //3.释放资源
        reader.close();
    }
}

写文件

  • 创建字符流写文件对象：Writer writer = new FileWriter（"dest.txt"）;

  • 调用方法写入数据：int x = '中'；writer.write(x);写一个字符

  • 调用方法写入数据：char[] chs = {'1','2','3','4'’}; writer,write(chs);写一个字符数组

  • 调用方法写入数据：writer.write("PAG针不戳！");写一个字符串

  • 异常处理：throw IOException

  • 关闭资源：writer.close();

Test：

package 字符流;

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

public class Test2 {
    public static void main(String[] args) throws IOException {
        //需求：通过字符流，写数据
        //1.创建字符输出流对象
        Writer writer = new FileWriter("lib/1.txt");
        //2.写数据
        //一次写一个字符
        //writer.write("好");
        
        //一次写一个指定的字符数组
        /*char[] chs = {'P','A','G','针','不','戳'};
        writer.write(chs,2,3);*/
        
        //一个写一个字符串
        writer.write("PAG针不戳");
        //3.释放资源
        writer.close();
    }
}

拷贝文件

  • 创建字符流读文件对象：Reader reader = new FileReader（"readma.txt"）;

  • 创建字符流写文件对象：Writer writer = new FileWriter（"dest.txt"）;

  • 调用方法读取数据1：int data = reader.read();

  • 调用方法写入数据1：writer.write(data);

  • 调用方法读取数据2：char[] chs = new char[2048];int len = reader.read(chs);

  • 调用方法写入数据2：writer.write(chs,0,len);

  • 异常处理：throw IOException

  • 关闭资源：reader.close(); writer.close();

Test1（一个字符）：

package 字符流;

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

public class Test1 {
    public static void main(String[] args) throws IOException {
        //需求：通过字符流拷贝文件，一次读写一个字符
        /*
            IO流拷贝文件核心步：
                1.创建字符输入流文件，关联数据源文件
                2.创建字符输出流文件，关联目的地文件
                3.定义变量，记录读取到的内容
                4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
                5.将读取到的数据写入到目的地文件中
                6.释放资源
        */
        //Reader reader = new FileReader("lib/1.txt");
        FileReader fr = new FileReader("lib/1.txt");
        // Writer writer = new FileWriter("lib/2.txt");
        FileWriter fw = new FileWriter("lib/2.txt");
        int len;
        while ((len = fr.read()) != -1){
            fw.write(len);
        }
        fr.close();
        fw.close();
    }
}

Test2（一个字符数组）：

package 字符流;

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

public class Test2 {
    public static void main(String[] args) throws IOException {
        //需求：通过字符流拷贝文件，一次读写一个字符数组
        /*
            IO流拷贝文件核心步：
                1.创建字符输入流文件，关联数据源文件
                2.创建字符输出流文件，关联目的地文件
                3.定义变量，记录读取到的内容
                4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
                5.将读取到的数据写入到目的地文件中
                6.释放资源
        */
        //Reader reader = new FileReader("lib/1.txt");
        FileReader fr = new FileReader("lib/1.txt");
        // Writer writer = new FileWriter("lib/2.txt");
        FileWriter fw = new FileWriter("lib/2.txt");
        //定义一个字符数组
        char[] chs = new char[1024];
        //用来记录读取到的有效字符数
        int len;
        while ((len = fr.read(chs)) != -1){
            fw.write(chs,0,len);
        }
        fr.close();
        fw.close();
    }
}

字符缓冲流拷贝文件

  • 创建字符流读文件对象：BufferedReader br = new BufferedReader （new FileReader（"readma.txt"））;

  • 创建字符流写文件对象：BufferedWriter bw = new BufferedWriter（new FileWriter（"dest.txt"））;

  • 使用while循环读写数据：int len; while((len = br.read())!=-1){bw.write(len);}

  • 异常处理：throw IOException

  • 关闭资源：br.close(); bw.close();

Test1:

package 字符流;


import java.io.*;

//字符缓冲流自带有缓冲区，大小为8192个字节，也就是16KB
public class Test1 {
    public static void main(String[] args) throws IOException {
        //需求：通过字符缓冲流，将1.txt文件中的内容拷贝到2.txt文件夹中
        //1.创建字符缓冲流输入流对象，关联数据源文件
        BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
        //2.建立字符缓冲输出流对象，关联目的地文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));
        //3.定义变量，记录读取到的数据
        int len;
        //4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
       while ((len = br.read()) != -1){
           //5.将读取到的数据写入到目的地文件中
           bw.write(len);
       }

        //6.释放资源
        br.close();
        bw.close();
    }
}

Test2(一次读一行)：

package 字符流;


import java.io.*;

//字符缓冲流自带有缓冲区，大小为8192个字节，也就是16KB
//字符流只能拷贝纯文本文件
public class Test2 {
    public static void main(String[] args) throws IOException {
        //需求：通过字符缓冲流，将1.txt文件中的内容拷贝到2.txt文件夹中
        //1.创建字符缓冲流输入流对象，关联数据源文件
        BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
        //2.建立字符缓冲输出流对象，关联目的地文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));
        //3.定义变量，记录读取到的数据
        String str;
        //4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
       while ((str = br.readLine()) != null){
           //5.将读取到的数据写入到目的地文件中
           bw.write(str);
           //注意换行 window：\r\n   mac:\r    unix:\n
           bw.newLine();
       }

        //6.释放资源
        br.close();
        bw.close();
    }
}

字节流

读写文件

  • 创建字节流读文件对象：InputStream is = new FileInputStream("Desktop.jpg");
  • 创建字节流写文件对象：OutputStream os = new FileOutputStream("C:/桌面.jpg");
  • 使用while循环读写数据：int b；while（（b=is.read（）！=-1））{os.write(b);}
  • 异常处理：throws IOException
  • 关闭资源：is.close(); os.close();

Test1:

package 字节流;

import java.io.*;

public class Test1 {
    public static void main(String[] args) throws IOException {
        //需求：通过普通的字节流，一次读写一个字节的方式，将a.jpg复制到b.jpg中
        //1.创建字节流读文件对象
        FileInputStream fis = new FileInputStream("lib/a.jpg");
        //2.创建字节流写文件对象
        FileOutputStream fos = new FileOutputStream("lib/b.jpg");
        //3.定义变量，用来记录读取到的内容
        int len;
        //4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
        while ((len = fis.read()) != -1){
            //5.将读取到的内容写入到目的地文件中
            fos.write(len);
        }

        //6.释放资源
        fis.close();
        fos.close();
    }
}

拷贝文件

  • 创建字节流读文件对象：InputStream is = new FileInputStream("Desktop.jpg");
  • 创建字节流写文件对象：OutputStream os = new FileOutputStream("C:/桌面.jpg");
  • 定义字节数组，每次读取2048个字节：byte[] b = new byte[2048];
  • 使用while循环读写数据：int b；while（（b=is.read（）！=-1））{os.write(0,b,len);}
  • 异常处理：throws IOException
  • 关闭资源：is.close(); os.close();

Test1:

package 字节流;

import java.io.*;

public class Test1 {
    public static void main(String[] args) throws IOException {
        //需求：通过普通的字节流，一次读写一个字节数组的方式，将a.jpg复制到b.jpg中
        //1.创建字节流读文件对象
        FileInputStream fis = new FileInputStream("lib/a.jpg");
        //2.创建字节流写文件对象
        FileOutputStream fos = new FileOutputStream("lib/b.jpg");
        //3.定义变量，用来接收读取到的内容
        byte[] bys = new byte[1024];
        //用来记录读取到的有效字节数
        int len;
        //4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
        while ((len = fis.read(bys)) != -1){
            //5.将读取到的内容写入到目的地文件中
            fos.write(bys,0,len);
        }

        //6.释放资源
        fis.close();
        fos.close();
    }
}

缓冲流拷贝文件

  • 创建字节流读文件对象：BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Desktop.jpg")) ;

  • 创建字节流写文件对象：BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream("C:/桌面.jpg")) ;

  • 使用while循环读写数据：int len；while（（len=bis.read（）！=-1））{bos.write(len);}

  • 异常处理：throws IOException

  • 关闭资源：bis.close(); bos.close();

Test1:

package 字节流;

import java.io.*;

//拷贝纯文本文件使用字符流，拷贝其他（图片，音频，视频等）使用字节流
public class Test2 {
    public static void main(String[] args) throws IOException {
        //需求：通过字节缓冲流，将a.jpg复制到b.jpg中
        //1.创建字节输入流对象，关联数据源文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("lib/a.jpg"));
        //2.创建字节输出流对象，关联目的地文件
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("lib/b.jpg"));
        //3.定义变量，用来记录读取到的内容
        int len;
        //4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
        while ((len = bis.read()) != -1){
            //5.将读取到的内容写入到目的地文件中
            bos.write(len);
        }

        //6.释放资源
        bis.close();
        bos.close();
    }
}
FFFPAG
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
字符流-File类读写
宁静致远
12-18 391
字符流-File类读写 一、字符流的读写 1、写入字符流步骤（FileWriter为例）         a、创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步
java的reader_Java 之 字符输入流[Reader]
weixin_32944341的博客
02-12 897
一、字符输入流java.io.Reader 抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。public int read() ： 从输入流读取一个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)(2个字节的Unicode码)，如果已到达流的末尾，则返回 -1public int read(char[]...
使用字符流读写数据
weixin_30381793的博客
03-26 146
-------------siwuxie095 工程名：TestRWCharStream 包名：com.siwuxie095.charstream 类名：RWByCharStream.java 打开资源管理器，在工程 TestRWCharStream 文件夹下，放入 一个文本：java.txt java.txt 的...
字符流的拷贝
LeoZuosj的博客
01-19 154
字符流的拷贝 FileReader fr = new FileReader("a.txt"); FileWriter fw = new FileWriter("b.txt"); int ch; while((ch = fr.read()) != -1) { fw.write(ch); } fr.close(); fw.close(); package com.heima.chario; ...
Java的IO 各种类的详细讲解续（三）
会写Bug的攻城狮
01-03 230
一，字符输入流   Reader 类是所有字符流输入类的父类，该类定义了许多方法，这些方法对所有子类都是有效的。 Reader 类的常用子类如下。 CharArrayReader 类：将字符数组转换为字符输入流，从中读取字符。 StringReader 类：将字符串转换为字符输入流，从中读取字符。 BufferedReader 类：为其他字符输入流提供读缓冲区。 PipedReade...
黑马程序员java学习笔记——IO流
魏天翔的博客
06-08 509
IO流     概述     流的特点     IO流用于处理设备之间的数据传输；     java对数据的操作是通过流的方式；     java用于操作留的对象都放在IO包中；     流按操作数据分为两种：字节流和字符流；     按流向分为：输入流和输出流；     字符流对相融合了编码表。     流常用基类     字节流的抽象基类：输入流InputS
【Java实战项目】——图书管理系统（基于文件IO流）
生活很苦，但学习还得继续
09-28 2825
目录结构梳理【项目前提】【项目内容】【项目注意】【结构设计】 结构梳理 【项目前提】 掌握java基本语法 熟悉使用流程控制 理解面向对象思想 熟练封装，继承，多态 熟悉使用接口，异常 熟悉使用集合 熟悉掌握I/o流相关操作   【项目内容】 项目功能结构图： 项目功能如下： （1）读者信息管理：包括读者信息添加和读者信息查询与修改功能。用户登录成功之后，可以浏览所有读者的信息，也可以检索特定读者的信息；同时，可以对读者信息进行维护，包括增加、删除及修改。具体信息包括读者类型（读者的类型决定着他可以借
基于文件IO流的完整项目——图书管理系统
09-15
总的来说，这个基于文件IO流的图书管理系统项目涵盖了文件操作、数据持久化、用户管理、并发控制等多个Java编程的核心知识点，是学习和提升这些技能的良好实践平台。在实际开发中，随着需求的复杂度增加，可能还需要...
我的java学习日志day01
01-03
【Java学习日志Day01】——初识Java与编程环境搭建 在开始我们的Java学习之旅之前，首先要明确Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle收购）于1995年发布。Java的设计理念是...
日志分析工具 java_基于Java的日志分析工具——LogAnalyzerFramework，小轮子一个
weixin_39661345的博客
02-21 540
分析日志并不是Java擅长的工作，多数时候我们经常会把这项工作交给shell\Perl\Python之类的脚本去处理。但是很多时候因为所处的“大环境”是Java,在分析日志的时候需要去调用一些Java的接口，那么日志分析工具就得用Java来写了。分析日志是个很繁琐的工作，需要每次都去打开文件、一行行处理然后关闭文件，如果是动态日志分析还需要去维护文件指针。于是这种工作做多了烦了之后就把这些繁琐的通...
字符流的读写
最新发布
f_95271的博客
12-14 72
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。void write(String str, int off, int len) 写一个字符串的一部分。可以指定缓冲区大小，或者可以使用默认大小。void write(charl[] cbuf) 写入一个字符数组。int read(char[]cbuf) 一次读一个字符数组数据。缓冲字符,以提供字符,数组和行的高效读取。将文本写入字符输出流，缓冲字符、数组和字符串的高效写入。
字符流方式读写
别抢我蓝buff
03-19 84
https://blog.csdn.net/weixin_40182062/article/details/89254007?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
字符流拷贝文件
sugar_sugar_sugar的博客
12-19 400
package 字符流; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class copy3 { /** * @param args * 使用字符流进
字符流拷贝（转载）
look_at_star的博客
07-24 256
什么情况下使用字符流？ 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符, 写出时还要把字符转回字节.程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流读取的时候是按照字符的大小读取的,不会出现半个中文 写出的时候可以直接将字符串写出,不用转换为字节数组 图解为什么字节流Copy速度要比字符流快 字符流是否可以拷贝非纯文本的文件？ 不
字符流的读取和写入
bandenger的博客
04-22 1515
整理字节流读取和写入、复制public class LearnStream {public void readWrite(){ InputStream in=null; try{ //建立文件读取字节流 in=new FileInputStream("E:/ATM.txt"); int data=0; //将流中的数据读取到字节数组中，返回当前读取的字节数，读取完毕，返回-1    by...
字符流读写数据
jtjeeeee的博客
04-24 880
一，字符流写数据的5种方式 方法 描述 void write(int c) 写一个字符 void write(charl[] cbuf) 写入一个字符数组 void write(char[] cbuf, int off, int len) 写入字符数组的一部分 void write(String str) 写一个字符串 void write(String str, int off, int len) 写一个字符串的一部分 二， 字
Java面向对象编程：构建高可用日志采集系统
此外，还涉及到了高级主题，如容器类、IO流、多线程编程、Socket编程、JDBC以及使用Mina框架进行网络编程。书中通过一个在线游戏项目展示了实际开发流程，将理论知识与实践相结合，帮助读者更好地理解和运用Java语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FFFPAG

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值