Java 基于多客户端的ServerSocket—聊天服务器端,客户端Socket “操作文件”系统的程序拼接

工作内容：

java 文件操作系统的程序拼接（文章后面贴代码）

学习分享：

在分发任务之初，我以：方法名（参数类型 参数）的方式分发下去，之后由组员自己设计方法体，来实现相应的内容【http://blog.csdn.net/yingtian648/article/details/51749702】

回收方法时还是出现了种种错误：

1.方法名不同于分发下去的方法名。

2.参数类型和参数个数不同。

3.实现方法体的时候使用自己定义的其他方法（重复的方法），最后没把方法调用做个改变

自学分享：

基于多客户端的socket，ServerSocket服务器端，客户端

核心：

1.服务器端：利用一个socket集合来管理socket,将客户福安socket发来的消息分发给集合中所有的socket——即所有已连接客户端，客户端退出则从集合中删除。【利用while(true){clientSocket = socket.accpet()}来无线接收客户端socket的连接】

2.客户端：利用了一个接收消息的线程来一直监听来自服务器端的消息，收到一条显示一条，来个点击发送事件来推送消息到服务器端

【注意：这里连接的客户端socket过多（50条）就很可能会出错，建议可以尝试使用线程池来管理】

服务器端：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;

import jdk.net.Sockets;
/**
 * 可以接受多个客户端来连接，并将客户端发过来的信息反馈给所有已连接的客户端
 * @author Administrator
 *
 */
