IO学霸2 -- NIO

最新推荐文章于 2022-08-30 20:08:52 发布
最新推荐文章于 2022-08-30 20:08:52 发布
阅读量1.2k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java学霸笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/eyeooo/article/details/12872921

11. NIO

JDK1.4的java.nio.*已经加入新的IO类库，目的在于提高速度。实际上旧的IO包已经使用nio重写，即使不显示用nio写代码，速度已经得到提升。

这种速度提升得益于使用的结构接近于操作系统执行IO的方式：通道与缓冲器。

唯一直接与通道交互的缓冲器：ByteBuffer。

产生FileChannel的三个类：FileInputStream, FileOutputStream, RandomAccessFile.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class GetChannel {

	private static final int BSIZE = 1024;
	
	public static void main(String[] args) throws IOException {
		FileChannel fc = new FileOutputStream("data.txt").getChannel();
		fc.write(ByteBuffer.wrap("Some text ".getBytes()));
		fc.close();
		fc = new RandomAccessFile("data.txt","rw").getChannel();
		fc.position(fc.size());
		fc.write(ByteBuffer.wrap("Some more".getBytes()));
		fc.close();
		fc = new FileInputStream("data.txt").getChannel();
		ByteBuffer buff = ByteBuffer.allocate(BSIZE);
		fc.read(buff);
		buff.flip();
		while(buff.hasRemaining()){
			System.out.print((char)buff.get());
		}
	}

}
//*Output:
Some text Some more
*//

文件复制，注意flip()与clear()的使用

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class ChannelCopy {
	private static final int BSIZE = 1024;
	public static void main(String[] args) throws IOException {
		if(args.length!=2){
			System.out.println("args shit");
			System.exit(1);
		}
		FileChannel in = new FileInputStream("D:\\javaLD\\workspace_IBM\\IO1\\src\\com\\ld\\tij\\ChannelCopy.java").getChannel(),
		out = new FileOutputStream(args[1]).getChannel();
		ByteBuffer buffer = ByteBuffer.allocate(BSIZE);
		while(in.read(buffer)!=-1){
			buffer.flip();
			out.write(buffer);
			buffer.clear();
		}
		//method 2：改进方法transferTo()/transferFrom() 可以将一个通道与另外一个通道相连
		in.transferTo(0, in.size(), new FileOutputStream("test2.txt").getChannel());
	}

}

11.1 NIO中转换数据 

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;

public class BufferToText {
	private static final int BSIZE = 1024;
	public static void main(String[] args) throws IOException {

		FileChannel fc = new FileOutputStream("data2.txt").getChannel();
		fc.write(ByteBuffer.wrap("Some text".getBytes()));
		fc.close();
		
		fc = new FileInputStream("data2.txt").getChannel();
		ByteBuffer buff = ByteBuffer.allocate(BSIZE);
		fc.read(buff);
		buff.flip();
		System.out.println(buff.asCharBuffer());
		
		buff.rewind();
		String encoding = System.getProperty("file.encoding");
		System.out.println("Decoded using "+encoding+": "+ Charset.forName(encoding).decode(buff));
		
		fc = new FileOutputStream("data2.txt").getChannel();
		fc.write(ByteBuffer.wrap("Some text by utf".getBytes("UTF-16BE")));
		fc.close();
		fc = new FileInputStream("data2.txt").getChannel();
		buff.clear();
		fc.read(buff);
		buff.flip();
		System.out.println(buff.asCharBuffer());
		
		fc = new FileOutputStream("data2.txt").getChannel();
		buff = ByteBuffer.allocate(100);
		buff.asCharBuffer().put("some text as charbuffer");
		fc.write(buff);
		fc.close();
		fc = new FileInputStream("data2.txt").getChannel();
		buff.clear();
		fc.read(buff);
		buff.flip();
		System.out.println(buff.asCharBuffer());
	}

}
//*output:
????
Decoded using GBK: Some text
Some text by utf
some text as charbuffer
*//

打印第一行错误原因是因为既没有编码也没有解码。

第二行有解码

第三行有编码

第四行读写都指定了相应的数据格式

在这个例子基础上，下面是一个对各种数据类型的例子

