Java快读快写

这篇具有很好参考价值的文章主要介绍了Java快读快写。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

文章汇总归纳整理于:算法竞赛学习之路[Java版]

Java快读快写模版

相应的数据的读入与输出方法,可以根据自己的需求进行相应的修改
使用StreamTokenizer读取数据时,要注意输入数据的空格(StreamTokenizer以空格或回车换行为每次输入的分隔)

读入与输出对象

// 读入对象
// 快速读入对象
StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
// 字符串快速读入对象
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 快速输出对象
PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

读入整数

// 读入整数
public int readInt() {
    try {
        st.nextToken();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return (int) st.nval;
}

读入长整型整数

// 读入长整型整数
public long readLong() {
    try {
        st.nextToken();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return (long) st.nval;
}

读入浮点数

// 读入浮点数
public double readDouble() {
    try {
        st.nextToken();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return st.nval;
}

读入字符串

public String readString() {
    try {
        st.nextToken();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return st.sval;
}

注意:
1.如果读取的字符串中含有空格,则使用上述方法读取字符串,会存在读取问题,读到空格就停止本次的数据读入,因为StreamTokenizer在读取输入数据时,是以空格或回车换行为每次输入数据的分隔,所以如果要读取含有空格的字符串,要使用下面的方法
虽然StreamTokenizer有提供方法,可以修改输入数据时的分隔符,但是由于大部分题目的输入数据中都是以空格或换行为分隔符,所以不建议进行修改(如要修改可以参考:StreamTokenizer使用详解)
2.如果要将数值数据以字符串的形式读入,则不能使用上述的方法,需要使用下面的方法。StreamTokenizer以字符串的形式读取数值数据,读入后的字符串变量将指向null,即StreamTokenizer以字符串的形式读入数值数据读入的结果为空。

String s = readString();
out.print(s);
out.flush();

image.png

// 读入字符串
public String readString() {
    String s = null;
    try {
        s = br.readLine();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return s;
}

输出数据

out.print(); // 不换行输出
out.println(); // 换行输出
out.printf();//格式化输出
// 将缓冲区的数据刷新
// 只有将缓冲区的数据进行刷新,才会在控制台进行输出
out.flush(); // 一定要写否则数据不会真正输出

快读快写的使用

package 快读快写;

import java.io.*;

class ReadAndWrite {
    // 读入对象
    // 快速读入对象
    StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    // 字符串快速读入对象
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    // 快速输出对象
    PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    
    // 读入整数
    public int readInt() {
        try {
            st.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int) st.nval;
    }
    
    // 读入长整型整数
    public long readLong() {
        try {
            st.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (long) st.nval;
    }
    
    // 读入浮点数
    public double readDouble() {
        try {
            st.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return st.nval;
    }
    
    // 读入字符串
    public String readString1() {
        String s = null;
        try {
            s = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return s;
    }
    
    public String readString2() {
        try {
            st.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return st.sval;
    }
    
    public static void main(String[] args) {
        ReadAndWrite readAndWrite = new ReadAndWrite();
        // 读入整数
        int i = readAndWrite.readInt();
        readAndWrite.out.println(i);
        // 将缓冲区的数据刷新
        // 只有将缓冲区的数据进行刷新,才会在控制台进行输出
        readAndWrite.out.flush(); // 一定要写否则数据不会真正输出
        // 读入长整数
        long l = readAndWrite.readLong();
        readAndWrite.out.println(l);
        // 读入浮点数
        double d = readAndWrite.readDouble();
        readAndWrite.out.println(d);
        // 读入字符串
        String s = readAndWrite.readString1();
        readAndWrite.out.println(s);
        s = readAndWrite.readString2();
        readAndWrite.out.println(s);
        readAndWrite.out.flush();
    }
}

image.png

Java快读快写练习

P5715 【深基3.例8】三位数排序

传送门:https://www.luogu.com.cn/problem/P5715

解题代码

// package 快读快写;

import java.io.*;

public class Main {
    // 读入对象
    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    // 输出对象
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    
    public static void main(String[] args) {
        // 读入数据
        int a = readInt();
        int b = readInt();
        int c = readInt();
        // 将 a b c 三个数从小到大进行排序
        // 如果 a 大于 b 则交换 a b
        if ( a > b ) {
            int t = a;
            a = b;
            b = t;
        }
        // 如果 a 大于 c 则交换 a c
        if ( a > c ) {
            int t = a;
            a = c;
            c = t;
        }
        // 经过上两次交换 a 变为最小
        // 如果 b 大于 c 则交换 b c
        // 交换之后 c 变为最大
        if ( b > c ) {
            int t = b;
            b = c;
            c = t;
        }
        // 输出
        out.print(a + " ");
        out.print(b + " ");
        out.print(c);
        out.flush();
    }
    
    /**
     * 读入整数
     * @return 返回读入的整数数值
     */
    static int readInt() {
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int) in.nval;
    }
}

P4414 [COCI2006-2007#2] ABC

传送门:https://www.luogu.com.cn/problem/P4414

解题代码

// package 快读快写;

import java.io.*;

public class Main {
    // 数据读入对象
    static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    // 输出对象
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    
    public static void main(String[] args) throws IOException {
        // 数据读入
        int a = readInt();
        int b = readInt();
        int c = readInt();
        // 对三个数从小到大进行排序
        if (a > b) {
            int t = a;
            a = b;
            b = t;
        }
        if (a > c) {
            int t = a;
            a = c;
            c = t;
        }
        if (b > c) {
            int t = b;
            b = c;
            c = t;
        }
        // 此时 a b c 已经按照从小到大的顺序排列
        // 读取字符串
        String s = readString();
        int len = s.length();
        // 输出的顺序按照输入的字符串中ABC三个字母的顺序输出abc,
        // ABC三个对应的数据要满足 A<B<C
        for (int i = 0; i < len; i++) {
            char ch = s.charAt(i);
            switch (ch) {
                case 'A':
                    out.print(a);
                    break;
                case 'B':
                    out.print(b);
                    break;
                case 'C':
                    out.print(c);
                    break;
            }
            out.print(" ");
        }
        out.flush();
    }
    
    /**
     * 读入整数
     * @return 整数
     */
    static int readInt() {
        try {
            st.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int) st.nval;
    }
    
    /**
     * 读入字符串(输入的字符串中不能含有空格)
     * @return 字符串
     */
    static String readString() {
        try {
            st.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return st.sval;
    }
}

P4325 [COCI2006-2007#1] Modulo

传送门:https://www.luogu.com.cn/problem/P4325

解题代码

// package 快读快写;

import java.io.*;

public class Main {
    // 快读对象
    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    // 快写对象
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    
    public static void main(String[] args) {
        // 读入数据
        // 由题目已知输入10个整数
        // 由于要统计输入的10个整数模42后有多少个不同的余数
        // 模42,余数最多有42种可能 0-42
        // 这里使用一个数组来统计每种可能余数出现的次数
        int[] remain = new int[42];
        for (int i = 0; i < 10; i++) {
            int num = readInt();
            remain[num % 42]++; // 计算num%42余数,并对该余数出现的次数加一
        }
        // 遍历查看有多少个不同的余数
        int ans = 0;
        for (int i = 0; i < 42; i++) {
            if (remain[i] > 0) ans++;
        }
        out.print(ans);
        out.flush();
    }
    
    /**
     * 读入整数
     *
     * @return 整数
     */
    static int readInt() {
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int) in.nval;
    }
}

P8711 [蓝桥杯 2020 省 B1] 整除序列

传送门:https://www.luogu.com.cn/problem/P8711

解题代码

// package 快读快写;

import java.io.*;

public class Main {
    // 快读对象
    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    // 快写对象
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    
    public static void main(String[] args) {
        // 读取数据
        long num = readLong();
        // 如果当前整数还大于0就进行除以2
        while ( num > 0 ) {
            out.print(num + " ");
            num /= 2;
        }
        out.flush();
    }
    
    /**
     * 读取长整型整数
     *
     * @return 长整型整数
     */
    static long readLong() {
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (long) in.nval;
    }
}

存在整数的精度问题,最后一个测试点的精度超过long所允许的最大值,需要使用Java中的大数

image.png文章来源地址https://www.toymoban.com/news/detail-406975.html

// package 快读快写;

import java.io.*;
import java.math.BigInteger;

public class Main {
    // 快读对象
    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    // 快写对象
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    
    public static void main(String[] args) {
        // 读取数据
        String s = readString();
        // 使用大数(10^18次方 long的精度不够)
        BigInteger bigInteger = new BigInteger(s);
        // 如果当前整数还大于0就进行除以2
        // bigInteger.compareTo(BigInteger.ZERO) 和0比较,
        // 大于0返回正数,等于0返回0,小于0返回负数
        while ( bigInteger.compareTo(BigInteger.ZERO)>0 ) {
            out.print(bigInteger + " "); // 输出当前整数
            bigInteger = bigInteger.divide(BigInteger.valueOf(2)); // 除以2
        }
        out.flush();
    }
    
    /**
     * 读取字符串
     *
     * @return 字符串
     */
    static String readString() {
        String s = null;
        try {
            s = in.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return s;
    }
}

P1152 欢乐的跳

解题代码

// package 快读快写;

import java.io.*;

public class Main {
    // 快读对象
    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    // 快写对象
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    
    public static void main(String[] args) {
        int n = readInt();
        // 一个 n 个元素的整数数组,如果数组两个连续元素之间差的绝对值包括了
        // [1,n−1] 之间的所有整数,则称之符合“欢乐的跳”
        // 采用一个数组来记录 [1,n−1] 之间的所有整数出现的次数
        int[] divide = new int[n];
        // num1 num2为数组中相邻的两个数
        int num1 = 0; // 记录前一个整数
        int num2 = 0; // 记录后一个整数
        for (int i = 0; i < n; i++) {
            if (i == 0) { // 第一次读入
                num1 = readInt();
                continue;
            }
            num2 = readInt(); // 读入当前数
            int d = Math.abs(num2 - num1); // 计算相邻两个数之间差的绝对值
            // 防止下标越界,由于不记录差为0出现的次数,所以将差不在[1,n−1]内,令差为0
            d = d > 0 && d < n ? d : 0;
            divide[d]++; // 计算相邻两个数之间的差,并记录该差出现的次数
            num1 = num2; // 计算完成后,对于下一次输入,num2为前一个数
        } 
        boolean flag = true; // 初始为 欢乐的跳
        for (int i = 1; i < n; i++) {
            // 如果 [1,n−1] 之间的所有整数,由整数未出现,则不为 欢乐的跳
            if (divide[i] == 0) {
                flag = false;
                break;
            }
        }
        // 为 欢乐的跳 输出 Jolly
        // 否则输出 Not jolly
        out.print(flag ? "Jolly" : "Not jolly");
        out.flush();
    }
    
    /**
     * 读入整数
     *
     * @return 整数
     */
    static int readInt() {
        try {
            in.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int) in.nval;
    }
}

到了这里,关于Java快读快写的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • elasticsearch 7.9.3知识归纳整理(五)之 es的索引生命周期管理

    一、常见概念及命令 1.1、概念 ILM定义了四个生命周期阶段: Hot :正在积极地更新和查询索引。 Warm :不再更新索引,但仍在查询。 cold :不再更新索引,很少查询。信息仍然需要可搜索,但是如果这些查询速度较慢也可以。 Delete :不再需要该索引,可以安全地将其删除

    2024年01月22日
    浏览(21)
  • elasticsearch 7.9.3知识归纳整理(六)之 kibana图形化操作es指南

    一、创建用户,角色和权限指引 1.创建角色 1.1 在kibana首页点击Manage and Administer the Elastic Stack下的securitys settings 1.2 点击左侧Security 下的roles 1.3 点击右上角的create role 1.4 输入角色名字 完成后点击下面的create role 1.5 创建好角色后,找到角色,点击 角色名 就会进入给角色授权界

    2024年02月08日
    浏览(19)
  • elasticsearch 7.9.3知识归纳整理(二)之 es基本原理及使用kibana操作es的常见命令

    一、es的基本原理与基础概念 1.1 倒排索引 倒排索引 源于实际应用中需要根据属性的值来查找记录。这种索引表中的每一项都包括一个属性值和具有该属性值的各记录的地址。由于不是由记录来确定属性值,而是由属性值来确定记录的位置,因而称为倒排索引(inverted index)。带

    2024年02月12日
    浏览(14)
  • 《Java SE》网络编程基础知识归纳。

    目录 一、网络基本介绍 1、什么是网络通信? 2、网络 3、IP地址 4、域名 5、网络通信协议 6、Socket 二、TCP网络通信编程  1、应用实例1(字节流) 2、应用实例2(字节流) 3、应用实例3(字符流) 4、netstat 指令 三、UDP网络通信编程  1、基本介绍 2、基本流程 3、应用实例  

    2024年01月20日
    浏览(23)
  • Flink文章汇总

    Flink(1):Flink概述 Flink(2):为什么选择Flink Flink(3):Flink安装部署之Local本地模式 Flink(4):Flink安装部署之Standalone独立集群模式 Flink(5):Flink安装部署之Standalone-HA高可用集群模式 Flink(6):Flink安装部署之Flink On Yarn模式 Flink(7):Flink提交命令之参数总结 Flink(

    2024年02月07日
    浏览(16)
  • Flink 系列文章汇总索引

    本专栏系统介绍某一知识点,并辅以具体的示例进行说明。 本专栏的文章编号可能不是顺序的,主要是因为写的时候顺序没统一,但相关的文章又引入了,所以后面就没有调整了,按照写文章的顺序进行编号。但一个专题的顺序号是统一的,不存在编号跳跃情况。 本部分介

    2024年02月03日
    浏览(16)
  • 【Java基础教程】Java学习路线攻略导图——史诗级别的细粒度归纳 ~

    🍺🍺 各位读者朋友大家好!得益于各位朋友的支持和关注,我的专栏《Java基础教程》 至今已经更新完毕,我们一起探索了Java语言的许多核心概念和重要特性。在过去的文章中,我们 一共涉及了入门知识介绍、编程基础概念、面向对象OOP、包及访问控制权限、异常处理篇、

    2024年02月14日
    浏览(19)
  • 【论文阅读】图像信息隐藏文章汇总(含代码)

    Large-capacity Image Steganography Based on Invertible Neural Networks CVPR2021;可逆网络ISN,大容量的实现是靠RGB通道的累加;无公开代码 Multitask Identity-Aware Image Steganography via Minimax Optimization IEEE Transactions on Image Processing2021;提出直接识别防止接收端泄密、其中恢复分支可选;主要涉及身份信息

    2024年04月09日
    浏览(24)
  • 【Java基础教程】Java学习路线攻略导图——史诗级别的细粒度归纳,持续更新中 ~

    🍺🍺 各位读者朋友大家好!得益于各位朋友的支持和关注,我的专栏《Java基础教程》 至今已经更新完毕,我们一起探索了Java语言的许多核心概念和重要特性。在过去的文章中,我们 一共涉及了入门知识介绍、编程基础概念、面向对象OOP、包及访问控制权限、异常处理篇、

    2024年02月16日
    浏览(22)
  • 【整理】爬取网页数据的方法汇总

    案例 :爬取豆瓣电影Top 250的列表(电影名称、导演、主演、星级等信息) 操作 :浏览器内鼠标右键 — “检查”(不同的浏览器名称可能不一样,此处使用了Google)— Elements :查看网页结构 — Console : 输入指令

    2024年02月02日
    浏览(22)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包