JavasSEDemo31IO流

最新推荐文章于 2024-05-14 09:06:19 发布
最新推荐文章于 2024-05-14 09:06:19 发布
阅读量451 收藏 1
点赞数 2
分类专栏： JavaSE个人学习笔记 文章标签： java IO流 递归算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hypertext123/article/details/116240843
版权

文章目录

简介

  • 本文是2021/04/29整理的笔记
  • 赘述可能有点多，还请各位朋友耐心阅读
  • 本人的内容和答案不一定是最好最正确的，欢迎各位朋友评论区指正改进

易错练习题

练习1

byte b = 127;
System.out.println(-b);

选择程序运行结果
A、-127
B、0
C、-128
D、运行错误
答案
A

练习2

对于switch/case语句以下说法正确的有。
A、default语句是可选的，但是如果出现default则必须位于所有的case后面
B、case子句后面的值必须是常量，且不可重复
C、switch后面的表达式的值如果是数值型，则必须是可精确匹配的整数值，如int\long，而不能是浮点数
D、case后面的break是必选的，不能省略break

练习3

以下哪个是有关封装优点的正确描述？
A、 可以不用定义成员变量
B、 可以直接通过类名修改属性
C、 可以不需要改变接口来改变实现，以达到外部使用代码无需变动
D、 可以不需要改变实现来改变接口，已达到外部使用代码无需变动

练习4

当一个类的所有构造器均为私有的，以下哪个描述是正确的？
A、 不能被其他类实例化
B、 不能被其他类继承
C、 既不能被其他类实例化，也不能被其他类继承
D、 该类必须被final修饰

练习5

交易明细文件内容如下例：log.txt
#姓名 性别 帐号 发生额
刘德华|1|4155990188888888|300.00
晓龙|1|1155990199999999|500.00
黄晓明|1|4155990100000000|1000.50
张东健|1|4155990155555555|600.99
梁朝伟|0|4155990111111111|5000.00
刘德华|1|4155990188888888|200.00
张东健|1|4155990155555555|500.99
刘德华|1|4155880188888888|1200.00
PS:1)一行是一条交易明细，每行分4列，列间用|分隔。#为注释符号。
2)类TransRecord存储一条明细。
实现功能:
一个人可能消费有多笔。（当姓名和账号相同的话就认为是同一人)统计每个人的消费总额。按消费额的金额升序排序。要求显示每个人的姓名、性别、帐号、消费总额的信息

public  class TransRecord implements Comparable<TransRecord>{
    private String name;
    private int sex;
    private String number;
    private double money;

    @Override
    public String toString() {
        return "Exchange{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", number='" + number + '\'' +
                ", price=" + money +
                '}';
    }

    public TransRecord() {
    }

    public TransRecord(String name, int sex, String number, double price) {
        this.name = name;
        this.sex = sex;
        this.number = number;
        this.money = price;
    }