import java.nio.ByteBuffer;

public class GetData {

	private static final int BSIZE = 1024;
	
	public static void main(String[] args) {
		ByteBuffer bb = ByteBuffer.allocate(BSIZE);
		
		int i =0;
		while(i++<bb.limit()){
			if(bb.get()!=0)
				System.out.println("nonzero");
		}
		System.out.println("i="+i);
		bb.rewind();
		
		bb.asCharBuffer().put("Howdy!");
		char c;
		while((c=bb.getChar())!=0){
			System.out.print(c+" ");
		}
		System.out.println();
		bb.rewind();
		
		bb.asShortBuffer().put((short)471142);
		System.out.println(bb.getShort());
		bb.rewind();
		
		bb.asIntBuffer().put(99471142);
		System.out.println(bb.getInt());
		bb.rewind();
		
		bb.asLongBuffer().put(99471142);
		System.out.println(bb.getLong());
		bb.rewind();
		
		bb.asFloatBuffer().put(99471142);
		System.out.println(bb.getFloat());
		bb.rewind();
		
		bb.asDoubleBuffer().put(99471142);
		System.out.println(bb.getDouble());
		bb.rewind();
		
	}

}
//*Output:
i=1025
H o w d y ! 
12390
99471142
99471142
9.9471144E7
9.9471142E7
*//

11.2 视图缓冲器

通过某个特定的基本数据类型的view查看其底层的ByteBuffer。ByteBuffer依然是实际保存数据的地方，并支持前面的view，所以对view任何修改都会映射成为修改后ByteBuffer中的数据。

import java.nio.ByteBuffer;
import java.nio.IntBuffer;

public class IntBufferDemo {
	private static final int BSIZE = 1024;
	public static void main(String[] args) {
		ByteBuffer bb = ByteBuffer.allocate(BSIZE);
		IntBuffer ib = bb.asIntBuffer();
		ib.put(new int[]{11,42,47,99,143,811,1016});
		System.out.println("ib3:"+ib.get(3));
		ib.put(3, 1811);
		ib.flip();
		while(ib.hasRemaining()){
			System.out.println(ib.get());
		}
	}

}
//*Output:
ib3:99
11
42
47
1811
143
811
1016
*//

在同一个ByteBuffer建立不同的view buffer，将同一个字节序列翻译成short, int, float, long, double. 

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;

public class ViewBuffers {

	public static void main(String[] args) {
		ByteBuffer bb = ByteBuffer.wrap(new byte[]{0,0,0,0,0,0,0,'a'});
		bb.rewind();
		System.out.println("Byte Buffer ");
		while(bb.hasRemaining()){
			System.out.print(bb.position()+"->"+bb.get()+", ");
		}
		System.out.println();
		
		CharBuffer cb = ((ByteBuffer)bb.rewind()).asCharBuffer();
		System.out.println("Char Buffer");
		while(cb.hasRemaining()){
			System.out.print(cb.position()+"->"+cb.get()+", ");
		}
		System.out.println();
		
		FloatBuffer fb = ((ByteBuffer)bb.rewind()).asFloatBuffer();
		System.out.println("Float Buffer");
		while(fb.hasRemaining()){
			System.out.print(fb.position()+"->"+fb.get()+", ");
		}
		System.out.println();
		
		IntBuffer ib = ((ByteBuffer)bb.rewind()).asIntBuffer();
		System.out.println("Int Buffer");
		while(ib.hasRemaining()){
			System.out.print(ib.position()+"->"+ib.get()+", ");
		}
		System.out.println();
		
		LongBuffer lb = ((ByteBuffer)bb.rewind()).asLongBuffer();
		System.out.println("Long Buffer");
		while(lb.hasRemaining()){
			System.out.print(lb.position()+"->"+lb.get()+", ");
		}
		System.out.println();
		
		ShortBuffer sb = ((ByteBuffer)bb.rewind()).asShortBuffer();
		System.out.println("Short Buffer");
		while(sb.hasRemaining()){
			System.out.print(sb.position()+"->"+sb.get()+", ");
		}
		System.out.println();
		
		DoubleBuffer db = ((ByteBuffer)bb.rewind()).asDoubleBuffer();
		System.out.println("Double Buffer");
		while(db.hasRemaining()){
			System.out.print(db.position()+"->"+db.get()+", ");
		}
		System.out.println();
		
	}

}
//*output:
Byte Buffer 
0->0, 1->0, 2->0, 3->0, 4->0, 5->0, 6->0, 7->97, 
Char Buffer
0-> , 1->, 2-> , 3-> a,
Float Buffer
0->0.0, 1->1.36E-43, 
Int Buffer
0->0, 1->97, 
Long Buffer
0->97, 
Short Buffer
0->0, 1->0, 2->0, 3->97, 
Double Buffer
0->4.8E-322, 
*//
ByteBuffer是8字节数组产生，然后通过不同的基本类型view buffer显示出来，如下图：



