AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java快读快写

2023-08-06 324
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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();

// 读入字符串
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();
    }
}

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中的大数

// 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
算法
关键词：
Java快读
萤火虫的小尾巴
目录
相关文章
多多!
|
5月前
|
算法 Java 数据处理
Java算法模板 数据流快读
Java算法模板 数据流快读
多多!
36 2
翔宇1
|
6月前
|
Java
Java快读写法
Java快读写法
翔宇1
29 3
运营研究坊
|
9天前
|
安全 Java 测试技术
Java并行流陷阱：为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱，尤其是指定线程池的问题。文章分析了并行流的设计思想，指出了指定线程池的弊端，并提供了使用CompletableFuture等替代方案。同时，介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
运营研究坊
35 2
运营研究坊
|
18天前
|
安全 Java
java 中 i++ 到底是否线程安全？
本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先，使用 100 个线程分别执行 10000 次 `i++` 操作，发现最终结果小于预期的 1000000，证明 `i++` 是线程不安全的。接着，介绍了两种解决方法：使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中，`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后，通过分析字节码和源码，解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。
运营研究坊
40 2
java 中 i++ 到底是否线程安全？
众所周知
|
5天前
|
安全 Java 开发者
深入解读JAVA多线程：wait()、notify()、notifyAll()的奥秘
在Java多线程编程中，`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中，每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践，帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法，确保线程安全和高效的通信。
众所周知
25 9
叫个什么名字
|
8天前
|
存储 安全 Java
Java多线程编程的艺术：从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式，旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战，随后详细介绍了Java中创建和管理线程的两种主要方式：继承Thread类与实现Runnable接口。通过实例代码，本文展示了如何正确启动、运行及同步线程，以及如何处理线程间的通信与协作问题。最后，文章总结了多线程编程的最佳实践，为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
叫个什么名字
43 5
ShaFaChuang-36210
|
5天前
|
监控 安全 Java
Java中的多线程编程：从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式，本文将以一个简短的代码示例作为开篇，直接展示多线程的魅力，随后再详细解析其背后的原理与实现方式，旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例：创建两个线程，分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
ShaFaChuang-36210
20 1
众所周知
|
8天前
|
Java
JAVA多线程通信：为何wait()与notify()如此重要？
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式，使线程在条件不满足时进入休眠状态，并在条件满足时被唤醒，从而确保数据一致性和同步。相比其他通信方式，如忙等待，这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
众所周知
22 3
2G冲浪词条
|
7天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全，提高了并发性能。
2G冲浪词条
17 1
Skyund
|
8天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程，是系统运行的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 线程 线程，与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间做切换工作时，负担要比
Skyund
19 1

热门文章

最新文章

  • 1
    Java 生成 UUID
  • 2
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 3
    【Java用法】使用Java导出word文档的解决方案（适用于从服务器上下载到本地电脑）
  • 4
    JAVA虚拟机关闭钩子(Shutdown Hook)
  • 5
    JDK6笔记（5）----JDBC4
  • 6
    （JAVA编程练习）：判断101-200之间有多少个素数，并输出所有素数。
  • 7
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 8
    （十三）java类的继承
  • 9
    Java基础之004-面向对象
  • 10
    java 定时调用 bat
  • 1
    Dubbo03【管理控制台和监控中心搭建】，Java开发实用必备的几款插件
    56
  • 2
    Java中int[]与Integer[]相互转化的方法，java基础知识面试重点总结
    35
  • 3
    Java 并发编程中的锁优化策略
    34
  • 4
    Java一分钟之-设计模式：装饰器模式与代理模式
    63
  • 5
    《手把手教你》系列技巧篇（四十六）-java+ selenium自动化测试-web页面定位toast-下篇（详解教程）
    62
  • 6
    刷题两个月，从入门到字节跳动offer丨GitHub标星16k+，美团Java面试题
    65
  • 7
    《MySQL 入门教程》第 05 篇 账户和权限，Java高并发编程详解深入理解pdf
    53
  • 8
    Java的前景如何，好不好自学？，万字Java技术类校招面试题汇总
    54
  • 9
    es集群安装，邮储银行java面试
    79
  • 10
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    97

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云OSS设置跨域访问