    public String getName() {
        return name;
    }

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

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }




    @Override
    public int compareTo(TransRecord o) {
        double d = this.getMoney() - o.getMoney();
       if(d >0){
           return 1;
       }else{
           return -1;
       }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.TreeSet;
public class Demo03homework {
    public static void main(String[] args) throws IOException {
        //创建TreeSet集合,存储类型为TransRecord
        TreeSet<TransRecord> treeSet = new TreeSet<>();
        TreeSet<TransRecord> treeSet1 = new TreeSet<>();
        //创建基本字符输入流
        FileReader fileReader = new FileReader("D:\\AJavaStudyTest\\homework\\log.txt");
        //创建缓冲字符输入流
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String line;
        while((line = bufferedReader.readLine())!=null){
            if(line.contains("|")){
                String[] split = line.split("\\|");
                TransRecord transRecord = new TransRecord(split[0], Integer.parseInt(split[1]), split[2], Double.parseDouble(split[3]));
                boolean flag =false;
                for (TransRecord record : treeSet) {
                    if(record.getName().equals(transRecord.getName()) && record.getNumber().equals(transRecord.getNumber()) && record.getSex()==(transRecord.getSex())){
                        flag =true;
                        record.setMoney(record.getMoney() + transRecord.getMoney());
                    }
                }
                if(!flag){
                    treeSet.add(transRecord);
                }
            }
        }
        bufferedReader.close();
        fileReader.close();
        for (TransRecord transRecord : treeSet) {
            treeSet1.add(transRecord);
        }
        for (TransRecord transRecord : treeSet1) {
            System.out.println("transRecord = " + transRecord);
        }
    }
}

练习6

题目:
将一个文件夹中的内容复制到其它目录中。（比如:把D:\chenhao中的内容复制一份到 e:\zhangsan文件夹中）
(递归和通过字节流来进行复制FileInputStream和FileOutputStream)

import org.junit.Test;
import java.io.*;

/**
 * 将一个文件夹中的内容复制到其它目录中。（比如:把D:\\chenhao中的内容复制一份到 e:\\zhangsan文件夹中）
 * (递归和通过字节流来进行复制FileInputStream和FileOutputStream)
 */
public class Demo03 {
    @Test
    public void test() throws IOException {
        diGui(new File("D:\\A国创"),new File("D:\\B国创"));
    }
    private void diGui(File source,File dest) throws IOException {
        //source存在
        if(source.exists()){
            if(source.isDirectory()){
                //在目标文件夹创建这个文件夹
                File dir = new File(dest + "/" + source.getName());
                //创建子文件夹
                dir.mkdirs();
                //遍历原文件夹的每一项
                File[] files = source.listFiles();
                if (files!=null && files.length >0) {
                    for (File file : files) {
                        //file.exists()
                            diGui(file, dir);
                }
            }
        }else {
                copy(source, dest);
                return;
            }
            }
    }

    public  void copy(File source, File dest) throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(source));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(dest + "/" + source.getName()));
        byte[] bytes = new byte[1024];
        int length;
        while((length = bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,length);
        }
        bufferedOutputStream.close();
        bufferedInputStream.close();
    }


}

注意:Win10系统在复制文件夹之前，需要将文件夹权限改为完全访问。

练习7

题目
获取一个文件夹下所有指定后缀名(.java)的文件（包括子文件夹中的内容），并将这些文件的绝对路径写入到一个文本文件中

import org.junit.Test;

import java.io.*;

public class Demo08 {
    private PrintWriter printWriter= new PrintWriter(new FileWriter("result.txt"));

    public Demo08() throws IOException {
    }

    @Test
    public void test(){
        diGui(new File("D:\\王力宏"));
        printWriter.close();
    }

    private void diGui(File file){
        if(file.isDirectory()){
            File[] files = file.listFiles();
            for (File file1 : files) {
                if(file1.isFile()){
                    save(file1);
                }else {
                    diGui(file1);
                }
            }
        }else {
            save(file);
        }
    }

    private void save(File file){
        if(file.getName().endsWith(".java")){
            //向文件写
            printWriter.println(file.getAbsolutePath());
        }
    }
}

练习8