public class SocketService{
	static List<Socket> sockets = new ArrayList<Socket>();
	private Socket socket = null;
	private ServerSocket server = null;
	private int countNum=1;	//记录已杀连接的客户端个数
	//主函数
	public static void main(String [] args){
		new SocketService();
	}
	public SocketService() {
		// 启动服务器
		try {
			System.out.println("服务器已启动");
			server = new ServerSocket(2016);
			while (true) {
				System.out.println("\r\n等待客第" + countNum + "个客户连接...");
				socket = server.accept();
				System.out.println("\r\n客户端已连接");
				System.out.println("\r\n客户端地址：" + socket.getInetAddress());
				sockets.add(socket);
				new Server_thread(socket).start();
				countNum++;
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

class Server_thread extends Thread {
	private Socket socket;
	private DataInputStream dis = null;
//	private DataOutputStream dos = null;
	private String s = null;
	private String userName;
	private int readTimes = 1;//用于控制客户端姓名显示
	public Server_thread(Socket socket) {
		this.socket = socket;
	}
	@Override
	public void run() {
		while (true) {
			try {
				dis = new DataInputStream(socket.getInputStream());
//				dos = new DataOutputStream(socket.getOutputStream());
				// 堵塞状态，除非收到信息
				s = dis.readUTF();
				//第一次读取客户端的名称
				if(readTimes ==1 ){
					userName = s ; 
					for(Socket socket1:SocketService.sockets){
						DataOutputStream	dos1 = new DataOutputStream(socket1.getOutputStream());
						dos1.writeUTF("[系统消息]"+userName+"上线了");
						dos1.flush();
					}
				}else{
					for(Socket socket1:SocketService.sockets){
						DataOutputStream	dos1 = new DataOutputStream(socket1.getOutputStream());
						dos1.writeUTF(userName+"： "+ s);
						dos1.flush();
					}
				}
				readTimes++;
			} catch (SocketException e){
				SocketService.sockets.remove(socket);
				/**
				 * 执行到这里表示当前客户端socket已经下线
				 * 1.提示所有客户端XX已下线 
				 * 2.把从sockets中删除已下线的socket【不删除会在发消息的时候报错】
				 * 3.运行结果：如果有客户端s1下线，则会提示其他所有的客户端“s1已下线”
				 */
				try {
					for(Socket socket1:SocketService.sockets){
						DataOutputStream	dos1 = new DataOutputStream(socket1.getOutputStream());
						dos1.writeUTF(userName+" 已下线");
						dos1.flush();
					} 
				}catch (IOException e1) {
						e1.printStackTrace();
					}
				System.out.println(userName+"已下线");//打印日志信息
				return;
			}catch (IOException e) {
				e.printStackTrace();				
			}
		}
	}
}

客户端登录窗口

<span style="font-size:14px;">import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

//登录窗口
public class LoginFrame extends JFrame implements ActionListener{
	private String name;
	private JTextField textField_name;
	private DataOutputStream dos = null;
	private Socket client;
	//主界面
	public static void main(String[] args) {
		new LoginFrame();
	}
	public LoginFrame() {
		super.setTitle("登录界面");
		this.setLayout(new FlowLayout());
		JLabel label_points = new JLabel("请输入用户名：");
		textField_name = new JTextField(25);
		textField_name.addActionListener(this);
		this.add(label_points);
		this.add(textField_name);
		setBounds(400, 280, 400, 70);
		setVisible(true);
		validate();
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		/**
		 * 1.创建Socket连接到服务器端
		 * 2.把用户名发送给服务器
		 * 3.显示客户端界面
		 * 4.销毁登录界面
		 */
		name = textField_name.getText();
		try {
			client = new Socket("192.168.199.231", 2016);
			dos = new DataOutputStream(client.getOutputStream());
			dos.writeUTF(textField_name.getText());
		} catch (UnknownHostException e1) {
			e1.printStackTrace();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		new SocketClient(client,name);
		this.dispose();
	}
	
}</span><span style="font-weight: bold; font-size: 24px;">
</span>

客户端聊天界面

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.swing.*;

//客户端界面
public class SocketClient extends JFrame implements ActionListener {
	// 放置窗体下边，用于放置发送内容，发送按钮 清除内容按钮
	private JPanel sourthPanel;
	private JScrollPane centerPanel, panelForMessage; // 放置显示区,放置信息编辑区
	public static JTextArea jTextArea_showMessage; // 显示历史发送，和收到的信息
	private JTextArea textArea_message; // 内容编辑区
	private JButton btn_send, btn_clear; // 发送 清除编辑区内容按钮
	private Socket client;
	private String name;
	private DataOutputStream dos = null;
	private Date date;
	private String timeNow;		//放置编辑好格式的时间（当前时间）
	private SimpleDateFormat sdf;	//编辑时间显示格式
	Font font = new Font("微软雅黑", Font.PLAIN, 14);
	//构造函数
	public SocketClient(Socket client,String name) {
		this.client = client;
		this.name = name;
		sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		super.setTitle("聊天窗口："+name);
		/**
		 * 显示内容
		 * 1.设置不可编辑
		 * 2.加载到滚动面板上（使其具有滚动功能）
		 * 
		 */
		jTextArea_showMessage = new JTextArea();
		jTextArea_showMessage.setEditable(false);
		jTextArea_showMessage.setLineWrap(true);
		jTextArea_showMessage.setFont(font);
		jTextArea_showMessage.setForeground(new Color(11,184,5));
		centerPanel = new JScrollPane(jTextArea_showMessage);
		// 发送内容编辑区
		textArea_message = new JTextArea(3, 40);
		textArea_message.setLineWrap(true);
		panelForMessage = new JScrollPane(textArea_message);
		btn_send = new JButton("发送");
		btn_send.addActionListener(this);
		btn_clear = new JButton("清空");
		btn_clear.addActionListener(this);
		sourthPanel = new JPanel();
		sourthPanel.setBackground(new Color(100, 101, 102));
		sourthPanel.setLayout(new FlowLayout());
		sourthPanel.add(panelForMessage);
		sourthPanel.add(btn_send);
		sourthPanel.add(btn_clear);
		add(centerPanel, BorderLayout.CENTER);
		add(sourthPanel, BorderLayout.SOUTH);
		addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		setBounds(310, 280, 600, 450);
		setVisible(true);
		validate();
		new Client_readThread(client,name).start();
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == btn_send) {
			/**
			 * 1.把发送的信息放在内容显示区
			 * 2.发送给服务器端
			 * 3.清空内容编辑区
			 * 【运行结果：可以发送到服务器端】
			 */
			date = new Date();
			timeNow = sdf.format(date);
			String message = textArea_message.getText();
			jTextArea_showMessage.append("我： "+ message+"   "+timeNow+"\n");
			try {
				dos = new DataOutputStream(client.getOutputStream());
				dos.writeUTF(message+"   "+timeNow);
			} catch (IOException e2) {
				//发送不成功显示内容
				jTextArea_showMessage.append("由于网络原因刚刚您发送的【 "+ message+"】发送失败！");
			}
			textArea_message.setText("");
		} else if(e.getSource() == btn_clear){
			// 清空消息
			textArea_message.setText("");
			validate();
		}
	}
}
//客户端读取信息（来自服务器端）
class Client_readThread extends Thread {
	private Socket socket = null;
	private DataInputStream dis = null;
	private String message = "";
	private String name;
	public Client_readThread(Socket socket,String name) {
		this.socket = socket;
		this.name = name;
		try {
			dis = new DataInputStream(socket.getInputStream());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public void run(){
		while (true) {
			try {
				/**
				 * 1.堵塞
				 * 2.message可能得到的是空，会抛出错误
				 */
				message = dis.readUTF();
				if(message.startsWith(name)){
					//自己发出的信息不用在显示区显示
				}else{
					SocketClient.jTextArea_showMessage.append(message+"\n");
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

文件操作系统代码：【默认路径：e:/FileDemo】开始运行后

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.util.Scanner;

public class FileDemo {
	private PrintStream outPrint = System.out;
	private String star = "**********************************";
	private static Scanner input = new Scanner(System.in);
	private File baseFile = null; // 创建有个基目录

	// 主界面
	public void mainView() {
		initData();
		do {
			String[] titleList = { "新建目录", "新建文件", "删除文件", "删除文件夹", "删除文件夹里面所有的内容", "复制文件", "复制文件夹的所有内容", "移动文件到指定目录",
					"移动文件夹到指定目录", "列出当前目录下文件名称", "退出程序" };
			int choice = viewMethod(titleList);
			switch (choice) {
			case 1:
				// [1]新建目录 刘世华 → createNewFloder(File file)
				/*
				 * 1. 用户可以在默认路径下创建文件夹2. 用户可以自定义路径
				 * 
				 * 【file.mkdir()返回是一个boolean类型，可以用于判断是否成功】
				 */
				print("当前所在目录：" + baseFile.getPath());
				print("请问是否在本目录下创建目录？y/n");
				char isNext = input.next().charAt(0);
				// 在默认路径下创建文件夹
				if (isNext == 'y') {
					print("请输入文件夹名称：");
					String pathName = input.next();
					// 判定文件夹名称不能是
					File newFile = new File(baseFile.getPath() + "/" + pathName);
					// 调用创建目录方法
					if (createNewFloder(newFile)) {
						print("新建目录成功");
					} else {
						print("新建目录失败");
					}
				} else {
					File fileNew = null;
					do {
						print("请输入完整路径名称：[请在def盘创建]输入格式：d:/xx/xx/xx");
						String pathName = input.next();
						// 判断路径是否非法
						if (checkPathString(pathName)) {
							fileNew = new File(pathName);
							// 调用创建目录方法
							if (createNewFloder(fileNew)) {
								print("新建目录成功");
							} else {
								print("新建目录失败");
							}
							break;
						} else {
							print("输入路径错误");
						}
						/**
						 * 调用方法判断路径名称是否正确 调用是路径名正规化，符合java路径规则的方法
						 * 
						 */
					} while (true);
				}

				// 用户自定义完整路径

				break;
			case 2:
				// [2]新建文件 刘世华 → createNewFile(File file)
				/**
				 * 1.创建文件名
				 */
				print("当前所在目录：" + baseFile.getPath());
				print("请输入文件名：");
				String fileName = input.next();
				File newFile = new File(baseFile.getPath() + "/" + fileName);
				// 调用方法
				if (createNewFile(newFile)) {
					print("创建文件成功");
				} else {
					print("创建文件失败");
				}
				break;
			case 3:
				// [3]删除文件 何林 → deleteFile(File file)
				print("当前所在目录：" + baseFile.getPath());
				listFloderContentName(baseFile);
				print("请输入要删除的文件名称：");
				String fileName_delete = input.next();
				File fileDelete = new File(baseFile.getPath() + "/" + fileName_delete);
				// 调用方法
				if (deleteFile(fileDelete)) {
					print("删除文件成功");
				} else {
					print("删除文件失败");
				}
				break;
			case 4:
				// [4]删除文件夹 何林 → deleteEmptyFloder(File file)
				print("当前所在目录：" + baseFile.getPath());
				listFloderContentName(baseFile);
				print("请输入要删除的文件夹名称：[请删除空文件夹]");
				String folderName_delete = input.next();
				File folderDelete = new File(baseFile.getPath() + File.separator + folderName_delete);
				// 调用方法
				if (deleteEmptyFloder(folderDelete)) {
					print("删除文件夹成功");
				} else {
					print("删除文件夹失败");
				}
				break;
			case 5:
				// [5]删除文件夹里面所有的内容 何林 → deleteFloder(File file)
				print("当前所在目录：" + baseFile.getPath());
				listFloderContentName(baseFile);
				print("请输入要删除的文件夹名称：[请删除非空文件夹]");
				String folderName_deleteAll = input.next();
				File folderDeleteAll = new File(baseFile.getPath() + "/" + folderName_deleteAll);
				// 调用方法
				if (deleteFolder(folderDeleteAll)) {
					print("删除文件夹成功");
				} else {
					print("删除文件夹失败");
				}
				break;
			case 6:
				// [6]复制文件 朱国文 → copyFile(File sourceFile,File targetFile)
				print("当前所在目录：" + baseFile.getPath());
				listFloderContentName(baseFile);
				print("请输入要复制的文件名称：");
				String fileName_copy = input.next();
				File copyFile = new File(baseFile.getPath() + "/" + fileName_copy);
				do {
					print("请输入目标路径：[请在def盘操作]输入格式：d:/xx/xx/xx");
					String targetPath_copy = input.next();
					if (checkPathString(targetPath_copy)) {
						File targetFile_copy = new File(targetPath_copy);
						// 调用方法
						if (copyFile(copyFile, targetFile_copy)) {
							print("复制文件成功");
						} else {
							print("复制文件失败");
						}
						break;
					} else {
						continue;
					}
				} while (true);
				break;
			case 7:
				// [7]复制文件夹的所有内容 朱国文 → copyFloder(File sourceFile,File
				// targetFile)
				print("当前所在目录：" + baseFile.getPath());
				listFloderContentName(baseFile);
				print("请输入要复制的文件夹名称：[请复制非空文件夹]");
				String floderName_copy = input.next();
				File copyfolder = new File(baseFile.getPath() + "/" + floderName_copy);
				do {
					print("请输入目标路径：[请在def盘操作]输入格式：d:/xx/xx/xx");
					String targetPath_copy = input.next();
					if (checkPathString(targetPath_copy)) {
						File targetfolder_copy = new File(targetPath_copy);
						// 调用方法
						if (copyFolder(copyfolder, targetfolder_copy)) {
							print("复制文件夹成功");
						} else {
							print("复制文件夹失败");
						}
						break;
					} else {
						continue;
					}
				} while (true);
				break;
			case 8:
				// [8]移动文件到指定目录 廖端洪 → moveFile(File sourceFile,File targetFile)
				print("当前所在目录：" + baseFile.getPath());
				listFloderContentName(baseFile);
				print("请输入要移动的文件名称：");
				String fileName_move = input.next();
				File moveFile = new File(baseFile.getPath() + "/" + fileName_move);
				do {
					print("请输入目标路径：[请在def盘操作]输入格式：d:/xx/xx/xx");
					String movePath_copy = input.next();
					if (checkPathString(movePath_copy)) {
						File targetfolder_move = new File(movePath_copy);
						if (moveFile(moveFile, targetfolder_move)) {
							print("移动文件夹成功");
						} else {
							print("移动文件夹失败");
						}
						break;
					} else {
						continue;
					}
				} while (true);
				break;
			case 9:
				// [9]移动文件夹到指定目录 廖端洪 → moveFloder(File sourceFile,File
				// targetFile)
				print("当前所在目录：" + baseFile.getPath());
				listFloderContentName(baseFile);
				print("请输入要移动的文件夹名称：[请移动非空文件夹]");
				String folderName_move = input.next();
				File folderFile_move = new File(baseFile.getPath() + "/" + folderName_move);
				do {
					print("请输入目标路径：[请在def盘操作]输入格式：d:/xx/xx/xx");
					String targetPath_move = input.next();
					if (checkPathString(targetPath_move)) {
						File targetFile_move = new File(targetPath_move);
						// 调用方法
						if (moveFolder(folderFile_move, targetFile_move)) {
							print("移动文件夹成功");
						} else {
							print("移动文件夹失败");
						}
						break;
					} else {
						continue;
					}
				} while (true);
				break;
			case 10:
				// [10]列出当前目录下文件名称 刘世华 → listFloderContentName(File file)
				print("当前所在目录：" + baseFile.getPath());
				// 列出当前目录下文件名称
				listFloderContentName(baseFile);
				break;
			case 11:
				// 退出程序
				System.exit(0);
				break;
			default:
				break;
			}
		} while (true);
	}

	// 初始化数据
	public void initData() {
		baseFile = new File("e:/FileDemo"); // 基目录创建位置
		if (!baseFile.exists()) {
			baseFile.mkdirs();
		}

	}

	// 界面方法
	public int viewMethod(String[] str) {
		print(star);
		for (int i = 0; i < str.length; i++) {
			print("\t[" + (i + 1) + "]" + str[i]);
		}
		print(star);
		print("请选择操作序列号：");
		do {
			if (checkInputType()) {
				int choice = input.nextInt();
				if (choice > str.length || choice < 1) {
					print("输入序列号超出，请重新输入");
					continue;
				} else {
					return choice;
				}
			} else {
				print("操作错误，请重新输入操作编号：");
				continue;
			}
		} while (true);
	}

	// [1]新建目录 刘世华 → createNewFloder(File file)
	public boolean createNewFloder(File file) {
		if (file.exists()) {
			return false;
		} else {
			File parent = file.getParentFile();
			// 父目录存在不为空则创建父目录
			if (parent != null) {
				file.mkdirs();
			} else {
				file.mkdir();
			}
			return true;
		}
	}

	// [2]新建文件 刘世华 → createNewFile(File file)
	public boolean createNewFile(File file) {
		if (file.exists()) {
			return false;
		} else {
			try {
				File parent = file.getParentFile();
				if (parent != null) {
					parent.mkdirs();
					file.createNewFile();
				} else {
					file.createNewFile();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			return true;
		}
	}

	// [3]删除文件 何林 → deleteFile(File file)
	public boolean deleteFile(File file) {
		// 路径不存在，或者是目录，返回false
		if (!file.exists() || file.isDirectory()) {
			return false;
		}
		// 删除成功，返回true
		if (file.delete()) {
			return true;
		}
		// 删除失败，返回false
		return false;

	}

	// [4]删除文件夹 何林 → deleteEmptyFloder(File file)
	public boolean deleteEmptyFloder(File file) {
		// 路径不存在，或者是一个文件，或者目录不为空，返回false
		if (!file.exists() || file.isFile() || file.list().length != 0) {
			return false;
		}
		// 删除成功，返回true
		if (file.delete()) {
			return true;
		}
		// 删除失败，返回false
		return false;
	}

	// [5]删除文件夹里面所有的内容 何林 → deleteFloder(File file)
	public boolean deleteFolder(File file) {
		// 路径不存在，或者是一个文件，返回false
		if (!file.exists() || file.isFile()) {
			return false;
		}
		// 目录是空目录，删除，返回true
		if (file.list().length == 0) {
			file.delete();
			return true;
		}
		String[] temp = file.list();
		File fileTemp = null;
		for (int i = 0; i < temp.length; i++) {
			fileTemp = new File(file.getPath() + File.separator + temp[i]);
			// 路径是一个文件
			if (fileTemp.isFile()) {
				// 删除成功，遍历下一个路径
				if (fileTemp.delete()) {
					continue;
				}
				// 删除失败，返回false
				return false;
			}
			// 路径是目录
			if (fileTemp.isDirectory()) {
				// 目录为空
				if (fileTemp.list().length == 0) {
					// 删除成功，遍历下一个路径
					if (fileTemp.delete()) {
						continue;
					}
					// 删除失败，返回false
					return false;
				}
				// 目录不为空，删除成功，遍历下一个路径
				if (deleteFolder(fileTemp)) {
					continue;
				}
				// 删除失败，返回false
				return false;
			}
		}
		// 遍历完成，删除成功
		if (file.delete()) {
			return true;
		}
		return false;
	}

	// [6]复制文件 朱国文 → copyFile(File file)
	// 廖调用
	public boolean copyFile(File sfile, File rfile) {// 复制文件
		boolean ask = false;
		// System.out.println("输入要移动的文件名：");
		File file1 = sfile;
		File file2 = rfile;
		File newName = new File(file2.getPath() + '/' + file1.getName());
		if (file1.exists()) {
			// System.out.println("文件存在！！！");
			String fileName = file1.getName();
			// 判断是否是文本文档
			if (fileName.endsWith(".txt")) {
				try {
					// 是文本文档
					if (!newName.exists()) {
						File parent = file2.getParentFile();
						if (parent != null) {
							parent.mkdirs();
						}
						newName.createNewFile();
						// System.out.println("移动完成！！！");
					} else {
						// 假如存在，同名的文件夹,不影响文件的创建
						/*
						 * 1，列出新的路径下的文件 2.文件名与源文件名相同，则新取名 直到不相同退出循环
						 */
						File[] file = file2.listFiles();
						for (int i = 0; i < file.length; i++) {
							if (file[i].getName().equals(file1.getName())) {
								System.out.println("文件名重名，请输入复制后的名称：");
								String newName1 = input.next();
								// 假如输入的文件名与已有的文件名一样，且同一类型，继续输入新的名称
								newName = new File(file2.getPath() + "/" + newName1 + ".txt");
								newName.createNewFile();
								break;
							}
						}
						newName.createNewFile();
						// System.out.println("移动完成！！！");
					}
					FileReader File1 = new FileReader(file1);
					BufferedReader readerFile = new BufferedReader(File1);
					FileWriter File2 = new FileWriter(newName);
					BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

					BufferedWriter writerFile = new BufferedWriter(File2);
					String file = null;
					while ((file = readerFile.readLine()) != null) {
						writerFile.write(file);
					}
					writerFile.close();
					readerFile.close();
					ask = true;
				} catch (Exception e) {
					e.printStackTrace();
				}
			} else {
				try {
					// 不是文本文档
					if (!newName.exists()) {
						File parent = file2.getParentFile();
						if (parent != null) {
							parent.mkdirs();
						}
						newName.createNewFile();
						// System.out.println("移动完成！！！");
					} else {
						// 假如存在，同名的文件夹,不影响文件的创建
						/*
						 * 1，列出新的路径下的文件 2.文件名与源文件名相同，则新取名 直到不相同退出循环
						 */
						File[] file = file2.listFiles();
						do {
							for (int i = 0; i < file.length; i++) {
								if (file[i].getName().equals(file1)) {
									System.out.println("文件名重名，请输入复制后的名称：");
									String newName1 = input.next();
									// 假如输入的文件名与已有的文件名一样，且同一类型，继续输入新的名称
									newName = new File(file1.getPath() + "/" + newName1);
									newName.createNewFile();
									break;
								}
							}
							newName.createNewFile();
							// System.out.println("移动完成！！！");
						} while (true);
					}
					FileInputStream ioFile = new FileInputStream(file1);
					FileOutputStream outFile = new FileOutputStream(newName);
					byte[] by = new byte[1024 * 5];
					int f = 0;
					while ((f = ioFile.read(by)) != -1) {
						outFile.write(by, 0, f);
					}
					outFile.close();
					ioFile.close();
					ask = true;
				} catch (Exception e) {
					e.printStackTrace();
				}
				ask = true;
			}
		} else {
			// System.out.println("文件不存在，移动失败！！！");
			ask = false;
		}
		return ask;
	}

	// [7]复制文件夹的所有内容 朱国文 → copyFloder(File file)
	public boolean copyFolder(File sourceFolder, File targetFolder) {
		String targetPath = targetFolder.getPath();
		String sourcePath = sourceFolder.getPath();
		try {
			// if (targetFolder.exists()) {
			// System.out.println(new File(targetPath).getName() + "已存在,请重试！");
			// return false;
			// }
			File newFolder1 = new File(targetPath + "/" + sourceFolder.getName()); // 如果文件夹不存在
																					// 则建立新文件夹
			newFolder1.mkdirs();
			targetPath = newFolder1.getPath();
			File a = new File(sourcePath);
			String[] file = a.list();
			File temp = null;
			for (int i = 0; i < file.length; i++) {
				if (sourcePath.endsWith(File.separator)) {
					temp = new File(sourcePath + file[i]);
				} else {
					// 指向路径下的子路径
					temp = new File(sourcePath + File.separator + file[i]);
				}
				if (temp.isFile()) {
					FileInputStream input = new FileInputStream(temp);
					FileOutputStream output = new FileOutputStream(targetPath + "/" + temp.getName());
					byte[] b = new byte[1024 * 5];
					int len;
					while ((len = input.read(b)) != -1) {
						output.write(b, 0, len);
					}
					output.flush();
					output.close();
					input.close();
				}
				if (temp.isDirectory()) {// 如果是子文件夹
					// copyFolder(sourcePath + "/" + file[i], targetPath + "/" +
					// file[i]);
					// 原调用方法copyFile
					copyFolder(new File(sourcePath + "/" + file[i]), newFolder1);
				}
			}
			return true;
		} catch (Exception e) {
			System.out.println("复制整个文件夹内容操作出错");
			System.out.println(sourcePath + "不存在！");
			return false;
		}
	}

	// [8]移动文件到指定目录 廖端洪 → moveFile(File file)
	public boolean moveFile(File filemove, File fileAim) {
		boolean ask = false;
		if (copyFile(filemove, fileAim)) {
			deleteFile(filemove);
			ask = true;
		}
		return ask;
	}

	// [9]移动文件夹到指定目录 廖端洪 → moveFloder(File file)
	public boolean moveFolder(File sfolder, File rfolder) {
		boolean ask = false;
		if (copyFolder_liao(sfolder, rfolder)) {
			File folder = sfolder;
			deleteFolder(folder);
			ask = true;
		}
		return ask;
	}

	// [10]列出当前目录下文件名称 刘世华 → listFloderContentName(File file)
	public void listFloderContentName(File file) {
		if (file.exists()) {
			if (file.isFile()) {
				print("此File是一个文件：" + file.getName());
			}
			if (file.isDirectory()) {
				File[] fileList = file.listFiles();
				for (int i = 0; i < fileList.length; i++) {
					if (fileList[i].isFile()) {
						print("文件：" + fileList[i].getName());
					} else if (fileList[i].isDirectory()) {
						File[] childFileList = fileList[i].listFiles();
						if (childFileList.length > 0) {
							print("文件夹：" + fileList[i].getName() + "[子文件个数：" + childFileList.length + "]");
						} else {
							print("文件夹：" + fileList[i].getName() + "[空]");
						}
					}
				}
			}
		} else {
			System.out.println("文件路径不存在，或文件不存在");
		}
	}

	// [11]退出程序 刘世华 → exit

	public boolean copyFolder_liao(File sfolder, File rfolder) {// 复制文件夹的
		/*
		 * [7]复制文件夹的所有内容 判断是否存在 → [不存在：提示并返回][存在] → 递归遍历[文件 → 复制][文件夹 →
		 * 创建文件夹：递归] → 成功：提示
		 */

		if (!rfolder.exists()) {
			rfolder.mkdirs();
		}
		if (sfolder.isFile()) {

		}
		File folder1 = sfolder;
		File folder2 = new File(rfolder + "/" + folder1.getName());
		folder2.mkdirs();
		File[] folder = folder1.listFiles();
		for (int i = 0; i < folder.length; i++) {
			if (folder[i].isFile()) {
				copyFile(folder[i], folder2);
			} else if (folder[i].isDirectory()) {
				copyFolder_liao(folder[i], folder2);
			}
		}
		return true;
	}

	/**
	 * 判定是否是路径是否非法
	 */
	public boolean checkPathString(String pathString) {
		if (pathString.indexOf('d') == 0 || pathString.indexOf('e') == 0 || pathString.indexOf('f') == 0) {
			if (pathString.indexOf(':') == 1) {
				print("路径正常");
				return true;
			}
		}
		return false;
	}

	// 打印方法—println
	public void print(String str) {
		outPrint.println(str);
	}

	// 判断是否是数字
	public boolean checkInputType() {
		if (input.hasNextInt()) {
			return true;
		} else {
			input.nextLine();
			return false;
		}
	}
}