11.2.1字节存放次序（二进制）

big endian 高位优先：将最重要的字节存放在地址最低的存储单元。

little endian 低位优先：讲最重要的字节存放在地址最高的存储单元。

ByteBuffer以高位优先存储数据，网上传送也常用此方式。

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;

public class Endians {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String s = "abcdef";
		ByteBuffer bb = ByteBuffer.wrap(new byte[12]);
		bb.asCharBuffer().put(s);
		System.out.println(Arrays.toString(bb.array()));
		bb.rewind();
		bb.order(ByteOrder.BIG_ENDIAN);
		bb.asCharBuffer().put(s);
		System.out.println(Arrays.toString(bb.array()));
		bb.rewind();
		bb.order(ByteOrder.LITTLE_ENDIAN);
		bb.asCharBuffer().put(s);
		System.out.println(Arrays.toString(bb.array()));
	}

}
//*Output:
[0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102]
[0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102]
[97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102, 0]
*//



11.2.2 深入缓冲区

Buffer由数据和四个索引组成：mark, position, limit, capacity。

capacity(): 返回缓冲区容量;

clear(): 清空缓冲区，position=0, limit=capacity();

flip(): limit=position, position=0;

limit(): 返回limit值;

limit(int lim): 设置limit值;

mark(): mark=position;

position(): 返回position值;

position(int pos): 设置position值;

remaining(): 返回(limit - position);

hasRemaining(): 如果存在position和limit之间元素(limit-position>0?)，则返回ture;

reset(): position=mark.



例子：交换缓冲器中相邻的字符

import java.nio.ByteBuffer;
import java.nio.CharBuffer;

public class UsingBuffers {

	private static void symmetricScramble(CharBuffer buffer){
		while(buffer.hasRemaining()){
			buffer.mark();
			char c1 = buffer.get();
			char c2 = buffer.get();
			buffer.reset();
			buffer.put(c2).put(c1);
		}
	}
	
	
	public static void main(String[] args) {
		char[] data = "UsingBuffers".toCharArray();
		ByteBuffer bb = ByteBuffer.allocate(data.length*2);
		CharBuffer cb = bb.asCharBuffer();
		cb.put(data);
		System.out.println(cb.rewind());
		symmetricScramble(cb);
		System.out.println(cb.rewind());
		symmetricScramble(cb);
		System.out.println(cb.rewind());
	}

}
//*Output:
UsingBuffers
sUniBgfuefsr
UsingBuffers
*//

11.2.3 内存映射文件

内存映射文件用于创建和修改因为太大不能放入内存的文件，使用这种方式，我们可以假定这个文件都放在内存中，而且可以完全把它当做巨大的数组来访问。

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class LargeMappedFiles {

	static int length = 0x8FFFFFF; //128MB
	
	public static void main(String[] args) throws IOException, Exception {
		// TODO Auto-generated method stub
		MappedByteBuffer out 
			= new RandomAccessFile("test.dat","rw").getChannel().map(FileChannel.MapMode.READ_WRITE, 0, length);
		for(int i=0;i<length;i++){
			out.put((byte)'x');
		}
		System.out.println("Finished writing");
		for(int i=length/2;i<length/2+60;i++){
			System.out.print((char)out.get(i));
		}
	}

}
//*Output:
Finished writing
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
*//

11.2.4 加锁 