题目
题目：实现一个方法日志记录器，将每次方法的调用信息存放在单一的文本日志文件中，并能够分析日志文件中包含的数据：调用次数最多的方法，调用总耗时最长的方法
考点：输入输出流
难度：中
思路:

  1. 日志文件
  2. 写内容:类#方法名#开始时间#结束时间#本次耗时
  3. 什么时候写日志:方法里开头写:类#方法名#开始时间 方法结尾写:#结束时间#本次耗时
  4. 分析日志文件:读取日志文件逐行解析
    (1)调用次数最多的方法:map: key:类+方法名组合 value:调用次数
    (2)调用总耗时最长的方法:map key:类+方法名组合 value:耗时
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class Logger {
    private PrintWriter printWriter;
    {
        try {
            printWriter = new PrintWriter("log.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    public void log(String string){
        printWriter.print(string);
        printWriter.flush();
    }
    public void logLn(String string){
        printWriter.println(string);
        printWriter.flush();
    }
}


import java.text.SimpleDateFormat;
import java.util.Date;

public class MyClass {
    private Logger logger = new Logger();
    public void eat(){
        logger.log(this.getClass().getName() + "#eat()#" +getTime()+"#");
        long start  = System.currentTimeMillis();
        System.out.println("MyClass.eat([])方法");
        try {
            Thread.sleep(1200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        //方法结尾写:#结束时间#本次耗时
        logger.logLn(getTime()+"#"+(end-start));
    }
    public String getTime(){
        return  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date());
    }
    public void study(){
        logger.log(this.getClass().getName() + "#study()#" +getTime()+"#");
        long start  = System.currentTimeMillis();
        System.out.println("MyClass.study([])方法");
        try {
            Thread.sleep(2200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        //方法结尾写:#结束时间#本次耗时
        logger.logLn(getTime()+"#"+(end-start));
    }

    public void drink(){
        logger.log(this.getClass().getName() + "#drink()#" +getTime()+"#");
        long start  = System.currentTimeMillis();
        System.out.println("MyClass.drink([])方法");
        try {
            Thread.sleep(5200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        //方法结尾写:#结束时间#本次耗时
        logger.logLn(getTime()+"#"+(end-start));
    }
    public void play(){
        logger.log(this.getClass().getName() + "#play()#" +getTime()+"#");
        long start  = System.currentTimeMillis();
        System.out.println("MyClass.play([])方法");
        try {
            Thread.sleep(1200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        //方法结尾写:#结束时间#本次耗时
        logger.logLn(getTime()+"#"+(end-start));
    }
}


public class TestMyClass {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.eat();
        myClass.eat();
        myClass.eat();
        myClass.drink();
        myClass.drink();
        myClass.study();
        myClass.study();
        myClass.play();
    }
}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class TestLogAnalysis {
    public static void main(String[] args) throws IOException {
        //分析日志文件:读取日志文件逐行解析
        BufferedReader bufferedReader = new BufferedReader(new FileReader("log.txt"));
        String line;
        Map<String, Integer> map1 = new HashMap<>();
        Map<String, Integer> map2 = new HashMap<>();
        while((line = bufferedReader.readLine())!=null){
            String[] split = line.split("#");
            String key = split[0] + "-" + split[1];
                //解决数量问题
                Integer count = map1.get(key);
                if(count != null){
                    map1.put(key,count+1);
                    //原来没有,就放1
                }else {
                    map1.put(key,1);
                }

                //耗时
                Integer time = map2.get(key);
                if(time !=null){
                    map2.put(key,time + Integer.parseInt(split[4]));
                }else {
                    map2.put(key,Integer.parseInt(split[4]));
                }

        }

       //调用次数最多的方法
        int maxCount = 0;
        String maxKey = null;
        for (Map.Entry<String, Integer> entry : map1.entrySet()) {
            if(entry.getValue() > maxCount){
                maxCount = entry.getValue();
                maxKey = entry.getKey();
            }
        }
        System.out.println("调用方法最多的是"+maxKey + ",调用方法次数是:"+maxCount);


        //调用时间最长的方法
        int maxTime = 0;
        for (Map.Entry<String, Integer> entry : map2.entrySet()) {
            if(entry.getValue() > maxCount){
                maxTime = entry.getValue();
                maxKey = entry.getKey();
            }
        }
        System.out.println("调用方法最多的是"+maxKey + ",调用方法次数是:"+maxTime);


        bufferedReader.close();
    }
}

序列化与反序列化

什么是序列化

  • 将对象的状态信息保存到流中的操作，称为序列化。

什么是反序列化

  • 将流中读取对象状态信息的操作称为反序列化。

怎么实现序列化

  1. 让实体类实现Serializable 接口 生成serialVersionUID
  2. 创建ObjectOutputStream(new FileOutputStream(文件名称))
  3. 调用writeObject(new 对象)

怎么实现反序列化

  1. new ObjectInputStream(new FileInputStream(文件名称))
  2. 调用readObject()返回Object，向下转型，将其强转为对应的对象。
  3. 打印输出

自定义序列化1

  1. 在实现了Serializable接口的类中写两个方法
  2. private void writeObject(ObjectOutputStream out){
    out.defaultWriteObject();
    out.writeUTF(address+“小贝贝”);
    }
  3. private void readObject(ObjectInputStream in){
    in.defaultReadObject();
    address = in.readUTF();
    }

自定义序列化2

  1. 在实现了Serializable接口的类中写两个方法
  2. private void writeObject(ObjectOutputStream out){
    out.writeUTF(name+“小贝贝”);
    out.writeInt(age);
    out.writeUTF(addres+“小贝贝”)
    }
  3. private void readObject(ObjectInputStream in){
    name = in.readUTF();
    age = in.readInt();
    address = in.readUTF();
    }

自定义序列化3

  1. 让类实现Externalizable接口。重写2个方法
 @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(name+"小贝贝");
        out.writeInt(age);
        out.writeUTF("天安门"+address);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = in.readUTF();
        age = in.readInt();
        address = in.readUTF();
    }

在字段前加transient关键字，该字段就不会被默认序列化

在字段前加static关键字，该字段页不会被默认序列化

serialVersionUID推荐加上，如果不加：会根据类名 属性名 方法名 接口名 生成；如果修改了其中的任何一项，都会引起serialVersionUID的改变，反序列化会引发InvalidClassException异常

香鱼嫩虾
关注
专栏目录
浅谈跨域(四)——SSE试用
zhoujie_zhoujie的博客
02-11 2601
Comet虽然实现比较简单，但是实际使用过程中并不是那么简单，还需要考虑很多实际的问题，例如连接断开如何重连。而且Comet并不是HTML5规范的一部分，并且在服务器端和浏览器端都需要第三方库的支持。 幸运的是HTML5规范中新增了SSE（Server-Sent Event），直接使用SSE API就能实现和Comet一样的功能。Server-Sent EventSSE 用于创建到服务器的单向连接
java io 流选择题_java Io流面试题和选择题
weixin_29729247的博客
02-13 1454
Java对象的序列化指将一个java对象写入OI流中，与此对应的是，对象的反序列化则从IO流中恢复该java对象。下面就由学习啦小编为大家介绍一下java Io流面试题和选择题的文章，欢迎阅读。java Io流面试题和选择题篇11.PrintStream、BufferedWriter、PrintWriter的比较?PrintStream类的输出功能非常强大，通常如果需要输出文本内容，都应该将输出流...
Java使用Server-Sent Events (SSE) 的demo
m0_62056932的博客
12-10 786
HTTP 更适用于一次性请求和响应的情况，例如加载网页内容或提交表单数据。SSE 更适用于需要持续更新的应用，比如新闻流、聊天室或者动态图表的数据更新。然而，这两种协议并不是互斥的。实际上，在许多情况下，它们会被结合使用，以便充分利用各自的优势。例如，一个应用程序可能会用 HTTP 来加载初始页面，然后用 SSE 来提供实时更新。
JavaSE小Demo
qq_44372246的博客
03-24 222
Java SE学习小案例
SSE（Server-Sent Events）| 前后端demo参考
你个无聊小demo的博客
03-24 1935
SSE（Server-Sent Events）| 前后端demo参考 | java实现
百度文心一言 java 支持流式输出，Springboot+ sse的demo
最新发布
wangqiaowq的博客
05-14 1538
和其他的接口不一样 需要 CompletionsResponse.data 封装下 ，不然前端页面需要兼容非json的格式。3、WenxinEventSourceListener 事件监听器。2、配置apikey和secretkey。4、返回的json格式。
Java IO流（超详细！）
热门推荐
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
Java读写IO流详解
AriesLY0411的博客
11-21 3482
一、IO流要明确的几点 （1）明确要操作的数据是数据源还是数据目的（是读还是写） 源/读 InputStream Reader 目的/写 OutputStream Writer （2）明确操作设备上的数据是字节还是文本 源/读 字节：InputStream 文本：Reader 目的/写 字节：OutputStream ...
java io流读取文件_java的几种IO流读取文件方式
weixin_39701768的博客
02-16 6095
一、超类：字节流： InputStream(读入流) OutputStream(写出流)字符流： Reader(字符 读入流) Writer (字符写出流)二、文件操作流字节流： FileInputStream ，FileOutputStream字符流： FileReader, FileWriter(用法与字节流基本相同，不写)//1.指定要读 的文件目录及名称File file =...
java io流不关闭有什么后果_Java IO流
weixin_39563827的博客
11-21 2095
一、基本概念 IO是Java对数据的操作是通过流的方式，数据传输是需要通道的，而IO流就是数据传输的通道。IO流可以形象的比喻为运送货物的传输带。IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。总结一下，Java IO输入机制就是为了允许程序读取外部数据（包括来自于磁盘、光盘等存储设备的数据）和用户输入的数据。 Java的IO流通过java...
jersey-sse-demo:演示显示 Jersey 的服务器发送事件功能
07-07
演示显示 看 怎么跑 $ mvn spring-boot:run 转到
sse-eventbus-demo:sse-eventbus库的演示应用程序
05-13
一个简单的Spring Boot应用程序，演示库的用法。 该应用程序使用库在浏览器中可视化数据。 启动应用程序 git clone https://github.com/ralscha/sse-eventbus-demo.git cd sse-eventbus-demo ./mvnw package (Windows: .\mvnw.cmd package) java -jar target/sse-eventbus-demo.jar 在浏览器中打开URL http://localhost:80 执照 下发布代码。
springboot ，sse
10-19
基于springboot ，sse（serverlet-sent-event） 服务器主动定时向浏览器推送数据
sse接口测试demo（sse-test测试dome）
weixin_61434483的博客
04-25 486
【代码】sse接口测试demo（sse-test测试dome）
SSE指令优化的简单demo
gbz3300255的博客
08-01 433
网上抄的 https://blog.csdn.net/mydear_11000/article/details/50856690 自己记录一下防忘。 #include<intrin.h> intmain(intargc,char*argv[]) { floatop1[4]={1.0,2.0,3.0,4.0...
SSE(Server-sent Events) demo 屏幕共享
daqinzl的专栏
06-29 394
SSE(Server-sent Events) demo 屏幕共享 SSE（ Server-sent Events ）是 WebSocket 的一种轻量代替方案，使用 HTTP 协议 SSE是单向通道，只能服务器向客户端发送消息。
小而美的服务端推送技术SSE之理论与实战(含demo)
qubes的专栏
11-08 548
Server-Sent Events,服务器向浏览器推送信息, 注意反过来不行,基于http协议的服务端推送技术
Go语言实现SSE中转demo
weixin_45501219的博客
03-21 856
本文主要通过一个demo来介绍如何使用Go语言实现SSE中转。
长轮询，iframe和sse三种web消息实时推送demo实践
m0_48333563的博客
07-25 413
web消息实时推送demo实践
深入理解Java IO流
"深入理解Java的IO流系统，包括字节流和字符流的各类实现" 在Java编程中，IO（Input/Output）流是处理数据输入和输出的关键机制。Java的IO流系统提供了丰富的类库，使开发者能够方便地进行文件读写、网络通信以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

香鱼嫩虾

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

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

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

打赏作者

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

抵扣说明：

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

余额充值