有关io的编程

‘壹’ simotion 的IO输入如何配置使用编程

这部分细节使用方法比较繁琐。化繁为简后：
1.IO变量有映像区，来刷新数据。
2.映像区刷新频率不同，与执行系统的中Task一致。以PIX.X的形式访问。
3.地址区0-63已被预设为BackgroundTask的映像区，以%IX.X的形式访问。

如果不清楚上面的话，这么做：
1.建议所有IO变量全部在ADDRESS LIST中定义，全部是PIX.X的形式定义IO变量，并分配映像区
2.在程序中调用IO变量即可。
3.如果想突破映像区刷新频率限制，而直接访问IO变量，使用格式_direct.IO_Var。不建议这么做

‘贰’ ABB机器人smart组件中的IO信号如何在示教器上编程

首先在smart组件中有两个信号是抓和放的，我们可以在示教器中用两个输出信号通过工作站逻辑中进行信号关联，从而实现抓，放，绝对可以的，我有试过了

‘叁’ io指的是什么啊

io指的是输入和输出。

由于程序和运行时数据是在内存中驻留，由CPU这个超快的计算核心来执行，涉及到数据交换的地方，通常是磁盘、网络等就需要IO接口。IO编程中Stream（流）是一个很重要的概念，可以把流想象成一个水管，数据就是水管里的水，但是只能单向流动。

由于CPU和内存的速度远远高于外设的速度，所以在IO编程中，就存在速度严重不匹配的问题。举个例子来说，比如要把100M的数据写入磁盘，CPU输出100M的数据只需要0.01秒，可是磁盘要接收这100M数据可能需要10秒。

Io的主要的优点

它是一个可以很快学会的语言因为他有一个简单而且一致的语法、语义和API。由于Io的足迹小，所以它十分合适嵌入式编程。Io的另一个长处是它的速度。它能在性能上胜过很多其他解释型语言，这让他成为密集工作的一个理想选择。

Io的另一个长处——从一个嵌入的角度来看是很有意思的——是你可以重新定义几乎任何运行机制。Io语法中的任何东西都已经转化成了消息，而消息是可以在运行时重新定义的。从这方面来看，实际上你就可以改变里面任何东西来满足你的需求。

‘肆’ 一个java的编程问题关于IO操作及异常处理，题目如下

public static void main(String[] args) {
Scanner in =new Scanner(System.in);
System.out.println("请输入一个整数");
File file =new File("D:\\2.txt");
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
int zs = 0 ;
try {
zs= in.nextInt();
} catch (Exception e) {
System.out.println("输入有误，吵前请输入整数");
zs= in.nextInt();
}
try {
BufferedWriter output = new BufferedWriter(new FileWriter(file,true));

output.write(zs+"\r\n");
//output.write("\r\n");//换行
output.close();
} catch (Exception e) {
e.printStackTrace();
}
in.close();
try {
BufferedReader br = new BufferedReader(new FileReader(file));
StringBuilder result = new StringBuilder();
String s = null;
while((s = br.readLine())!=null){//使用readLine方法，一次读一行
result.append(System.lineSeparator()+s.trim());
}
s = result.toString();
s.replaceAll("\r|\n", "#");
String [] ce = s.split("#");
Arrays.sort(ce);
File f = new File("D:\\", "3.txt");
if(f.exists())
f.delete();
if(!f.exists()){
file.createNewFile();
}
BufferedWriter output = null;
for (int i = 0; i < ce.length; i++) {
output = new BufferedWriter(new FileWriter(f,true));
output.write(ce[i]+"");
output.write("\升纳清r\n");//换行
}
br.close();
output.close();
} catch (Exception e) {
// TODO: handle exception
}
System.out.println("茄者保存成功");

}

‘伍’ 单片机编程-基本IO口与定时计数器

先要定义定时器如果使用定时器尘弯0如下：
12MHz晶振的蔽羡1ms延时：
Timer0 () interrupt 1
{
R0=0;
ET0=0;
TH0=0xfc;
TL0=0x18;
if(delayTimes1!=0) delayTimes1--;
TR0=1;
ET0=1;
}
要实现LED的派并闷变化很简单的：
main()
{
if(first_run==0)
{
delayTimes1=2000;//两秒延时初值
first_run=1;
}
if(delayTimes1==1500)//0.5秒到
{
P1=0xff;//全灭
}
if(delayTimes1==1000)//定时1秒到
{
P1=0x55;//亮一半灭一半
}
if(delayTimes1==500)//定时1.5秒到
{
P1=X；//X值随你定不同的亮法，X不一样
}
}
下面的别抄我饿

‘陆’ 有关IO流的JAVA编程，要求：把一个数组的元素复制到另个数组；去除重复元素不能用SET集合

以int数组为例
先对该数组排序，
因为是排序过的，相同的值会集中在一起
然后循环该数组，
对于每个值，第一次出现时保存到文件里，以后出现时无视
代码如下

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Arrays;

