10

I/O输入输出

3.完成下面方法中的代码，要求建立一个缓冲区，将字节输入流中的内容转为字符串。

import java.io.*;
public class test {
	 static String loadStream(InputStream in) throws IOException {
	        //int ptr;
	        //in = new BufferedInputStream(in);
	        StringBuffer buffer = new StringBuffer();  
	        int n = 1,i=5;
	        byte[] buf = new byte[n];//缓冲区，大小为1字节
	        while(i-->0) {
	         //因为read主要用于读文件，而我这里用它来一个字节的从键盘读，所以不会返回-1，于是我用i来设置读取长度为5
	        	in.read(buf,0,n);
	        	System.out.println(new String(buf));//按字节显示一下
	            buffer.append(new String(buf));    //连接一个字符串
	        }
	        return new String(buffer);  
	  }
	
	public static void main(String[] args) throws IOException {
		InputStream in = new BufferedInputStream(System.in);//in必须要初始化一个对象，不能为null
		String test=loadStream(in);
		System.out.println("result=: "+test);
	}
}

4.编写程序，将一个字符串转为字节数组输入流，将这个流中所有小写字母换成大写字母并写入字节数组输出流中，再将数组输出流转为字符串。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
public class test {
public static void main(String[] args) {
	String str = "Hello World!"; //源字符串
	//字节数组输入流
	ByteArrayInputStream bais = new ByteArrayInputStream(str.getBytes());
	//字节数组输出流
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	//循 环读取
	int b = -1;
	while((b = bais.read()) != -1){
		//把小写字母转换成大写字母
		System.out.print(" "+(char)b);
		if(b >= 97 && b <= 122){ //大写字母从 65~90, 小写字母从 97~122
			b -= 32;
		}
		//写回到字节数组输出流中
		baos.write(b);
	}
	System.out.println();
	//输出，并把字节数组输出流转换成字符串
	String out = baos.toString();
	System.out.println(out);
	}
}

5.完成下面方法中的代码，方法中的参数为一个文本文件的名称，要求将文件中的内容转为字符串。

import java.io.*;
public class test {
	static public String loadFile(String filename) {
	    File file = new File( filename );//建立文件对象
	    try {
	        Reader rdr = new FileReader( file );//建立读文件对象
	        long sz = file.length();
	        //一次全部读入
	        char[] ch = new char[(int)sz]; //开辟一次读入的大小  
	        rdr.read(ch);
	        rdr.close();
	        return new String(ch);//变为字符串
	    } catch(IOException ioe) {
	        return null;
	    }
	}
	public static void main(String[] args) {
		//先在test工程的目录下手动新建一个test.txt（和bin,src文件夹并列的位置），自己保存点内容
		//设定文件名
		String fname = "test.txt";
		String test=loadFile(fname);//调用方法
		System.out.println(test);
	}
}

6.完成下面方法中的代码，将字符串contents中的内容写入文件filename中。

import java.io.*;
public class test {
	static public boolean saveFile(String filename, String contents) {
	    try {
	        File file = new File( filename );
	        if(!file.exists()) {//判断该txt是否存在
	              file.createNewFile();//不存在就在当前目录下新建一个
	        }
	        Writer wtr = new FileWriter( file );
	        char[] ch = contents.toCharArray();//把字符串转为字符数组
	        wtr.write(ch);
	        wtr.close();
	        return true;
	    } catch(IOException ioe) {
	        return false;
	    }
	} 

	public static void main(String[] args) throws IOException {
		String fname = "test.txt";//给定文件名
		String contents = "hello world!";//给定写入的字符串
		if(saveFile(fname,contents))System.out.println("contents is save!");//显示是否成功
	}
}

7.socket套接字有一个方法getInputStream(),其含义是得到从网络上传过来的数据流。现要求编写一段程序，将接收的数据存入文件。

客户端：
import java.io.*;
import java.net.Socket;

public class TalkClient {
    public static void main(String[] args)throws IOException {
        Socket socket = new Socket("127.0.0.1",5000);
        OutputStream out = socket.getOutputStream();
        int i =10;
        while(i-->0)  
        {
        	out.write("HELLO".getBytes());
        	out.flush();
        }
        System.out.println("发送消息完毕！");
        out.close();
        socket.close();
    }
   }
   
