洛神赋

知识点一：分类
         IO中按照数据流的方向不同可以分为输入流和输出流（以程序的角度来考虑）

         按照数据单位的不同可以分为字节流和字符流。

         按照功能的不同可以分为节点流和处理流。

知识点二: 四大等级结构

　　java语言的i/o库提供了四大等级结构:InputStream,OutputStream,Reader,Writer四个系列的类。InputStream和OutputStream处理8位字节流数据, Reader和Writer处理16位的字符流数据。InputStream和Reader处理输入, OutputStream和Writer处理输出。大家一定要到J2SE文档中看看这四大等级结构的类继承体系。

　　除了这四大系列类,i/o库还提供了少数的辅助类,其中比较重要的是InputStreamReader和OutputStreamWriter。InputStreamReader把InputStream适配为Reader, OutputStreamWriter把OutputStream适配为Writer;这样就架起了字节流处理类和字符流处理类间的桥梁。

　　您使用I/O库时,只要按以上的规则,到相应的类体系中寻找您需要的类即可

下面我就会对I/O 进行不定期更新：

1 FileOutputStream 文件字节流

Public class FileInputStream extends InputStream

　　{

　　/* File Descriptor - handle to the open file */

　　private FileDescriptor fd;

　　public FileInputStream(FileDescriptor fdObj)

　　{

　　SecurityManager security = System.getSecurityManager();

　　if (fdObj == null) {

　　throw new NullPointerException();

　　}

　　if (security != null) {

　　security.checkRead(fdObj);

　　}

　　fd = fdObj;

　　}

　　//其他代码

　　}

　　可见,FileInputStream继承了InputStream,组合了FileDescriptor,采用的是对象Adapter模式。我们学习i/o库时,主要应该掌握这四个对象Adapter模式的适配源: ByteArrayInputStream的适配源是Byte数组, FileInputStream的适配源是File对象, PipedInputStream的适配源是PipedOutputStream对象, StringBufferInputStream的适配源是String对象

线程间通信：一个线程向数据存储空间添加数据（唐老鸭），另一个线程从数据存储空间取出数据（米琪）。

程序有两种以外需要考虑：

1、      假设唐老鸭线程刚向数据存储空间添加了一辆车的名字。还没有加入这辆车的颜色，CPU就切换到了米琪线程，唐老鸭线程将把这辆车的名字和上辆车的颜色联系到了一起。

2 、唐老鸭了若干次的数据。米琪才开始取数据，或者是，米琪取完了一个数据后，还没等到唐老鸭放入新的数据，又重复取出已取过的数据。

可能出现的问题：

1唐老鸭比米琪快时，米琪会漏掉一些数据没有取到。

2、      米琪比唐老鸭快时，米琪取相同的数据。

多个线程共享同一资源的时候，必须进行同步，采用同步方法，解决第一个问题。

线程的等待和唤醒机制：

wait()：告诉当前线程放弃监视器并进入睡眠状态，直到其他线程进入同一监视器并调用notify为止。

notify()：唤醒同一对象监视器中调用wait的第一个线程。

程序中采用线程的等待和唤醒机制，当发现米琪没有取走内容时，唐老鸭应该等待，当米琪把内容取走之后，唐老鸭才可以放。这样解决了第二个问题。


代码如下：

package Killva.IOchaper4.o3;

class Animal{
 private String name ="唐老鸭";
 private String  sex= "公";
 private boolean flag=false;
 
 public synchronized void set(String name, String sex){//生产者
  //如果flag的值不是true则要等待
  
  if(!flag){
   //等待
   try{
    wait();
   }catch(Exception e){}
   
  }
  //如果向下继续执行了，则表示可以设置， flag =true
  this.name=name;
  this.sex=sex;
  //修改设置的标志
  flag = false;
  //唤醒其他线程
  notify();
 }
 //设置一个输出的方法
 public synchronized void get(){
  //如果flag的值为true的时候，表示要等待
  if(flag){
   try{
    wait();
    
   }catch(Exception e){}
   
  }
  //如果向下执行了，就表示允许
  System.out.println(this.name+"-->"+this.sex);
  //改变标签
  flag =true;
  notify();
 }
}

class Pro implements Runnable{
 Animal per =null;
 public Pro(Animal p){
  this.per=p;
  
 }
 public void run() {
  int i =0;
  
  while (true){
   
   if(i==0){
    per.set("米琪", "母");
    i=1;
    
   }else{
    per.set("唐老鸭", "公");
    i=0;
   }
  }
 }
}

class Cus implements Runnable{
 Animal per =null;
 public Cus(Animal p){
  this.per=p;
 }
 public void run() {
  while(true){
     per.get();
  }
 }
}

public class Demo01 {
 //主方法
 public static void main(String[] args){
  Animal per =new Animal();
  Pro p =new Pro(per);
  Cus c =new Cus(per);
  
  new Thread(p).start();
  new Thread(c).start();
  
 }

}

运行结果：




感谢阅读 ！！！欢迎交流！！！    QQ：237333696

         所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。
下面是我忍为比较重要的API：
        1、. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。

　　2、. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例，。

　　3、. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。

　　注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。

  写代码时一般先写server端.
//Server

package Killva.NetWorkchaper1.o3;

import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class TestTCPServer {
 public static void main(String args[])throws IOException{
  ServerSocket ss =new ServerSocket(9999);
  while(true){
   System.out.println("--------服务端已近启动------------");
      Socket s =ss.accept();
     
      DataOutputStream dos =new DataOutputStream(s.getOutputStream());
     
      System.out.println("客户端["+s.getInetAddress().getHostAddress()+
                     "  :"+s.getPort()+
                     "]已近链接！");
      dos.writeUTF("服务器端写入客户端的数据：客户端("+
               s.getInetAddress().getHostAddress()+
                "  :"+s.getPort()+
                        "]已经链接上服务器端["+
                        s.getLocalAddress().getHostName()+
                        ":"+s.getLocalPort()+
                        "]！");
     
      dos.flush();
      dos.close();
      s.close();
     
     
  }
 }
 

}

Client端

package Killva.NetWorkchaper1.o3;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;

public class TestTCPCLient {
 public static void main(String[] args) throws IOException{
  System.out.println("-------------client端-----------");
  for(long i=0;i<10;i++){
   Socket s =new Socket("192.168.1.*",9999);//IP是用你所在的局域网来测试
   
   DataInputStream dis = new DataInputStream(s.getInputStream());
   System.out.println(""+dis.readUTF());
   dis.close();
   s.close();
  }
 }
}


运行结果真确时服务器端和客户端能连接

感谢阅读！！！！