import java.io.FileOutputStream;
import java.nio.channels.FileLock;
import java.util.concurrent.TimeUnit;

public class FileLocking {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		FileOutputStream fos = new FileOutputStream("file.txt");
		FileLock fl = fos.getChannel().tryLock();
		if(fl!=null){
			System.out.println("Locked File");
			TimeUnit.MILLISECONDS.sleep(1000);
			fl.release();
			System.out.println("Released Lock");
		}
		fos.close();
	}

}
//*Output
Locked File
Released Lock
*//
这里是对整个文件加锁，tryLock()是非阻塞式的，它设法获得锁，否则直接在方法中返回。lock()是阻塞式，阻塞进程直至可以获得锁，或者调用lock()线程中断，或者lock()的通道关闭，FileLock.release()可以释放锁。

11.2.5 部分加锁

tryLock(long position, long size, boolean shared) / lock(long position, long size, boolean shared)

无参数加锁根据文件大小变化而变化，固定大小加锁不会随着文件变化变化，如果获得一段区域加锁(position~position+size)，当文件增大时候，position+size以外的部分将不会被锁定。

对于独占锁或者共享锁由底层的操作系统所决定。如果操作系统不支持共享锁并为每一个请求都创建一个锁，那么它就是独占锁，FileLock.isShared()可以查询。

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;

public class LockingMappedFiles {

	static final int LENGTH = 0x8FFFFFF;//128MB
	static FileChannel fc;
	