服务器端：
import java.io.*;
import java.net.*;
public class MultiTalkServer{
	public static void main(String[] args)throws IOException {
        ServerSocket server = new ServerSocket(5000);//打开服务器制定端口,等待客户端连接
        //获得与服务器相连的套接字对象     套接字:绑定ip地址和端口号的网络对象
        Socket socket = server.accept();
        //查看该地址文件夹是否存在,如果不存在,创建一个
        String name = "test.txt";        //文件名，按照我的设定，应该在test文件夹下面
        File file = new File(name); 
        if(!file.exists()){
            file.createNewFile();
            System.out.println("文件已新建！");
        }   
        InputStream in = socket.getInputStream();  //套接字的字节输入流,读取客户端传过来的数据
        FileOutputStream fos = new FileOutputStream(name);  //创建输出流对象           
        byte[] data = new byte[5];//一次读取5字节,方便阅读，因为客户端传的就是5个字节
        int len = 0;
        //如果客户端没有关闭socket输出流,这里的read方法会一直读取
        while((len = in.read(data)) != -1) 
        {
        	fos.write(data, 0, len);
        	fos.write("\r\n".getBytes());// 写入一个换行
        }  
        System.out.println("上传成功!");
        server.close();
        fos.close();
    }
}

8.编写程序实现文件查找功能。提供两个参数，第一个参数为查找的起始路径，第二个参数为要查找的文件名称。如果找到，则给出文件的完整路径，否则提示文件不存在。

import java.io.File;
public class test
{
	String path = null;
	public String searchFile(File dir, String fileName) 
	{
		if(dir.isFile())//测试当前dir是否为文件
		{
			if(dir.getName().equals(fileName))//此时表明dir为一个文件，和我们要找的文件比对一些
				path = dir.getAbsolutePath();
		}
		if (dir.isDirectory())//进入if表明dir为一个文件夹
		{
			//列出dir中所有的文件和目录
			File[] files = dir.listFiles();
			File f ;
			for (int i=0;i<files.length;i++ ){
				f = files[i];
				path = searchFile(f, fileName);//递归调用，因为文件夹可能有多层
			}				
		}
		return path;
	}
 
	public static void main(String[] args) {
		File dir = new File("D:/360Downloads/");//此处不能写D:/，原因应该是根目录不支持吧
		String fileName = "filelist.dat";	//自己修改个文件名	
		if (!dir.exists())
		{
			System.out.println("目录不存在：" + dir);
			System.exit(0);
		}
		String path = new test().searchFile(dir,fileName);
		if(path!=null)
			System.out.println("文件完整路径：" + path);
		else
			System.out.println("不存在此文件");
	}
}

6.利用串行化技术和Socket通信，将一个客户端构造的对象传送到服务器端，并输出该对象的属性值。

User对象类：
import java.io.Serializable;

public class User implements Serializable{

	/**
	 * 下面那句serialVersionUID是用来防止旧版本修改出错的，这里我们用不上，但确实是一个漏洞，所以要设置默认UID
	 */
	private static final long serialVersionUID = 1L;
	String Name;
	String Password;
	User()//默认构造函数
	{
		Name="null";
		Password="00000";
	}
	User(String name,String password)//带参数的构造函数
	{
		Name=name;
		Password=password;
	}
	void setName(String name) {Name=name;}
	void setPassword(String password) {Password=password;}
	String getName() {return Name;}
	String getPassword() {return Password;}
}

客户端：
import java.io.*;
import java.net.Socket;

public class TalkClient {
	public static void main(String[] args) throws IOException{
	    Socket socket = null;
		try {
			socket = new Socket("127.0.0.1", 4700);
		} catch (IOException e) {
			e.printStackTrace();
		} 
        User u1 = new User();
        u1.setName("Tommy");
        u1.setPassword("1234567"); //赋值
        //把对象串行化为可输出的形式，输入到Socket的输出流里面
        ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
        out.writeObject(u1);//以串行化方式写入这个对象
        System.out.println("successful!");
        out.flush();
        out.close();//超级重要，要是没有close来正常退出，服务器端就会被意外中止，导致出错。
    }
}

服务器端：
import java.io.*;
import java.net.*;
public class MultiTalkServer {
	public static void main(String[] args) throws ClassNotFoundException, IOException {
	    ServerSocket server;
	    Socket socket = null; 
        try {
            server = new ServerSocket(4700);
            socket = server.accept();
            //这步很重要，socket.getInputStream()是输入流，要用ObjectInputStream装配为串行化输入流
            ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
            System.out.println("连接成功！");
            User u2 = (User) in.readObject();//接受一个被串行化的对象，赋值给u2
            System.out.println("Name: "+ u2.getName() + "  Password: " + u2.getPassword());
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
	}
}