精华内容
下载资源
问答
  • Java输入输出

    万次阅读 多人点赞 2018-05-12 15:27:45
    引言:在平时java开发中,被输入输出搞得头疼。特此写下这篇博客,一是为了总结输入输出,二是为了和大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!! 1.输入格式,输出格式控制 1.1输入处理 java的...

    源代码见:点击打开链接

    引言:在平时java开发中,被输入输出搞得头疼。特此写下这篇博客,一是为了总结输入输出,二是为了和大家分享。如果大家觉得写得好,就请高抬贵手点个赞呗!!!

    1.输入格式,输出格式控制

    1.1输入处理

        java的输入,我们用到Scanner类,可以用它创建一个对象

        Scanner reader=new Scanner(System.in);

        然后reader对象调用nextBoolean(),nextByte(),nextShort(),nextInt(),nextLong(),nextFloat(),nextDouble()方法来从输入流中获取数据。这些方法在执行时都会阻塞,程序等待用户在输入流中输入enter键(\n)时继续执行。这里的nextInt,hasNextInt()这些方法的调用,会判断当前字节流里面是否有东西,没有就阻塞等待输入直到用户按enter键(\n)结束输入,在Scanner类中有一个变量needInput,当需要读取数据时,needInput=true(也就是调用nextInt,hasNextInt()这些函数的时候)。有一个readInput方法,当字节流中有东西可读时,让needInput=false(表示不需要阻塞等待输入);下面是Scanner.class源码:

     // Tries to read more input. May block.
        private void readInput() {
            if (buf.limit() == buf.capacity())
                makeSpace();
    
            // Prepare to receive data
            int p = buf.position();
            buf.position(buf.limit());
            buf.limit(buf.capacity());
    
            int n = 0;
            try {
                n = source.read(buf);//这儿
            } catch (IOException ioe) {
                lastException = ioe;
                n = -1;//这儿
            }
    
            if (n == -1) {
                sourceClosed = true;
                needInput = false;//这儿
            }
    
            if (n > 0)
                needInput = false;/这儿
    
            // Restore current position and limit for reading
            buf.limit(buf.position());
            buf.position(p);
        }
    

        总之,在调用next(),hasNext()方法时,字节流里面有东西,就不用等待,没有东西就阻塞等待。例如:

    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner s=new Scanner(System.in);
    		int a,b;
    		a=s.nextInt();
    		System.out.println(a);
    		b=s.nextInt();
    		System.out.println(b);
    		/*a=s.nextInt();
    		b=s.nextInt();
    		System.out.println(a+"  "+b);*/
    	}

        当在命令行时输入时,我可以这样输入(在一行就输入两个数据再按enter),当运行到b=s.nextInt()时,发现字节流里面有东西,就没有阻塞等待输入了。

        当然我们也可以这样输入(第一行输入2后,按enter键,然后在输入3,再按enter键)。运行过程是这样的,首先,当运行到a=s.nextInput()时发现,字节流里面没东西,等待输入,于是我们在命令行的第一行输入了2,按回车确认,这时程序继续执行。当运行到b=s.nextInt()时,发现字节流里面没东西,则阻塞等待输入,于是我们在命令行第三行输入3,按enter键确认,程序继续执行。

        Scanner 使用分隔符模式将其输入分解为标记,默认情况下该分隔符模式与空白匹配(当然可以自定义分隔符)。

         在下面1.3中我们举一个输入控制实例来熟练输入控制的使用。

     

    1.2 hasNext源码解析

    首先我们分输入源是System.in(也就是控制台),和从文件中读取(FileInputStream)。

    (1)对于System.in,不管如何都是要返回true的。我们看源码:

            /*这是测试代码*/
            Scanner scanner=new Scanner(System.in);
    
    
            while (scanner.hasNext()){
                System.out.println(scanner.next());
            }

     我们进入hasNext()函数

    
    public boolean hasNext() {
            ensureOpen();
            saveState();
            while (!sourceClosed) {
                /*看buffer里面是否有东西,有就返回ture*/
                if (hasTokenInBuffer())
                    return revertState(true);
                
                /*没有就从System.in中读入数据。该方法可能会阻塞*/
                readInput();
            }
            
            /*对于从控制台中读入数据,这两句代码是永远不会被执行的。相当于从控制台读入数据永远不会结束,sourceClosed永远为false*/
            boolean result = hasTokenInBuffer();
            return revertState(result);
    }

    (2) 从文件中读取(FileInputStream)

     Scanner scanner1=new Scanner(new FileInputStream("/home/fengli/a.txt"));
    
     while (scanner1.hasNext()){
           System.out.println(scanner1.next());
     }

     在进入hasNext()方法:

    public boolean hasNext() {
            ensureOpen();
            saveState();
            while (!sourceClosed) {
                /*看buffer里面是否有东西,有就返回ture*/
                if (hasTokenInBuffer())
                    return revertState(true);
                
                /*没有就从System.in中读入数据。该方法可能会阻塞*/
                readInput();
            }
            
            /*用文件中读取,sourceClosed就可能为ture。所以这个方法就可以返回false*/
            boolean result = hasTokenInBuffer();
            return revertState(result);
    }

     

    1.3 输出处理

        可用System.out.println()或System.out.print()来向屏幕进行输出。jdk1.5新增了和C语言中printf函数类似的数据输出方法,

    System.out.printf(“格式控制部分”,表达式1,表达式2,……,表达式n)

        格式控制部分由格式控制符号:%d,%c,%f,%s和普通字符组成,普通字符原样输出。格式控制符用来输出表达式的值。

        %d:输出int类型数据值

        %c:输出char类型数据

        %f:输出浮点型数据,小数点部分最多保留6位

        %s:输出字符串数据

        %md:输出int型数据占m列

        %m.nf:输出的浮点型数据占m列,小数点保留n位

    格式字符串语法:

        每个格式控制以%开始,以空格或标点符号结尾。

        

     

    1.3输入输出实例--读入指定形状,输出指定形状

        实例为输出九九乘法表,源码如下:

    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		for(int i=1;i<=9;i++)
    		{
    			for(int j=1;j<=i;j++)
    			{
    				System.out.printf("%2d X%2d=%3d ",j,i,i*j);
    			}
    			System.out.println();
    		}
    	}
    }

        运行结果:

    2.从文件输入,输出

    2.1实现方法

        可通过重定向标准输入输出流的方法来实现从文件中输入输出数据。具体使用到的方法如下:

        

    static void setIn(InputStream in)//重定向标准输入
    static void setOut(PrintStream out) //重定向标准输出

       

    2.2从文件输入输出实例--拷贝

        通过重定向的方法,实现从一个文件拷贝东西到另外一个文件。

        代码如下:

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.PrintStream;
    import java.util.Scanner;
    
    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		/*
    		 * FileInputStream里面的路径可以写绝对路径又可以写相对路径,为了程序的移植性,推荐使用相对路径,相对路径
    		 * 的根路径是Copy
    		 */
    		FileInputStream fis = null;
    		PrintStream fos=null;
    		try {
    			fis = new FileInputStream("src/source");
    			fos=new PrintStream("src/dest");
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		System.setIn(fis);//重定向标准输入
    		
    		//接下来就和从标准输入流读入数据一样了
    		Scanner sc = new Scanner(System.in);
    		String s=sc.nextLine();
    		System.out.println(s);
    		
    		//重定向输出流
    		System.setOut(fos);
    		
    		//接下来就和从标准输出流读入数据一样了
    		System.out.println(s);
    	}
    
    }
    

     

     

     

     

     

     

     

     

     

    展开全文
  • C++输入输出

    万次阅读 多人点赞 2019-06-11 20:46:05
    在C++的标准库中,将用于进行数据输入输出的类统称为”流类“。cin是流类istream的对象,cout是流类ostream的对象。要使用流类,需要在程序中包含iostream头文件。 C++中常用的几个流类及其2相互关系: 图1中的...

    数据输入和输出过程也是数据传输的过程。数据就像流水一样从一个地方流动到另一个地方,因此,在C++中将此过程称为“流(stream)"。

    在C++的标准库中,将用于进行数据输入输出的类统称为”流类“。cin是流类istream的对象,cout是流类ostream的对象。要使用流类,需要在程序中包含iostream头文件。

    C++中常用的几个流类及其2相互关系:

     图1中的箭头代表派生类。ios是抽象基类,它派生出istream和ostream。istream和ostream又共同派生出了iostream类。

    为了避免多继承的二义性,从ios派生出istream和ostream时,均使用virtual关键字(虚继承)。

    istream是用于输入的流类,cin就是该类的对象。

    ostream是用于输出的流类,cout就是该类的对象。

    ifstream是用于从文件读取数据的类。

    ofstream是用于向文件写入数据的类。

    iostream是既能用于输入,又能用于输出的类。

    fstream是既能从文件读取数据,又能向文件写入数据的类。

    标准流对象

    iostream头文件中定义了四个标准流对象,它们是cin、cout、cerr和clog。

    cin对应于标准输入流,用于从键盘读取数据,也可以被重定向为从文件中读取数据。

    cout对应于标准输出流,用于向屏幕输出数据,也可以被重定向为向文件写入数据。

    clog对应于标准错误输出流,用于向屏幕输出错误信息,不能被重定向。

    cerr和clog的区别在于:cerr不适用缓冲区,直接向显示器输出信息;而输出到clog中的信息会先被存放到缓冲区,缓冲区满或者刷新时才输出到屏幕。

    ostream类的无参构造函数和复制构造函数都是私有的,因此在程序中一般无法定义ostream类的对象,唯一能用的ostream类的对象就是cout。

    cout可以被重定向,而cerr不能。所谓重定向,就是将输入的源或输出的目的地改变。例如,cout本来是输出到屏幕的,但是经过重定向,本该输出到屏幕上的东西就可以被输出到文件中。

    例如:

    #include <iostream>
    using namespace std;
    int main()
    {
        int x,y;
        cin >> x >> y;
        freopen("test.txt", "w", stdout);  //将标准输出重定向到 test.txt文件
        if( y == 0 )  //除数为0则输出错误信息
            cerr << "error." << endl;
        else
            cout << x /y ;
        return 0;
    }

    其中,freopen是个标准库函数,第二个参数w代表写模式,第三个参数代表标准输出。该语句的作用是将标准输出重定向为test.txt文件。重定向之后,所有对cout的输出都不再出现在屏幕上,而是在test.txt文件中。

    cin也可以被重定向,如果在程序中加入

    freopen("input.dat", "r", stdin);

    第二个参数r代表读入方式,第三个参数stdin代表输入。执行此语句后,cin就不再从键盘读入数据,而是从input.dat文件中读入数据。

    使用流操作算子

    C++中常用的输入流操纵算子如表1所示,它们都是在头文件iomanip中定义的,要使用这些流操纵算子,必须包含该头文件。

    note:"流操纵算子"一栏中的*不是算子的一部分,星号表示在没有使用任何算子的情况下,就等效于使用了该算子。例如,在默认情况下,整数是十进制形式输出的,等效于使用了dec算子。

    流操作算子的用法

    使用这些算子的方法是将算子用<<和cout连用。例如

    cout<<hex<<12<<","<<24;

    这条语句的作用是指定以十六进制形式输出后面两个数,因此输出结果是:

    c,18

    setiosflags()算子

    setiosflags()算子实际上是一个函数库,它以一些标志作为参数,这些标志可以是在iostream头文件中定义的以下几种取值,它们的含义和同名算子一样。

     这些标志实际上都是仅有某比特位为1,而其他比特位都为0的整数。

    多个标志可以用|运算符连接,表示同时设置。例如:

    cout << setiosflags(ios::scientific|ios::showpos) << 12.34;

    如果两个相互矛盾的标志同时被设置,如先设置setiosflags(ios::fixed),然后设置setiosflags(ios::scientific),那么结果可能就是两个标志都不起作用。因此,在设置了某标志,又要设置其他与之矛盾的标志时,就应该用resetiosflags清除原先的标志。例如下面的三条语句:

    cout << setiosflags(ios::fixed) << 12.34 << endl;
    cout << resetiosflags(ios::fixed) << setiosflags(ios::scientific | ios::showpos) << 12.34 << endl;
    cout << resetiosflags(ios::showpos) << 12.34 << endl;  //清除要输出正号的标志

    输出结果是:

    12.340000
    +1.234000e+001
    1.234000e+001

    需要注意的是,setw()算子所起的作用是一次性的,即之影响下一次输出,每次需要指定输出宽度时都要使用setw()。因可以看到,第9)行的输出因为没有使用setw(),输出宽度就不再是前面所指定的12个字符。

    在读入字符串时,setw()还能影响cin的行为,例如下面的程序:

    #include <iostream>
    #include <iomanip>
    using namespace std;
    int main()
    {
        string s1, s2;
        cin >> setw(4) >> s1 >> setw(3) >> s2;
        cout << s1 << "," << s2 << endl;
        return 0;
    }

    输入:

    1234567890↙

    程序的输出结果是:

    1234,567

    说明setw(4)使得读入s1时,只读入4个字符串,其后的setw(3)使得读入s2时只读入3个字符。

    setw()用于cin时,同时只影响下一次的输入。

    调用cout的成员函数

    ostream类有一些成员函数,通过cout调用它们也能用于控制输出的格式,其作用和流操纵算子相同。

    这些成员函数的用法十分简单,如:

    cout.setf(ios::scientific);
    cout.precision(8);
    cout << 12.23 << endl;

    输出结果是:

    1.22300000e+001

    文章内容来自于http://c.biancheng.net/view/275.html

    展开全文
  • JAVA基础知识和常用算法合集: ... 目录 1.主类的命名必须是Main ...2.输入输出: 2.1输入: (1)使用Scanner类进行输入 (2) hasNext()方法 2.2输出 3快速输入输出 3.1使用StreamTokenizer 和 PrintW...

    JAVA基础知识和常用算法合集:

    https://blog.csdn.net/GD_ONE/article/details/104061907

    目录

    1. 主类的命名必须是Main

    2.输入输出:

      2.1输入:

    (1)使用Scanner类进行输入

    (2) hasNext()方法  

    2.2 输出

    3 快速输入输出

     3.1使用StreamTokenizer 和 PrintWriter

     3.2 使用BufferedReader和BufferedWriter实现快速输入输出

    BufferedReader

    BufferedWriter

    实例


    摘要

    本文主要介绍快速输入输出, 文中提到了几个IO类,这里推荐使用BufferedReader输入,BufferedWriter输出,当输入输出的数据量大于一百万左右就必须使用快速IO不能直接使用Scanner和System.out.print

    1. 主类的命名必须是Main

    形如:

    public class Main{

    }

    2.输入输出:

      2.1输入:

    (1)使用Scanner类进行输入

        首先需要定义一个可以在控制台从键盘接收数据的Scanner对象: (Scanner类的包名是 java.util.Scanner)

    Scanner in = new Scanner(System.in); // 用于控制台从键盘读入数据

    然后使用这个in对象配合in.nextXXX()方法接收数据:

    不同类型的数据使用不同的in.nextXXX()方法。

    如:

    字符串需要用

             或者

          

    需要注意的是:                                                                                                                                                                        

    in.next() 从缓冲区接收字符遇到空格后停止。 相当于 cin 和 scanf

    in.nextLine() 从缓冲区接收字符,并且接收空格,遇到换行才停止,并且会自动舍弃换行。 相当于 gets()

    import java.util.Scanner;
    
    public class Main{
    	public static void main(String[] args){
    		Scanner in = new Scanner(System.in);
    		String s1 = in.next();  // -》 C++中 cin/scanf
    		String s2 = in.nextLine(); // -> C++中  gets()
    		System.out.println("s1:"+s1);
    		System.out.println("s2:"+s2);
    		in.close();
    	}
    }
    

    上述代码定义了两个字符串类:s1 和 s2。  分别用 in.next()  和 in.nextLine() 输入。

    结果如下:

     in.next()将从缓冲区内接收了abc赋值给了s1 , 遇到空格后停止,缓冲区内还剩下了一个空格和qwe ,in.nextLine()将缓冲区剩下的字符赋值给 s2。

    类比scanf和gets。

     

    (2) hasNext()方法  

    in.hasNext用法:

    in.hasNext()的返回值是bool值,作用是当在缓冲区内扫描到字符时,会返回true, 否则会发生阻塞,等待数据输入。

    所以in.hasNext()是不会返回false的

    所以遇到多组输入时,可以使用 while + in.hasNext() 相当于 while(scanf())

    如:每次输入三个整数,输出三数之和。

    import java.util.Scanner;
    
    public class Main1 {
    	public static void main(String[] args){
    		Scanner in = new Scanner(System.in);	
    		int a, b, c; 
    		while(in.hasNext()){	
    		    a = in.nextInt();
    		    b = in.nextInt();
    		    c = in.nextInt();
    		    System.out.printf("%d\n",a+b+c);
    		}
    	}
    }
    

    和in.nextXXX()方法类似,in.hasNextXXX()也有针对不同类型变量的方法。

    如:

    in.hasNext() // 判断缓存区中还有没有数据,有返回true, 否则等待输入。
    in.hasNextInt() // 判断输入的是不是int型的数据,是的话返回true 否则继续扫描缓冲区,或者等待输入。
    in.hasNextDouble() // 判断输入的是不是double型的数据,是的话返回true 否则继续扫描缓冲区,或者等待输入。

     

     


    2.2 输出

            java中往控制台输出的几种常用函数

    System.out.printf(); //和C/C++中的printf一样。 可使用格式控制符进行格式化输出。
    // 例如: 输出一个int类型变量  System.out.printf("%d",a);
    System.out.print() //不能使用格式控制符进行格式化输出,仅输出变量
    System.out.println() //不能使用格式控制符进行格式化输出,仅输出变量,但会自动输出一个换行。

     

    3 快速输入输出

       (不想看函数介绍的,可以直接看最下面的程序实例)

      3.1使用StreamTokenizer 和 PrintWriter实现快速输入输出 (非推荐)

    StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    

       这种方式只能读取数字和字母字符串, 不能读取空格和其他字符。

    实例1:

    import java.io.*;
     
    public class Main {
        public static void main(String[] args) throws IOException {
            //快速输入  
            StreamTokenizer in =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
            //快速输出
            PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
            while(in.nextToken() != StreamTokenizer.TT_EOF){
                int a = (int)in.nval; // 获取一个整型数据
                in.nextToken();  //从流中获取下一个数据, 相当于scanf()读入一个数据然后存在缓存区
                String s=in.sval; //  获取一个字符串  
                in.nextToken();
                double n=in.nval;
                out.println(n);
                out.flush();//将输出缓冲区清空。
            }  
        }
    }

      PrintWriter类中 包含 print()  printf()  writer() 方法    printf()可用于格式化输出  但速度是最慢的  write()的速度是最快的

      注意要在最后刷新输出缓冲区, 就是记得加上  out.flush()  否则会什么也不输出

     3.2 使用BufferedReader和BufferedWriter实现快速输入输出(推荐)

    BufferedReader 和 BufferedWriter 都在 java.io.*包内。

    BufferedReader

    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

    成员方法
    方法                                                   描述
    int read()                                            读取单个字符。
    int read(char[] cbuf, int off, int len)     将字符读入数组的某一部分。
    String readLine()                                读取一个文本行。
    long skip(long n)                                 跳过字符。
    boolean ready()                                  判断此流是否已准备好被读取。
    void close()                                         关闭该流并释放与之关联的所有资源。
    void mark(int readAheadLimit)           标记流中的当前位置。
    boolean markSupported()                   判断此流是否支持 mark() 操作(它一定支持)。
    void reset()                                          将流重置到最新的标记。

    主要使用read() 和 readLine()

    String s = in.read() // 读入一个字符 可读入空格回车 但不抛弃回车
    String s1 = in.readLine(); // 读入一行 可读入空格可读入回车 但会将回车抛弃
    string s2[] = in.readLine().Split(" "); // 使用Split通过空格分割读入的一行字符串,存在s2中

    需要注意的是 在windows中按一下回车键 一共有两个字符 "\n\r"  而read()只能读取一个字符所以如要要用read来达到吸收回车的目的,需要用两个read();  如果用readLine()的话会将"\n\r"全部吸收 , 所以只需要一个readLine()来吸收回车。

    详见下面实例2.


     

    BufferedWriter

    BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

    主要使用 BufferedWriter类中的 write() 类进行输出。 当数据量大的时候一定要使用这个类进行输出,谨记!

      需要注意的是 write() 不能直接输出int类型, 因为write(int a)  会输出其对应的ASCii码的字符 ,比如输出 65 会显示 A 详见代码:

    int a = 65;
    char b = '2';
    String c = "3";
    
    out.write(a);
    out.write("\n");
    out.write(b);
    out.write("\n");
    out.write(c);
    out.write("\n");
    out.flush();
    
    输出:
    A
    2
    3
    

     

    所以当需要输出一个int类型的变量时, 可以用Integer.toString(int a)方法 将其变为字符串形式输出。

    或者使用 + 拼接一个字符串,这样 参数整体就是一个字符串了,比如加一个换行符。详见代码:

    int a = 65;
    
    out.write(a + "\n");
    out.write(Integer.toString(a));
    out.flush();
    
    输出:
    65
    65

     

    实例2:

    import java.io.*;
    import java.util.*;
    
    
    public class Main{
        static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        public static void main(String[] args) throws IOException{
            //测试writr 不能直接输出int类型
        	int a = 65;
            out.write(a);
            out.write("\n");
        	out.write(a + "\n");  // 使用 + 号拼接个字符串 使参数整体为一个字符串 
            out.write(Integer.toString(a)); // 输出a的字符串形式
            out.write("\n");
           
            //测试 read() 和  readLine();
            int b = in.read();   // read()只读取一个字符
            int c = in.read();   // 吸收 \n
            int x = in.read();   // 吸收 \r
           // String e = in.readLine();
            String d = in.readLine();
            out.write("\n");
            out.write(b + "\n");
            out.write(c + "\n");
            out.write(x + "\n");
            out.write(d + "\n");
            //out.write(e);
            out.flush();
        }
    }

     输出:

    一共输入了:

    1  (按回车键)

    ABC  DEF 

    然后下面输出了

    49(1的ASCii码)

    13(回车键的ACSii码)

    10 (换行键的ASCII码) 

    ABC  DEF

    展开全文
  • Go-输入输出总结及oj的输入输出

    万次阅读 2021-05-29 17:55:15
    目录 输入 无换行 接口 控制台 字符串 ...fmt部分输入输出函数调用图 oj的输入输出 全部代码 参考 输入 无换行 接口 func Fscan(r io.Reader, a ...interface{}) (n int, err error) .

    目录

    输入

    无换行

    接口

    控制台

    字符串

    有换行

    接口

    控制台

    字符串

    有格式

    接口

    控制台

    字符串

    操作系统参数

    输出

    无换行

    接口

    控制台

    字符串

    有换行

    控制台

    接口

    字符串

    有格式

    控制台

    接口

    字符串

    返回错误对象

    fmt部分输入输出函数调用图

    oj的输入输出

    全部代码

    参考


    输入

    无换行

    接口

    func Fscan(r io.Reader, a ...interface{}) (n int, err error)

    Fscan从r扫描文本,将成功读取的空白分隔的值保存进成功传递给本函数的参数换行视为空白。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少,会返回一个错误报告原因。

    接口

    type Reader interface {
        Read(p []byte) (n int, err error)
    }

     实现了Read方法即可,例如文件、标准输入,这里以标准输入为例。

    测试代码

    	var number int
    	fmt.Println("请输入一个整数:")
    	_, err = fmt.Fscan(os.Stdin, &number)
    	if err != nil{
    		fmt.Println(err)
    	}
    	fmt.Println("整数:",number)

    结果

    请输入一个整数:
    9
    整数: 9

     

    请输入一个整数:
    sfes
    expected integer
    整数: 0

    由于篇幅所限,之后就不再测试出错的情况,读者可以看后面全部代码,自行测试。

    控制台

    func Scan(a ...interface{}) (n int, err error)

    Scan从标准输入扫描文本,将成功读取的空白分隔的值保存进成功传递给本函数的参数换行视为空白。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少,会返回一个错误报告原因。

    Scan的源代码

    func Scan(a ...interface{}) (n int, err error) {
    	return Fscan(os.Stdin, a...)
    }

    使用

    	var err error
    	//---------Scan-------------
    	var num int
    	var f float64
    	var str string
    	fmt.Println("请输入一个整数、一个浮点数和一个字符串:")
    	_,err = fmt.Scan(&num)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("整数:",num)
    	}
    	_,err = fmt.Scan(&f)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("浮点数:",f)
    	}
    	_, err = fmt.Scan(&str)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("字符串:",str)
    	}

    结果

    请输入一个整数、一个浮点数和一个字符串:
    9 9.9 lady_killer9
    整数: 9
    浮点数: 9.9
    字符串: lady_killer9

    字符串

    func Sscan(str string, a ...interface{}) (n int, err error)

    Sscan从字符串str扫描文本,将成功读取的空白分隔的值保存进成功传递给本函数的参数换行视为空白。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少,会返回一个错误报告原因。

    Sscan源代码

    func Sscan(str string, a ...interface{}) (n int, err error) {
    	return Fscan((*stringReader)(&str), a...)
    }

    测试代码

    	strInput := "3 4.4 hello"
    	_, _ = fmt.Sscan(strInput,&num,&f,&str)
    	fmt.Println(num,f,str)

    结果:

    3 4.4 hello

    如果字符串是固定的,清楚空格分隔的是什么,使用此函数做一个字符串的分隔也可以。

    注意:输入部分不再展示源代码(Scanxx、Sscanxx的,都是调用的FScanxx),可看文章最后的调用图,在Goland中,可以选中函数,Ctrl+B来查看源代码。

    有换行

    接口

    func Fscanln(r io.Reader, a ...interface{}) (n int, err error)

    Fscanln类似Fscan,但会在换行时才停止扫描。最后一个条目后必须有换行或者到达结束位置。

    测试代码

    	fmt.Println("请输入一个字符串:")
    	_, _ = fmt.Fscanln(os.Stdin, &strInput)
    	fmt.Println("字符串:",strInput)

    结果

    请输入一个字符串:
    lady_killer9
    字符串: lady_killer9

    控制台

    func Scanln(a ...interface{}) (n int, err error)

    Scanln类似Scan,但会在换行时才停止扫描。最后一个条目后必须有换行或者到达结束位置

    测试代码

    	var num2,num3 int
    	fmt.Println("请输入两个整数:")
    	_,_ = fmt.Scanln(&num2,&num3)
    	fmt.Println(num2,num3)

    结果

    请输入两个整数:
    8 9
    8 9

     

    字符串

    func Sscanln(str string, a ...interface{}) (n int, err error)

    Sscanln类似Sscan,但会在换行时才停止扫描。最后一个条目后必须有换行或者到达结束位置。

    	newStr := ""
    	_, _ = fmt.Sscanln(strInput, &newStr)
    	fmt.Println("新字符串",newStr)

    结果

    新字符串 lady_killer9

     

    有格式

    在谈函数之前,我们先看一看有哪些格式。go借鉴了C的风格,使用%形式,浮点数可以指明保留位数。

    通用

    %v	值的默认格式表示
    %+v	类似%v,但输出结构体时会添加字段名
    %#v	值的Go语法表示
    %T	值的类型的Go语法表示
    %%	百分号

    结构体一般会有String方法,%+v也可以接受。

    布尔值

    %t	单词true或false

    整数

    %b	表示为二进制
    %c	该值对应的unicode码值
    %d	表示为十进制
    %o	表示为八进制
    %q	该值对应的单引号括起来的go语法字符字面值,必要时会采用安全的转义表示
    %x	表示为十六进制,使用a-f
    %X	表示为十六进制,使用A-F
    %U	表示为Unicode格式:U+1234,等价于"U+%04X"

    浮点数与复数的两个组分:

    %b	无小数部分、二进制指数的科学计数法,如-123456p-78;参见strconv.FormatFloat
    %e	科学计数法,如-1234.456e+78
    %E	科学计数法,如-1234.456E+78
    %f	有小数部分但无指数部分,如123.456
    %F	等价于%f
    %g	根据实际情况采用%e或%f格式(以获得更简洁、准确的输出)
    %G	根据实际情况采用%E或%F格式(以获得更简洁、准确的输出)

    宽度通过一个紧跟在百分号后面的十进制数指定,如果未指定宽度,则表示值时除必需之外不作填充。精度通过(可选的)宽度后跟点号后跟的十进制数指定。如果未指定精度,会使用默认精度;如果点号后没有跟数字,表示精度为0。举例如下:

    %f: 默认宽度,默认精度
    %9f 宽度9,默认精度
    %.2f 默认宽度,精度2
    %9.2f 宽度9,精度2
    %9.f 宽度9,精度0

    字符串和[]byte

    %s	直接输出字符串或者[]byte
    %q	该值对应的双引号括起来的go语法字符串字面值,必要时会采用安全的转义表示
    %x	每个字节用两字符十六进制数表示(使用a-f)
    %X	每个字节用两字符十六进制数表示(使用A-F)    

    指针

    %p	表示为十六进制,并加上前导的0x    

    下面的就不一一写例子了,举一个控制台的吧

    接口

    func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)

    Fscanf从r扫描文本,根据format 参数指定的格式将成功读取的空白分隔的值保存进成功传递给本函数的参数。返回成功扫描的条目个数和遇到的任何错误。

    控制台

    func Scanf(format string, a ...interface{}) (n int, err error)

    Scanf从标准输入扫描文本,根据format 参数指定的格式将成功读取的空白分隔的值保存进成功传递给本函数的参数。返回成功扫描的条目个数和遇到的任何错误。

    	var f1 float64
    	var f2 float64
    	fmt.Println("请输入普通浮点数和科学计数法表示的浮点数:")
    	_,_ = fmt.Scanf("%f %e", &f1,&f2)
    	fmt.Println(f1,f2)

    结果

    请输入普通浮点数和科学计数法表示的浮点数:
    12.3 123e-1
    12.3 12.3

    字符串

    func Sscanf(str string, format string, a ...interface{}) (n int, err error)

    Sscanf从字符串str扫描文本,根据format 参数指定的格式将成功读取的空白分隔的值保存进成功传递给本函数的参数。返回成功扫描的条目个数和遇到的任何错误。

    操作系统参数

    os.Args[]

    下标为0的是exe路径,之后是输入的参数

    测试代码

    	fmt.Println("第一个参数(exe路径):",os.Args[0])
    	fmt.Println("第二个参数:",os.Args[1])
    	fmt.Printf("参数类型:%T",os.Args[1])

    结果

    E:\Workspace\Go_workspace\learn_go\src\learninouput\main>go run inoutput.go lady_killer9
    第一个参数(exe路径): C:\Users\DELL\AppData\Local\Temp\go-build631438137\b001\exe\inoutput.exe
    第二个参数: lady_killer9
    参数类型:string

    输出

    无换行

    接口

    func Fprint(w io.Writer, a ...interface{}) (n int, err error)

    Fprint采用默认格式将其参数格式化并写入w。如果两个相邻的参数都不是字符串,会在它们的输出之间添加空格。返回写入的字节数和遇到的任何错误。

    控制台

    func Print(a ...interface{}) (n int, err error)

    Print采用默认格式将其参数格式化并写入标准输出。如果两个相邻的参数都不是字符串,会在它们的输出之间添加空格。返回写入的字节数和遇到的任何错误。

    Print源代码

    func Print(a ...interface{}) (n int, err error) {
    	return Fprint(os.Stdout, a...)
    }

    测试代码

    	fmt.Print(1,2,3)

    结果和下面的放一起了

    字符串

    func Sprint(a ...interface{}) string

    Sprint采用默认格式将其参数格式化,串联所有输出生成并返回一个字符串如果两个相邻的参数都不是字符串,会在它们的输出之间添加空格。

    测试代码

    	s := fmt.Sprint(1, 2, 3, "hello", "world")
    	fmt.Print(s)

    结果

    1 2 31 2 3helloworld

    可以看到没有换行,使用Sprint时,相连的非字符串会加空格

    注意:字符串的没有调用接口,后序的也是,不再黏贴源代码。

    有换行

    控制台

    func Println(a ...interface{}) (n int, err error)

    Println采用默认格式将其参数格式化并写入标准输出。总是会在相邻参数的输出之间添加空格并在输出结束后添加换行符。返回写入的字节数和遇到的任何错误。

     测试代码

    	fmt.Println(1,2,3)

    结果

    1 2 3

    接口

    func Fprintln(w io.Writer, a ...interface{}) (n int, err error)

    Fprintln采用默认格式将其参数格式化并写入w。总是会在相邻参数的输出之间添加空格并在输出结束后添加换行符。返回写入的字节数和遇到的任何错误。

    字符串

    func Sprintln(a ...interface{}) string

    Sprintln采用默认格式将其参数格式化,串联所有输出生成并返回一个字符串。总是会在相邻参数的输出之间添加空格并在输出结束后添加换行符

    有格式

    控制台

    func Printf(format string, a ...interface{}) (n int, err error)

    Printf根据format参数生成格式化的字符串并写入标准输出。返回写入的字节数和遇到的任何错误。

    测试代码

    	fmt.Printf("%02d %c %.2f",1,97,45.6344)

    结果

    01 a 45.63

    接口

    func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)

    Fprintf根据format参数生成格式化的字符串并写入w。返回写入的字节数和遇到的任何错误。

    字符串

    func Sprintf(format string, a ...interface{}) string

     Sprintf根据format参数生成格式化的字符串并返回该字符串。

    返回错误对象

    func Errorf(format string, a ...interface{}) error

    这个在文章Go-错误、异常处理详解中再讲解。

    有关文件的输入输出(即读写),可查看:Go-文件目录操作分类详解(创建、打开、关闭、读取、写入、判断等)

    fmt部分输入输出函数调用图

    为防止图片过大,函数参数写的不全,部分函数没有给出使用例子,读者可自行尝试,有问题下方评论。

    oj的输入输出

    使用牛客网:OJ在线编程常见输入输出练习

    不定长的使用的Scanner,大家可以试试前面的接口或Reader等。

    package main
    
    import (
    	"bufio"
    	"fmt"
    	"os"
    	"sort"
    	"strconv"
    	"strings"
    )
    //----------多组a,b----------
    func aB1(){
    	var a,b int
    	for{
    		_,err := fmt.Scan(&a,&b)
    		if err!=nil{
    			break
    		}else{
    			fmt.Println(a+b)
    		}
    	}
    }
    //--------t组a,b-----------
    func aB2()  {
    	var t int
    	var a,b int
    	_,_ = fmt.Scan(&t)
    	for i:=0;i<t;i++{
    		_,_ = fmt.Scan(&a,&b)
    		fmt.Println(a+b)
    	}
    }
    //--------0,0结束--------
    func aB3()  {
    	var a,b int
    	for{
    		_,_ = fmt.Scan(&a,&b)
    		if a==0 && b==0{
    			break
    		}
    		fmt.Println(a+b)
    	}
    }
    //---------多组, 长度为0结束-------------
    func aB4()  {
    	var n int
    	var a,sum int
    	for{
    		_,_ = fmt.Scan(&n)
    		if n==0{
    			break
    		}
    		sum = 0
    		for ;n>0;n--{
    			_,_ = fmt.Scan(&a)
    			sum += a
    		}
    		fmt.Println(sum)
    	}
    }
    //--------------t组,每组n个-----------
    func aB5()  {
    	var t,a,n,sum int
    	_,_ = fmt.Scan(&t)
    	for ;t>0;t--{
    		_,_ = fmt.Scan(&n)
    		sum = 0
    		for ;n>0;n--{
    			_,_ = fmt.Scan(&a)
    			sum += a
    		}
    		fmt.Println(sum)
    	}
    }
    //--------------不定组,长度为0结束-------
    func aB6()  {
    	var n int
    	var a,sum int
    	for{
    		_,err := fmt.Scan(&n)
    		if err != nil{
    			break
    		}
    		sum = 0
    		for ;n>0;n--{
    			_,_ = fmt.Scan(&a)
    			sum += a
    		}
    		fmt.Println(sum)
    	}
    }
    //-----------不定组,不定长-------------
    func aB7()  {
    	input := bufio.NewScanner(os.Stdin)
    	var sum int
    	for input.Scan(){
    		strs := strings.Split(input.Text()," ")
    		sum = 0
    		for _,n := range strs{
    			num,_ := strconv.Atoi(n)
    			sum += num
    		}
    		fmt.Println(sum)
    	}
    }
    //---------t个长字符串------------
    func strSort1(){
    	var t int
    	_,_ =fmt.Scan(&t)
    	input := bufio.NewScanner(os.Stdin)
    	input.Scan()
    	strs := strings.Split(input.Text()," ")
    	sort.Strings(strs)
    	n:=len(strs)
    	for i:=0;i<n;i++{
    		if i==n-1{
    			fmt.Print(strs[i])
    		}else{
    			fmt.Print(strs[i]," ")
    		}
    	}
    }
    //------------多组,不定长字符串,使用" "分隔-----------
    func strSort2()  {
    	input := bufio.NewScanner(os.Stdin)
    	var strs []string
    	var n int
    	for input.Scan(){
    		strs = strings.Split(input.Text()," ")
    		sort.Strings(strs)
    		n = len(strs)
    		for i:=0;i<n;i++{
    			fmt.Print(strs[i]," ")
    		}
    		fmt.Println()
    	}
    }
    //------------多组,不定长字符串,使用","分隔-----------
    func strSort3()  {
    	input := bufio.NewScanner(os.Stdin)
    	var strs []string
    	var n int
    	for input.Scan(){
    		strs = strings.Split(input.Text(),",")
    		sort.Strings(strs)
    		n = len(strs)
    		for i:=0;i<n;i++{
    			if i==n-1{
    				fmt.Print(strs[i])
    			}else{
    				fmt.Print(strs[i],",")
    			}
    		}
    		fmt.Println()
    	}
    }
    
    
    func main() {
    	//-----A+B(1)--------
    	aB1()
    	//----A+B(2)---------
    	aB2()
    	//
    	aB3()
    	aB4()
    	aB5()
    	aB6()
    	aB7()
    	strSort1()
    	strSort2()
    	strSort3()
    }
    

    全部代码

    package main
    
    import (
    	"fmt"
    	"os"
    )
    
    func main() {
    	//---------------------输入-------------------------
    	var err error
    	//--------Fscan------------
    	var number int
    	fmt.Println("请输入一个整数:")
    	_, err = fmt.Fscan(os.Stdin, &number)
    	if err != nil{
    		fmt.Println(err)
    	}
    	fmt.Println("整数:",number)
    	---------Scan-------------
    	var num int
    	var f float64
    	var str string
    	fmt.Println("请输入一个整数、一个浮点数和一个字符串:")
    	_,err = fmt.Scan(&num)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("整数:",num)
    	}
    	_,err = fmt.Scan(&f)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("浮点数:",f)
    	}
    	_, err = fmt.Scan(&str)
    	if err != nil{
    		fmt.Println(err)
    	} else{
    		fmt.Println("字符串:",str)
    	}
    	//----------Sscan----------
    	strInput := "3 4.4 hello"
    	_, _ = fmt.Sscan(strInput,&num,&f,&str)
    	fmt.Println(num,f,str)
    	//---------Fscanln----------
    	fmt.Println("请输入一个字符串:")
    	_, _ = fmt.Fscanln(os.Stdin, &strInput)
    	fmt.Println("字符串:",strInput)
    
    	//---------Scanln-----------
    	var num2,num3 int
    	fmt.Println("请输入两个整数:")
    	_,_ = fmt.Scanln(&num2,&num3)
    	fmt.Println(num2,num3)
    	// ----------Sscanln-------
    	newStr := ""
    	_, _ = fmt.Sscanln(strInput, &newStr)
    	fmt.Println("新字符串",newStr)
    	//---------Scanf------------
    	var f1 float64
    	var f2 float64
    	fmt.Println("请输入普通浮点数和科学计数法表示的浮点数:")
    	_,_ = fmt.Scanf("%f %e", &f1,&f2)
    	fmt.Println(f1,f2)
    	//----------os.Args------------
    	fmt.Println("第一个参数(exe路径):",os.Args[0])
    	fmt.Println("第二个参数:",os.Args[1])
    	fmt.Printf("参数类型:%T",os.Args[1])
    	//---------------------输出-------------------------
    	//---------Print--------------
    	fmt.Print(1,2,3)
    	//---------Sprint-------------
    	s := fmt.Sprint(1, 2, 3, "hello", "world")
    	fmt.Print(s)
    	//---------Println------------
    	fmt.Println(1,2,3)
    	//---------Printf-------------
    	fmt.Printf("%02d %c %.2f",1,97,45.6344)
    }

    参考

    Go-标准库fmt

    Go-标准库os

    Go-标准库bufio

    更多Go相关内容:Go-Golang学习总结笔记

    有问题请下方评论,转载请注明出处,并附有原文链接,谢谢!如有侵权,请及时联系。如果您感觉有所收获,自愿打赏,可选择支付宝18833895206(小于),您的支持是我不断更新的动力。

    展开全文
  • C语言 基本输入输出函数

    万次阅读 多人点赞 2016-11-03 15:07:57
    1 几组常见的输入输出函数在stdio.h头文件中内置了几种输入输出函数,如下列出: printf 与 scanf getchar 与 putchar gets 与 puts 相比之下 printf 与 scanf的功能最为强大,但操作稍显复杂,后两种则功能简单,...
  • Java的常用输入输出语句

    万次阅读 多人点赞 2018-04-14 19:03:38
    一、概述 输入输出可以说是计算机的基本功能。作为一种语言体系,java中主要按照流(stream)的模式来实现。其中数据的流向是按照计算机的方向确定的,流入计算机的数据流叫做输入流(inputStream),由计算机发出的...
  • C语言中的输入输出流和缓冲区(重点)详解

    万次阅读 多人点赞 2019-01-01 13:21:56
    C语言中我们用到的最频繁的输入输出方式就是scanf()与printf()。 scanf(): 从标准输入设备(键盘)读取数据,并将值存放在变量中。 printf(): 将指定的文字/字符串输出到标准输出设备(屏幕)。注意宽度输出和精度 ...
  • 【51/STM32】详解单片机GPIO口输入输出的各种模式

    千次阅读 多人点赞 2020-05-10 18:54:04
    通用型输入输出端口,简称GPIO口,是单片机与其他外围设备和电路进行信息交换和控制的桥梁。本文从复习模电中所学的场效应管开始,逐步引出开漏输出与推挽输出的概念及阐述其原理,并结合点亮一盏LED灯的实例进一步...
  • C++基础 输入输出流及常用头文件

    千次阅读 2019-06-30 21:23:45
    输入输出流 scanf 和 printf 格式化输入格式化输出:需要对应格式,用指针操作,没有类型安全机制,数据量大时效率高 cin 和 cout 流输入流输出:读取是数据流,而不是具体的数据,自动判断变量类型,不需要指定。...
  • 通常该流对应于键盘输入或者由主机环境或用户指定的另一个输入源 public static final PrintStream out:标准输出流。通常该流对应于显示输出或者由主机环境或用户指定的另一个输出目标 我们先看标准输入...
  • 输入输出重定向

    千次阅读 2018-05-15 17:04:30
      想要把多个Linux 命令适当地组合到一起,使其协同工作,以便我们更加高效地...在日常的学习和工作中,相较于输入重定向,我们使用输出重定向的频率更高,所以又将输出重定向分为了标准输出重定向和错误输出重...
  • C语言的基本的输入输出

    万次阅读 2020-03-17 12:40:40
    C语言的基本的输入输出 prinf()函数 在头文件stdio.h中 printf()函数是格式化输出函数,一般用于向标准输出设备按照规定格式输出信息。 printf()函数的格式为: printf("<格式化字符串>",<参量表>); ...
  • C语言:字符数组的输入输出

    万次阅读 多人点赞 2018-12-20 10:56:46
    用printf输出 用scanf输入 用gets输入 用puts输出 用printf输出 输出方法1:printf 逐个字符输出。  void main(void){  char c[ ] = "I am happy";   int i;   ...
  • linux中的标准输入输出

    万次阅读 多人点赞 2018-09-04 09:56:17
    Linux中的标准输入输出 标准输入0 从键盘获得输入 /proc/self/fd/0  标准输出1 输出到屏幕(即控制台) /proc/self/fd/1  错误输出2 输出到屏幕(即控制台) /proc/self/fd/2      /dev/null代表linux的...
  • c语言输入输出格式

    万次阅读 多人点赞 2018-06-11 20:39:58
    //最近被某题的输入输出卡了。。。转一波随时看。。。菜哭&lt;span style="font-family:KaiTi_GB2312;font-size:18px;"&gt;本小节介绍的是向标准输出设备显示器输出数据的语句。在C语言中,所有...
  • C语言对文件的输入输出

    千次阅读 多人点赞 2018-09-03 18:31:51
    输入输出数据流的开始和结束仅受程序控制而不受物理符号(如回车换行符)控制,这就增加了处理的灵活性。这种文件称为流式文件。 一、打开与关闭文件 1.1 C语言用标准输入输出函数fopen来实现打开文件,...
  • 牛客网输入输出(Java)总结

    千次阅读 多人点赞 2020-07-23 16:07:45
    由于自己笔试失利,痛定思痛之后决定总结一下牛客的输入输出问题,以免再次败北… 预备知识 Windows中的Enter键相当于回车(\r)+换行(\n),分别完成将光标移到行首、移到下一行的功能; nextInt():直至读取到空格或...
  • c语言-常见的输入输出符号

    千次阅读 2021-01-05 22:19:02
    c语言-常见的输入输出符号 一.关于%d的输入输出 (1)%5d就是将数字的宽度变为2,采用右对齐的方式输出,若数据不到5位,就用空格补完,比如输出32, 32[前面有3个空格]。 (2)%05d就是像上面一样,但是不同在它会用...
  • python学习-输入输出

    千次阅读 2020-12-03 06:47:41
    Python的输入和输出非常...输入是Input,输出是Output,因此,我们把输入输出统称为Input/Output,或者简写为IO。输出:Python的输出用print()方法,在括号中写需要输出的内容,例如最简单的输出一个字符串>>...
  • ACM的Python版输入输出

    千次阅读 多人点赞 2018-09-06 11:59:10
    一、输入部分 1. 单样例输入 (1)只需输入一行 2. 多样例输入 (1)多样例输入,无明确样例个数 (2)要输入N行  (3)多样例输入,指定结束符号 (4)输入N组,指定结束符号 3.多样例复杂输入 (1)多...
  • C++输入输出运算符的重载

    千次阅读 多人点赞 2018-07-26 10:49:48
    ”在C++类库中提供的,所有的C++编译系统都会在提供输入流istream和输出流ostream,cin、cout是分别是istream类和ostream类的对象,在类库的头文件中已经对“&amp;amp;lt;&amp;amp;lt;”、“&amp;amp;gt...
  • RNN的数据输入输出维度

    千次阅读 2019-09-24 14:25:53
    看到这篇文章的读者朋友应该对RNN和LSTM的基本结构有了一定的认识,下面就简单快速复习一下: 首先说明一下RNN是什么,递归神经网络(recursive ...相信你一定对RNN的输入输出维度方面的认知有了比较全面和清楚的认知。
  • C/C++文件输入输出(详细介绍)

    万次阅读 多人点赞 2018-10-28 09:39:20
    ´在头文件iostream中定义有两个流类:输入流类istream和输出流类ostream,且用这两个类定义了流对象cin和cout: ´Istream cin; ´ostream cout; ´cin是一个istream类的对象,它从标准输入设备(键盘)获取数据,...
  • C语言字符串输入输出函数

    千次阅读 多人点赞 2020-03-21 18:36:15
    C语言字符串输入输出函数 (1)putchar()函数 格式: putchar© 功能:向终端输出一个字符 注意:输出的时候不会加回车 (2) getchar()函数 格式:字符型变量=getchar () 功能:从标准输入设备上读取单个字符,返回值...
  • C语言总结(数据输入输出

    千次阅读 2019-01-20 15:20:26
    C语言总结第四章、数据输入输出数据输出字符输出函数格式输出函数数据输入字符输入函数格式输入函数 第四章、数据输入输出 C语言无I/O语句,I/O操作由函数实现 putchar( ) getchar( ) printf( ) scanf( )...
  • Java中数组的输入输出

    万次阅读 多人点赞 2019-08-15 15:28:59
    数组的输入 首先声明一个int型数组 int[] a 或者 int a[] 给数组分配空间 a=new int[10]; 和声明连起来就是int[] a=new int[10]; 或者是 int a[]=new int[10]; 给数组赋值 a[0]=1;//0代表的是数组的第1个...
  • Java输入输出流详解

    万次阅读 多人点赞 2017-06-17 21:15:21
    Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。 在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出...
  • 字符串的输入输出

    千次阅读 2019-07-02 09:59:09
    字符数组的输入除了使用 scanf外,还可以用 getchar或者ges其输出除了使用 printf外,还可以用 putchar或者puts。下面对上述几种方式分别进行介绍: (1) scanf输入, printf输出 scanf对字符类型有%c和%s两种格式( ...
  • python 标准输入输出

    千次阅读 2019-03-27 11:51:39
    标准输入输出 能够使用 input 函数通过键盘输入数据到程序中 能够使用print函数完成字符串信息的动态输出打印 能够完成输入输出版计算圆面积的案例 输入 1.1 概念 用户通过控制台将数据传递给程序的过程 1.2 语法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,313,100
精华内容 1,725,240
关键字:

输入输出

友情链接: gitasar.dll.zip