	public static void main(String[] args) throws IOException {
		fc = new RandomAccessFile("test.dat", "rw").getChannel();
		MappedByteBuffer out = fc.map(FileChannel.MapMode.READ_WRITE, 0, LENGTH);
		for(int i=0;i<LENGTH;i++){
			out.put((byte)'x');
		}
		new LockAndModify(out,0,0+LENGTH/3);
		new LockAndModify(out,LENGTH/2,LENGTH/2+LENGTH/4);
		
	}
	private static class LockAndModify extends Thread{
		private ByteBuffer buff;
		private int start, end;
		LockAndModify(ByteBuffer mbb, int start, int end){
			this.start=start;
			this.end=end;
			mbb.limit(end);
			mbb.position(start);
			buff = mbb.slice();
			start();
		}
		@Override
		public void run() {
			try {
				FileLock fl = fc.lock(start, end, false);
				System.out.println("Locked: "+start+" to "+end);
				while(buff.position()<buff.limit()-1){
					buff.put((byte)(buff.get()+1));
				}
					fl.release();
					System.out.println("Released: "+start+" to "+end);
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		
	}

}
//*Output
Locked: 0 to 50331647
Locked: 75497471 to 113246206
Released: 75497471 to 113246206
Released: 0 to 50331647
*//

finished nio，IO未完持续~:)






flume数据丢失与重复_Flume基础学习
weixin_39702335的博客
12-26 868
Flume是一款非常优秀的日志采集工具。支持多种形式的日志采集，作为apache的顶级开源项目，Flume再大数据方面具有广泛的应用首先需要在Flume的解压目录中conf文件夹中将flume-env.sh.templete更改未flume.env.sh并修改jdk的位置Source我们可以从Avro，NetCat。Http,TailDir。我们在Java开发中通常都是使用的log4j等日志工具进...
明明白白学Java大学霸
11-19
7. **Java标准库API**：熟悉常用的Java类库，如IO、NIO、XML解析、网络编程等，这些API极大地扩展了Java的功能。 8. **JVM内部原理**：了解Java虚拟机的工作机制，包括类加载、内存管理、垃圾回收等，有助于优化...
Flume的使用问题及解决方案
辉哥大数据
04-17 4259
在使用flume-ng时，踩了很多坑，现在来说一下，希望大家绕过坑，到达熟练使用flume的目的 第一坑：不能正确解码文件，造成不能正确的重命名文件，抛出bug后，之后所有文件都不可以被flume收集，是一个比较严重的错，引起原因是flume使用NIO方式读取文件，将读取的文件以UTF-8的编码读取，在linux状态下，默认是按照GBK编码方式存储文件，所以读取时就会遇到字符长度不够问题，解决办
ByteBuffer clear(), flip(), rewind(), remaining(), mark(), reset()
mlnotes
08-01 2863
ByteBuffer类是java.nio中的一个缓冲区类对于ByteBuffer而言，有四个属性 position, limit, mark, capacity0 ByteBuffer实例的方法ByteBuffer方法准备Buffer以实现结果值PositionLimitMarkByteBuffer clear()将数据read()/put() 进缓冲区0capacity未定义ByteBuffer
mysql io nio区别_Java NIO和IO的区别
weixin_40006963的博客
02-07 167
Java NIOJava NIO(New IO)是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。Java NIO ...文章西北野狼2017-06-26613浏览量Java NIO系列教程(十二) Jav...
javaNIO 理解
qq_19316267的博客
05-07 262
问题： linux IO多路复用有epoll， poll, select，知道epoll性能比其他几者要好。也在网上查了一下这几者的区别，表示没有弄明白。 IO多路复用是什么意思，在实际的应用中是指什么情况？ 以及IO多路复用在一些异步web server中的实际应用，就好比nginx是怎样使用epoll来实现异步IO处理的，一个请求到来了，nginx使用epoll接收请求的过程是怎样的？ P...
大话netty系列之--BIO
wmj765的博客
11-18 843
大话netty系列之--BIO 学渣与学霸   大明与老王是大学同学，大明是典型的三好学生，学习优秀，生活自律，并且是学生会一员，在班级人缘也好； 而老王每天游离在课堂与社会之间，与同学们见面的次数很少，平常不是网吧就是和他们的一帮朋友出去花天酒地！ ==============================分割线=====================================...
【网络通信】详解NIO、select
努力充实，远方可期
10-02 2542
数据源 数据源data source，提供数据的原始媒介。常见的数据源有：数据库、文件、其他程序、内存、网络连接、IO设备。如图10-1所示。 数据源分为：源设备、目标设备。 \1. 源设备：为程序提供数据，一般对应输入流。 \2. 目标设备：程序数据的目的地，一般对应输出流。 图10-1 数据源示意图.png 流 流是一个抽象、动态的概念，是一连串连续动态的数据集合。 对于输入流而言，数据源就像水箱，流(stream)就像水管中流动着的水流，程序就是我们最终的用户。我们通过流(A S
Java IO框架
yuboyao1012的博客
08-30 203
序列化类中必须要实现Serializable接口序列化类中对象属性要求实现Serializable接口serialVersionUID/序列化版本号ID一样，可以保证序列化的类和反序列化的类是同一个类使用transient(瞬间的)修饰属性，该属性就不可以序列化了静态属性不可以序列化/不能保存到硬盘上借助集合，序列化多个对象内存和存储设备之间传输数据的通道输入流、输出流；字节流、字符流；节点流、过滤流；将对象通过流写入到文件，或者将对象通过流读取到内存。...
IO 多路复用是什么意思？
朱小厮的博客
02-17 1400
点击上方“朱小厮的博客”，选择“设为星标”后台回复”加群“获取公众号专属群聊入口来源：知乎链接：rrd.me/gaM7L假设你是一个机场的空管， 你需要管理到你机场的所有的航线， 包括进...
Introduction-to-Java-IO.rar_Java IO Tutorial
09-19
这个教程“Introduction-to-Java-IO”旨在深入理解Java IO系统，包括它的设计原理、使用方法，以及对Java New IO（NIO）的介绍。Java IO API提供了一套丰富的类和接口，使得开发者可以有效地读取、写入数据，无论是...
非阻塞IO完成版.rar_阻塞IO_非阻塞_非阻塞io
09-15
在这个名为"非阻塞IO完成版.rar"的压缩包中，我们似乎有一个项目，它实现了“剪刀石头布”游戏的功能，使用了非阻塞I/O技术，并且开发环境是NetBeans IDE。NetBeans是一款流行的开源集成开发环境，支持多种编程语言...
java容器学习
eyeooo的狗窝
10-16 1415
1.Set Set(interface): 存入Set的每个元素是唯一的，Set中不存在重复元素，加入Set的元素必须定义equals()方法一确保对象的唯一性，Set接口不保证维护元素的次序。 HashSet（默认）: 快速查找，存入元素必须定义hashCode() TreeSet : 保持次序，底层树结构，提取有序序列需要实现Comparable接口。 LinkedHashSet:  
IO学霸3 -- Serializable
eyeooo的狗窝
10-21 1157
1. 压缩 CheckedInputStream: GetCheckSum()为任何InputStream()产生校验和。 CheckOutputStream: GetCheckSum()为任何OutputStream产生校验和。 DeflaterOutputStream: 压缩类的基类。 ZipOutputStream: 一个DeflaterOutputStream，用于将数据压缩成Zi
短期java学习计划
eyeooo的狗窝
10-16 1149
1.容器进阶，equals与hashCode原理。 2.IO进阶，Nio与缓冲。 3.深入并发。 4.网络与TCP/IP，结合IO与并发深入学习。 5.内存与JVM，java内存机制，review计算机原理，JVM启动与垃圾回收。 6.数据结构与算法，数据结构（大学那本教材）
IO学霸
eyeooo的狗窝
10-19 1030
学习IO，有必要了解一下Decorator装饰器模式，该模式在IO设计中大量被使用： http://blog.youkuaiyun.com/eyeooo/article/details/12870867 1.InputStream 类 说明 构造器参数 ByteArrayInputStream 允许将内存的缓冲区当做InputStream 缓冲区，字节从
西门子1200多轴伺服步进FB块程序详解及其工业自动化应用 - 工业自动化 实战版
08-13
西门子1200伺服步进FB块程序的特点和应用。该程序由两个FB组成，分别采用Sc L和梯形图编写，支持PTO脉冲和PN网口模式，适用于多种伺服和步进电机。文中提供了详细的中文注释和关键代码片段，展示了其在不同品牌设备如西门子s120、v90、雷赛步进、三菱伺服等的成功应用案例。此外，还强调了程序的兼容性和灵活性，使其能适应多轴控制和复杂控制需求。 适合人群：从事工业自动化领域的工程师和技术人员，尤其是那些需要深入了解和应用西门子1200伺服步进FB块程序的人群。 使用场景及目标：①用于多轴伺服和步进电机的精确控制；②适用于PTO脉冲和PN网口模式的控制需求；③帮助工程师快速理解和调试程序，提高工作效率。 其他说明：本文不仅提供了理论讲解，还有实际操作指导，确保读者能够在实际项目中顺利应用该FB块程序。
【C语言编程】函数调用规则与实现：函数声明、调用方式及参数传递详解
最新发布
08-13
内容概要：本文详细介绍了C语言中函数调用的相关知识。首先阐述了函数调用的一般形式，强调即使无参函数也需保留括号；当存在多个实参时，它们之间需用逗号分隔且数量与类型须匹配形参。文中特别指出不同编译器对实参求值顺序可能存在差异，如Turbo C++采用从右至左求值。其次，讲解了三种函数调用方式：作为语句执行特定操作、作为表达式返回值参与运算、作为参数传入另一函数。再者，强调了函数声明的重要性，包括库函数需通过预处理指令引入头文件，用户自定义函数若定义在调用之后则需要提前声明，明确了函数声明与定义的区别。最后提供了几个练习题，帮助读者巩固所学知识。; 适合人群：正在学习C语言编程，尤其是对函数调用机制感兴趣的初学者或有一定基础的学习者。; 使用场景及目标：①理解函数调用的基本规则，包括实参与形参的对应关系；②掌握不同编译环境下实参求值顺序的差异；③学会正确地声明和定义函数以确保程序正确运行。; 其他说明：文中还提供了几个实践题目，鼓励读者动手实现pow()、sqrt()函数及字符统计程序，以加深理解。此外，提及了fishc.com网站VIP会员可获取相关资源，支持网站运营和个人发展。
下载httpcore-nio-4.4.6及其核心Jar包交流区
2. 包含内容：httpcore-nio-4.4.6.jar包。.jar文件是一种Java归档文件，通常用于存储Java类文件和相关的元数据和资源文件。在该标题中，指的是特定版本（4.4.6）的httpcore-nio组件的打包文件。这个.jar文件包含了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值