public class Test {
public static void main(String[] args) {
// int型Sample数组
int[] testArr = { 8, 1, 2, 3, 4, 5, 4, 3, 2, 2, 5, 1, 2, 3, 4, 1, 2, 3,
5, 8 };
// 对该数组纤消排序
Arrays.sort(testArr);

try {
// 创建输出文件
File outFile = new File("c://result.txt");
PrintWriter pf = new PrintWriter(outFile);
// 判断值
int checkValue = 0;
// 循灶指环整个数组
for (int i = 0; i < testArr.length; i++) {
if (i == 0) {
// 把第一个值放到checkValue并保存到文件
checkValue = testArr[0];
pf.println(checkValue);
} else {
// 数组里的当前值毁辩知不等于checkValue
if (checkValue != testArr[i]) {
// 把当前值放到checkValue并保存到文件
checkValue = testArr[i];
pf.println(checkValue);
}
}
}
pf.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}

‘柒’ 请教两道java编程题，关于IO包的。

nio不能实现一行一行读，只能一块一块读或者一个字符一个字符读。
代码如下：

import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;
public class Main
{
public static void main(String[] args)
{
Main t = new Main();
t.ReadFlieByLine_IO("E:\\123.txt");
t.ReadFileByLine_NIO("E:\\123.txt");
}

public void ReadFlieByLine_IO(String Filename)
{
File file = new File(Filename);
BufferedReader reader = null;
try
{
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
//一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null)
{ //显示行号
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
}
catch (IOException e) {
e.printStackTrace();
}
/** finally {
if (reader != null){
try {
reader.close();
}
catch (IOException e1) {
}
}
}
*/
}

private void ReadFileByLine_NIO(String Filename)
{
FileInputStream file = null;
FileChannel reader = null;
try
{
file = new FileInputStream(Filename);
reader = file.getChannel();
String tempString = null;
ByteBuffer bb = ByteBuffer.allocate((int)reader.size());
reader.read(bb);
bb.flip();
String fileContent= new String(bb.array());
System.out.println(fileContent);
reader.close();
}
catch (IOException e) {
e.printStackTrace();
}
/** finally {
if (reader != null){
try {
reader.close();
}
catch (IOException e1) {
}
}
}
*/
}
}

‘捌’ java io 编程报错,大神给看下呢

划线代码多了一个分号，导致判断失效，删除分号就可以了

‘玖’ c++网络编程中~~~究竟什么是异步IO 还有那个select函数是异步IO

异步文件如首IO也就是重叠IO。
在同步文件IO中，线程启动一个IO操作然后就立即进入等待状态，直到IO操作完成后才醒来继续执行。而异步文件IO方式中，线程发送一个IO请求到内核，然后继续处理其他的事情，内核完成IO请求后，将会通知线程IO操作完成了。
如果IO请求需要大量时间执行的话，异步文件IO方式可以显着提高效率，因为在线程等待的这段时间内，CPU将会调度其他线程进行执行，如果没有其他线程需要执行的话，这段时间将会浪费掉（可能会调度操作系统的零页线程）。如果IO请求操作很快，用异步IO方式反而还低效，还不如用同步IO方式。
同步IO在同一时刻只允许一个IO操作，也就是说对于同一个文件句柄的IO操作是序列化的，即使使用两个线程也不能同时对同一个文件句柄同时发出读写操作。重叠IO允许一个或多个线程同时发出IO请求。
异步IO在请求完成时，通过将文件句柄设为有信号状态来通知应用程序，或者应用程序通过GetOverlappedResult察看IO请求是否完成，也可以通过一个事件对象来通知应用程序。
例如DeviceIoControl这个函数，他就可以通过参数指定是同步渣宽数或异步，如果是同步的话，则该函数将会等待结果返回后，才执行下一条语句。如果是异步的话，DeviceIoControl调用后马上返回，如果参数正确，则回返回ERROR_IO_PENDING（忘了怎样写，不过肯定是有PENDING这个词），然后你可以通过GetOverlappedResult获取返回结果，是一个overlap结构，是在你调用DeviceIoControl的最后一个参数传进去的``
简单的说``同步在编程里，一般是指某个操作执行完后，才可以执行后面的操作``拿到IO上来说``就是我要做完这个IO操作``才继续后面的操作```
异步则是，我交带了某个操作给系统（巧枝可以是windows，也可以是你自己的库），我呆会过来拿，我现在要去忙别的``拿到IO上说``我交带了某个IO操作给系统。。。。。

‘拾’ Java关于io和多线程的编程题，求代码

packageknow;
importjava.io.BufferedReader;
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.util.HashMap;
importjava.util.Map;
importjava.util.Scanner;
publicclassT20{
publicstaticvoidmain(String[]args)throwsIOException{
Scanners=newScanner(System.in);
Stringusername=null;
Stringpassword=null;
System.out.println("输入用户名：");
while(true){
if(username==null){
username=s.next();
System.out.println("输入密码：");
}else{
password=s.next();
}
if(password!=null){
s.close();
break;
}
}

BufferedReaderbr=null;
Map<String,String>map=newHashMap<String,String>();
try{
br=newBufferedReader(newInputStreamReader(newFileInputStream("d:/test.txt")));
Stringtemp=null;
while((temp=br.readLine())!=null){
String[]ss=temp.split("=");
map.put(ss[0],ss[1]);
}
}catch(IOExceptione){
throwe;
}finally{
if(br!=null)
br.close();
}
Stringu=map.get("userName");
Stringp=map.get("password");
if(u.equals(username)&&p.equals(password)){
System.out.println("登录成功");
}else{
System.out.println("用户名或密码错误");
}
}
}

packageknow;
publicclassT21{
publicstaticvoidmain(String[]args)throwsInterruptedException{
String[]persons=newString[]{"甲","乙","丙","丁","午","己","庚","辛","壬","癸"};
for(inti=0;i<persons.length;i++){
System.out.println(persons[i]+"正在过山洞");
Thread.sleep(5000);
}
}
}

最后一个网络搜一个就行了，肯定比我画的好