手机版飞鸽传书：无线牵

最新推荐文章于 2025-08-09 14:22:14 发布
原创 最新推荐文章于 2025-08-09 14:22:14 发布 · 209 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Mobile #OS #Nokia #软件测试 #C#

 

 

【中文名】无线牵
【英文名】Wireless Linker
【组成】PC端（PC版）WirelessLinker-PC.jar、Mobile端（手机版）WirelessLinker.jar

 

 

【作者】火种工作室(Tinder Studio)
【邮箱】tinderstudio@163.com

 

 

【使用注意】
1、本软件使用J2ME开发，使用前请确认你的手机支持JSR75；
2、在传输文件给Mobile端时，请注意文件后缀，经本人在Nokia 5800上测试发现一些后缀是禁止传输的，
   所以传输前请先将后缀改为可用的后缀，如jpg,mp3等，然后再进行传输；
3、本软件在基于进行使用的，即手机版的使用是基于WLAN，所以请在使用前确认你的旁边局域网通讯的条件。
4、本软件不具备Nokia对一些特殊功能使用时应有的签名和证书，所以在使用过程会出现一些提示询问
   用户确认，均是Nokia的认证机制所致，不便之处，敬请谅解；
5、因为条件限制，本软件只在Nokia 5800真机上测试过，对于其他手机用户可自行尝试，如果不能使用只要
   卸载即可，不会残留信息。
6、因为本人能力有限，如果在使用过程中遇到异常的情况，希望您能多多提供意见和建议（联系方式请见
   上文），本人在此谢过。

7、有网友反应安装了JDK后运行PC端会出现can not find main class ，program will exit异常，这是因为本

    软件使用JDK1.6版本编译，所以请使用前确认你的JDK版本。

 

【版本】1.0
【功能说明】
1、显示局域网用户IP列表
2、局域网发送接收文件传输并支持文件覆盖
3、文件传输带进度条显示
4、支持PC-PC、PC-Mobile、Moblie-Mobile的文件传输

 

【使用步骤】

1、在电脑上打开PC端，并在手机上打开Mobile端，这时PC端的IP列表如图：

其中192.168.0.100是本机IP，192.168.0.101是Mobile端的IP；

2、点击Mobile端的IP，然后点击发送，会弹出文件选择框，选择你要传送的文件（注意一些后缀可能受限制，建议先改为jpg等图片后缀）

3、这时Mobile端会提示收到PC端的发送文件请求，选择“接收”，这时会弹出目录选择框（会提示是否允许文件访问，一路按是）点击“选择”确认保存文件的路径，程序就开始将文件从PC端传送给Mobile端，传输过程如下：

4、传输完毕后，程序提示如下：

5、从Mobile端传给PC端也类似，先选择相应的IP再点击“发送”按钮选择文件.....。

 

很抱歉，本来应该连同Mobile端的图片一起上传，但可惜我手头刚好没有照相机，手机又无法截图，所以请各位将就着看，希望这个软件能给大家提供一些方便（拿着一条数据线在USB跟手机上拔插真的很不爽，：)）

 

部分源码：

 

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Vector;

import javax.microedition.io.Connector;
import javax.microedition.io.Datagram;
import javax.microedition.io.ServerSocketConnection;
import javax.microedition.io.SocketConnection;
import javax.microedition.io.UDPDatagramConnection;
import javax.microedition.io.file.FileConnection;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.ChoiceGroup;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Gauge;
import javax.microedition.lcdui.Image;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

/**
 * 无线牵
 * @version 1.0
 * 功能:
 * 1、显示局域网用户IP列表
 * 2、支持局域网发送接收文件传输
 * 3、文件传输带进度条显示
 *
 */
public class WirelessLinker extends MIDlet implements CommandListener {
	
	public static final char COMMAND_HI='H';
	public static final char COMMAND_REPLY='R';
	public static final char COMMAND_QUIT='Q';
	public static final char COMMAND_SEND='S';
	public static final char COMMAND_ACCEPT='A';
	public static final char COMMAND_FINISH='F';
	public static final char COMMAND_ERROR='E';
	
	public static final int STATE_NORMAL=0x01;
	public static final int STATE_READY=0x02;
	public static final int STATE_BUSY=0x04;
	
	public static final int PORT=6548;
	
	private Command exitCommand = new Command("退出", Command.EXIT, 2);
	private Command sendCommand = new Command("发送", Command.ITEM, 2);
	private Command aboutCommand=new Command("关于",Command.ITEM,2);
	private Command acceptCommand = new Command("接受", Command.OK, 2);
	private Command rejectCommand = new Command("拒绝", Command.CANCEL, 2);
	private Command okCommand=new Command("确定",Command.OK,1);
	
	private UDPServer udpServer;
	private UDPClient udpClient;
	private TCPServer tcpServer;
	private Form form;
	private ChoiceGroup choiceGroup;
	private FileInfo receivingFileInfo;
	private FileInfo sendingFileInfo;
	private DirectoryChooser directoryChooser;
	private Form aboutForm;

	public WirelessLinker() {
		try {
			udpServer=new UDPServer(){
	
				public void receive(final Datagram dg) {
					if(form!=null)
					{
						String data=new String(dg.getData()).trim();
						final String ip=getIP(dg.getAddress());
						int index=-1;
						switch(data.charAt(0))
						{
						case COMMAND_HI:
							udpClient.sendReply(ip);
						case COMMAND_REPLY:
							if(data.length()==1)
							{
								index=-1;
								for(int i=0;i<choiceGroup.size();i++)
								{
									if(choiceGroup.getString(i).equals(ip))
									{
										index=i;
										break;
									}
								}
								if(index==-1)
								{
									choiceGroup.append(ip,null);
									System.out.println("reply");
								}
							}
							break;
						case COMMAND_QUIT:
							if(data.length()==1)
							{
								index=-1;
								for(int i=0;i<choiceGroup.size();i++)
								{
									if(choiceGroup.getString(i).equals(ip))
									{
										index=i;
										break;
									}
								}
								if(index!=-1)
								{
									choiceGroup.delete(index);
								}
							}
							break;
						case COMMAND_SEND:
							try {
								String info=new String(dg.getData(),"UTF-8");
								index=-1;
								index=info.indexOf('@',2);
								if(index!=-1)
								{
									final String fileName=info.substring(2,index);
									String fileSize=info.substring(index+1,info.length()).trim();
									receivingFileInfo=new FileInfo(fileName,Long.parseLong(fileSize));
									System.out.println(info+","+fileName+","+fileSize);
									
									final Alert alert = new Alert("传输请求", ip+"请求传输文件："+receivingFileInfo.getFileName()+"("+receivingFileInfo.getStringFileSize()+")，是否接受？",null,AlertType.CONFIRMATION);
									alert.addCommand(acceptCommand);
									alert.addCommand(rejectCommand);
									alert.setCommandListener(new CommandListener() {
							            public void commandAction(Command c, Displayable d) {
							                if (c==acceptCommand) {
							                	directoryChooser=new DirectoryChooser(Display.getDisplay(WirelessLinker.this)){

													public void doCancel() {
														alert.setTimeout(1);
														Display.getDisplay(WirelessLinker.this).setCurrent(form);
													}

													public void doSelect(String currentPath) {
														try {
															final FileConnection fc=(FileConnection)Connector.open("file:///"+currentPath+fileName);
															if(fc.exists())
															{
																final Alert alert=new Alert("是否替换","E盘存在同名文件:"+receivingFileInfo.getFileName()+",确定替换文件？",null,AlertType.CONFIRMATION);
																alert.addCommand(acceptCommand);
																alert.addCommand(rejectCommand);
																alert.setCommandListener(new CommandListener() {
																	public void commandAction(Command c, Displayable arg1) {
																		if (c==acceptCommand) {
																			try {
																				fc.delete();
																				fc.create();
																				receivingFileInfo.setFileConnection(fc);
																				System.out.println("accept"+"@"+receivingFileInfo.getFileName()+"@"+receivingFileInfo.getFileSize()+","+ip);
															        			udpClient.send((COMMAND_ACCEPT+"@"+receivingFileInfo.getFileName()+"@"+receivingFileInfo.getFileSize()).getBytes("UTF-8"),ip);
																			} catch (IOException e1) {
																				e1.printStackTrace();
																			}finally{
																				alert.setTimeout(1);
																				Display.getDisplay(WirelessLinker.this).setCurrent(form);
																			}
																			
														                }
																		else if (c==rejectCommand) {
														                	alert.setTimeout(1);
														                	Display.getDisplay(WirelessLinker.this).setCurrent(directoryChooser);
														                }
																	}
																	
																});
																Display.getDisplay(WirelessLinker.this).setCurrent(alert);
															}
															else
															{
																fc.create();
																receivingFileInfo.setFileConnection(fc);
																System.out.println("accept"+"@"+receivingFileInfo.getFileName()+"@"+receivingFileInfo.getFileSize()+","+ip);
											                	try {
											        				udpClient.send((COMMAND_ACCEPT+"@"+receivingFileInfo.getFileName()+"@"+receivingFileInfo.getFileSize()).getBytes("UTF-8"),ip);
											        			} catch (UnsupportedEncodingException e) {
											        				e.printStackTrace();
											        			}
											        			Display.getDisplay(WirelessLinker.this).setCurrent(form);
															}
														} catch (IOException e) {
															e.printStackTrace();
															Display.getDisplay(WirelessLinker.this).setCurrent(form);
														}
														
													}
													
												};
												alert.setTimeout(1);
												Display.getDisplay(WirelessLinker.this).setCurrent(directoryChooser);
							                }
							                if (c==rejectCommand) {
							                	alert.setTimeout(1);
							                	Display.getDisplay(WirelessLinker.this).setCurrent(form);
							                }
							            }
							        });
									Display.getDisplay(WirelessLinker.this).setCurrent(alert,form);
								}
							} catch (UnsupportedEncodingException e) {
								e.printStackTrace();
							}
							break;
						case COMMAND_ACCEPT:
							try {
								String info=new String(dg.getData(),"UTF-8");
								index=-1;
								index=info.indexOf('@',2);
								if(index!=-1)
								{
									System.out.println(info.trim());
									String fileName=info.substring(2,index);
									String fileSize=info.substring(index+1,info.length()).trim();
									FileInfo fileInfo=new FileInfo(fileName,Long.parseLong(fileSize));
									if(fileInfo.equals(sendingFileInfo))
									{
										Alert alert=new Alert("发送文件","文件"+sendingFileInfo.getFileName()+"发送中...",null,AlertType.INFO);
										alert.setIndicator(new Gauge(null,false,100,0));
										alert.setTimeout(Alert.FOREVER);
										Display.getDisplay(WirelessLinker.this).setCurrent(alert);
										
										SocketConnection sc=TCPClient.connect(ip);
										OutputStream os=sc.openOutputStream();
										InputStream is=sendingFileInfo.getFileConnection().openInputStream();
										byte[] buffer = new byte[4096];
										long byteSum=0;
										int byteRead = 0;
										while((byteRead=is.read(buffer))!=-1)
										{
											byteSum+=byteRead;
											if(sendingFileInfo.getFileSize()>0)
												alert.getIndicator().setValue((int)(byteSum*100/sendingFileInfo.getFileSize()));
											else
												alert.getIndicator().setValue(0);
											os.write(buffer,0,byteRead);
										}
										is.close();
										os.close();
										sc.close();
										sendingFileInfo.getFileConnection().close();
										System.out.println("File send finish");
										alert.setIndicator(null);
										alert.setString("文件"+sendingFileInfo.getFileName()+"("+sendingFileInfo.getStringFileSize()+")"+"发送完毕!");
										alert.setTitle("发送完毕");
										alert.setTimeout(1500);
									}
								}
							} catch (UnsupportedEncodingException e) {
								e.printStackTrace();
							} catch (IOException e) {
								e.printStackTrace();
							}
							break;
						}
					}
				}
				
			};
			
			udpClient=new UDPClient();
			udpClient.start();
			
			tcpServer=new TCPServer(){
	
				public void doSocket(final SocketConnection sc) {
					new Thread(){
						public void run() {
							//接收文件
							FileConnection fc=receivingFileInfo.getFileConnection();
							try {
								OutputStream os=fc.openOutputStream();
								InputStream is=sc.openInputStream();
								byte[] buffer=new byte[4096];
								long byteSum=0;
								int byteRead = 0;
								Alert alert=new Alert("接收文件","文件"+receivingFileInfo.getFileName()+"接收中...",null,AlertType.INFO);
								alert.setIndicator(new Gauge(null,false,100,0));
								Display.getDisplay(WirelessLinker.this).setCurrent(alert);
								alert.setTimeout(Alert.FOREVER);
								while((byteRead=is.read(buffer))!=-1)
								{
									byteSum+=byteRead;
									System.out.println("receive:"+byteSum);
									if(receivingFileInfo.getFileSize()>0)
										alert.getIndicator().setValue((int)(byteSum*100/receivingFileInfo.getFileSize()));
									else
										alert.getIndicator().setValue(0);
									os.write(buffer,0,byteRead);
								}
								is.close();
								os.close();
								fc.close();
								sc.close();
								alert.setIndicator(null);
								alert.setString("文件"+receivingFileInfo.getFileName()+"("+receivingFileInfo.getStringFileSize()+")"+"接收完毕!");
								alert.setTitle("接收完毕");
								alert.setTimeout(1500);
							} catch (IOException e) {
								e.printStackTrace();
							}
						}
					}.start();
				}
				
			};
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		choiceGroup=new ChoiceGroup("本机IP:"+udpServer.getLocalAddress(),ChoiceGroup.EXCLUSIVE);
		form = new Form("无线牵1.0");
		form.append(choiceGroup);
		form.addCommand(exitCommand);
		form.addCommand(sendCommand);
		form.addCommand(aboutCommand);
		form.setCommandListener(this);
		Display.getDisplay(this).setCurrent(form);
	}

	protected void destroyApp(boolean arg0){}

	protected void pauseApp() {}

	protected void startApp() throws MIDletStateChangeException {
		udpServer.start();
		tcpServer.start();
		System.out.println("server has start");
		udpClient.sendHi(udpServer.getLocalBroadcastAddress());
		udpClient.sendHi(udpServer.getLocalBroadcastAddress());
	}

	public void commandAction(Command c, Displayable d) {
		if (c == exitCommand) {
			udpClient.sendExit(udpServer.getLocalBroadcastAddress());
			udpClient.sendExit(udpServer.getLocalBroadcastAddress());
			try {
				/*注意此处要sleep否则主线程会占用udpClient的CPU使其无法执行任务*/
				Thread.sleep(500);
				udpClient.close();
				udpClient.join();
				udpServer.close();
				udpServer.join();
				tcpServer.close();
				tcpServer.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		    destroyApp(true);
		    notifyDestroyed();
		} else if (c == sendCommand&&choiceGroup.getSelectedIndex()!=-1) {
			final String ip=choiceGroup.getString(choiceGroup.getSelectedIndex());
			FileChooser fileChooser=new FileChooser(Display.getDisplay(this)){

				public void doCancel() {
					Display.getDisplay(WirelessLinker.this).setCurrent(form);
				}

				public void doSelect(final String currentPath,final String fileName) {
					Display.getDisplay(WirelessLinker.this).setCurrent(form);
					try {
						FileConnection fc=(FileConnection)Connector.open("file:///"+currentPath+fileName);
						long size=fc.fileSize();
						udpClient.send((COMMAND_SEND+"@"+fileName+"@"+size).getBytes("UTF-8"), ip);
						WirelessLinker.this.sendingFileInfo=new FileInfo(fileName,size);
						WirelessLinker.this.sendingFileInfo.setFileConnection(fc);
					} catch (UnsupportedEncodingException e) {
						e.printStackTrace();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}};
			Display.getDisplay(this).setCurrent(fileChooser);
		} else if(c==aboutCommand)
		{
			if(aboutForm==null)
			{
				aboutForm=new Form("关于");
				aboutForm.append("无线牵 v1.0\r\n\r\n");
				try {
					aboutForm.append(Image.createImage(this.getClass().getResourceAsStream("/logo.png")));
				} catch (IOException e) {
					e.printStackTrace();
				}
				aboutForm.append("\r\n\r\n版权所有 侵权必究\r\n");
				aboutForm.addCommand(okCommand);
				aboutForm.setCommandListener(new CommandListener(){

					public void commandAction(Command c, Displayable arg1) {
						if(c==okCommand)
						{
							Display.getDisplay(WirelessLinker.this).setCurrent(form);
						}
					}});
			}
			Display.getDisplay(this).setCurrent(aboutForm);
		}
	}
	
	public static String getIP(String address)
	{
		String ip=null;
		if(address.startsWith("datagram://"))
		{
			ip=address.substring(11);
		}
		int index=ip.lastIndexOf(':');
		if(index>=0)
		{
			ip=ip.substring(0,index);
		}
		return ip;
	}
	
//	public static void log(String message)
//	{
//		try {
//			FileConnection fc=(FileConnection)Connector.open("file:///E:/log.txt");
//			if(fc.exists()==false)
//			{
//				fc.create();
//			}
//			OutputStream os=fc.openOutputStream();
//			
//			byte[] data=(message+"\n").getBytes("UTF-8");
//			os.write(data,0, data.length);
//			os.close();
//			fc.close();
//		} catch (IOException e) {
//			e.printStackTrace();
//		}
//	}

}

abstract class TCPServer extends Thread{
	
	protected ServerSocketConnection scn;
	protected boolean runnable=true;
	
	public TCPServer() throws IOException {
		scn = (ServerSocketConnection) Connector.open("socket://:"+WirelessLinker.PORT);
	}
	
	public void run() {
		while(runnable&&scn!=null)
		{
			try {
				SocketConnection sc = (SocketConnection) scn.acceptAndOpen();
				doSocket(sc);
			} catch (IOException e) {}
		}
	}
	
	public abstract void doSocket(final SocketConnection sc);
	
	public void close()  throws IOException
	{
		if(this.scn!=null)
		{
			this.runnable=false;
			this.scn.close();
		}
		System.out.println("TCPServer close");
	}
	
}

class TCPClient{
	
	public static SocketConnection connect(String ip) throws IOException
	{
		 return (SocketConnection) Connector.open("socket://"+ip+":"+WirelessLinker.PORT);
	}
}

class UDPClient extends Thread{
	
	private UDPDatagramConnection dc;
	private Vector packetQueue;
	private boolean runnable=true;
	
	public UDPClient() throws IOException {
		dc = (UDPDatagramConnection) Connector.open("datagram://localhost:"+WirelessLinker.PORT);
		this.packetQueue=new Vector();
	}
	
	public void run() {
		Packet packet=null;
		while(runnable)
		{
			synchronized (this.packetQueue) {
				while(this.packetQueue.isEmpty())
				{
					System.out.println("PacketQueue is Empty");
					this.packetQueue.notify();
					try {
						this.packetQueue.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					if(runnable==false)
						return;
				}
				packet=(Packet) this.packetQueue.elementAt(0);
				this.packetQueue.removeElementAt(0);
				try {
					send(packet);
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	private void send(Packet packet) throws IOException
	{
		Datagram dg=dc.newDatagram(packet.data,packet.data.length,"datagram://"+packet.ip+":"+WirelessLinker.PORT);
		dc.send(dg);
	}
	
	public void send(byte[] data,String ip)
	{
		synchronized (this.packetQueue) {
			this.packetQueue.addElement(new Packet(ip,data));
			this.packetQueue.notify();
		}
	}
		
	public void sendHi(String ip)
	{
		synchronized (this.packetQueue) {
			this.packetQueue.addElement(new Packet(ip,new byte[]{WirelessLinker.COMMAND_HI}));
			this.packetQueue.notify();
		}
	}
	
	public void sendReply(String ip)
	{
		synchronized (this.packetQueue) {
			this.packetQueue.addElement(new Packet(ip,new byte[]{WirelessLinker.COMMAND_REPLY}));
			this.packetQueue.notify();
		}
	}
	
	public void sendExit(String ip)
	{
		synchronized (this.packetQueue) {
			this.packetQueue.addElement(new Packet(ip,new byte[]{WirelessLinker.COMMAND_QUIT}));
			this.packetQueue.notify();
		}
	}
	
	public void close() throws IOException
	{
		this.runnable=false;
		synchronized (this.packetQueue) {
			this.packetQueue.notify();
		}
		dc.close();
		System.out.println("UDPClient close");
	}
	
	class Packet{
		private String ip;
		private byte[] data;
		
		public Packet(String ip,byte[] data) {
			this.ip=ip;
			this.data=data;
		}
	}
}

abstract class UDPServer extends Thread{
	
	private UDPDatagramConnection dc;
	private boolean runnable=true;
	
	public UDPServer() throws IOException {
		dc = (UDPDatagramConnection) Connector.open("datagram://:6548");
	}
	
	public void run() {
		try {
			while(runnable==true)
			{
				Datagram dg = dc.newDatagram(100);
				dc.receive(dg);
				receive(dg);
			}
		}catch (IOException e) {}
	}
	
	public String getLocalAddress()
	{
		if(dc!=null)
			try {
				return dc.getLocalAddress();
			} catch (IOException e) {
				e.printStackTrace();
			}
		return null;
	}
	
	public String getLocalAddressPrefix()
	{
		String localAddress=getLocalAddress();
		if(localAddress==null)
			return null;
		int index=-1;
		for(int i=localAddress.length()-1;i>0;i--)
		{
			if(localAddress.charAt(i)=='.')
			{
				index=i;
				break;
			}
		}
		if(index==-1)
			return null;
		return localAddress.substring(0,index)+".";
	}
	
	public String getLocalBroadcastAddress()
	{
		return getLocalAddressPrefix()+255;
	}
	
	public int getPort()
	{
		if(dc!=null)
			try {
				return dc.getLocalPort();
			} catch (IOException e) {
				e.printStackTrace();
			}
		return -1;
	}
	
	public void close() throws IOException
	{
		this.runnable=false;
		this.interrupt();
		this.dc.close();
		System.out.println("UDPServer close");
	}
	
	public abstract void receive(Datagram dg);
}
class FileInfo{
	private String fileName;
	private long fileSize;
	private String stringSize;
	private FileConnection fileConnection;
	
	public FileInfo(String fileName,long fileSize) {
		this.fileName=fileName;
		this.fileSize=fileSize;
	}
	
	public String getFileName() {
		return fileName;
	}

	public long getFileSize() {
		return fileSize;
	}

	public void setFileName(String fileName) {
		this.fileName = fileName;
	}

	public void setFileSize(long fileSize) {
		this.fileSize = fileSize;
	}

	public FileConnection getFileConnection() {
		return fileConnection;
	}

	public void setFileConnection(FileConnection fileConnection) {
		this.fileConnection = fileConnection;
	}

	public String getStringFileSize()
	{
		if(this.stringSize==null)
			this.stringSize=getStringSize(fileSize);
		return this.stringSize;
	}
	
	public static String getStringSize(long size)
	{
		String stringSize;
		float fileSize=(float)size;
		if(fileSize>1073741824)
		{
			fileSize/=1073741824;
			stringSize=format(fileSize,2)+"G";
		}
		else
		{
			if(fileSize>1048576)
			{
				fileSize/=1048576;
				stringSize=format(fileSize,2)+"M";
			}
			else
			{
				if(fileSize>1024)
				{
					fileSize/=1024;
					stringSize=format(fileSize,2)+"K";
				}
				else
				{
					stringSize=format(fileSize,2)+"B";
				}
			}
		}
		return stringSize;
	}
	
	/**
	 * 保留小数点后几位,不支持四舍五入
	 * @param number
	 * @param scale
	 * @return
	 */
	public static String format(double number,int scale)
	{
		return format(String.valueOf(number), scale);
	}
	
	/**
	 * 保留小数点后几位,不支持四舍五入
	 * @param number
	 * @param scale
	 * @return
	 */
	public static String format(String number,int scale)
	{
		if(number.startsWith("."))
			number=0+number;
		int index=number.indexOf('.');
		if(index==-1||number.length()-index-1<scale)
		{
			StringBuffer buffer=new StringBuffer();
			if(index==-1)
			{
				buffer.append(".");
			}
			for(int i=number.length()-index-1;i<scale;i++)
			{
				buffer.append("0");
			}
			return number.concat(buffer.toString());
		}
		else
		{
			return number.substring(0,index+scale+1);
		}
	}
	
	public boolean equals(Object obj) {
		if(obj instanceof FileInfo)
		{
			FileInfo info=(FileInfo)obj;
			return fileName.equals(info.fileName)&&fileSize==info.fileSize;
		}
		return false;
	}
}

 

飞鸽传书使用总结
q626779313的专栏
05-05 4303
一、飞鸽传书简介（摘自官网） 飞鸽传书是面向企业、学校、家庭的局域网即时通讯软件，实现局域网内部消息/文件的高速传输、多媒体远程播放和飞鸽网络打印，软件具有即装即用、传输快捷的特点，深受广大用户的喜爱。目前已经覆盖Windows / Mac / Linux / Android / iOS平台，实现各PC、手机、平板、智能电视平台基于网络的互联互通。         快捷方便是软件的最大特点，自
局域网即时通讯软件_无线局域网中，安卓手机和电脑的资源如何实现互传互访？...
weixin_39800387的博客
12-08 930
安卓手机和电脑之间的资源共享，可实现的方案有很多，例如：方案一是各种官方或第三方出品的“XX手机助手”软件。优点是直连的传输速率最高；缺点一是手机和电脑必须连在一起，相当不方便，缺点二是万一中途发生松动等异常，就只有重传；方案二是QQ、微信之类的互联网通讯软件。优点是不需要额外安装软件；缺点一是只适合互传不适合互访，缺点二是如果传输文件量较大，软件必须长时间处于登录状态；方案三是老牌的局域网即时通...
飞鸽传书 linux,飞鸽传书Linux版
weixin_42173205的博客
05-25 1589
飞鸽传书是专业的局域网即时通讯应用，拥有高速传文件、共享打印、文件共享、桌面共享四大功能，飞鸽传书Linux版是专门为Linux系统准备的Qt简捷界面版本，支持文字、文件及文件夹的传输，操作也非常的简单，有需要可以下载来使用。【功能说明】1、局域网通信，通过WiFi网络，即时沟通和高速文件传输；2、多媒体共享，图片、音乐和视频文件远程播放；3、打印共享，飞鸽网络打印机跨平台打印，无需安装和配置各类...
飞鸽传书：局域网文件传输的实用指南
weixin_30205153的博客
11-14 1807
本文还有配套的精品资源，点击获取 简介：在局域网环境下，文件传输工具的高效性和安全性是用户的关键需求。本文深入剖析了"飞鸽传书"这款局域网文件传输软件的优势、功能及应用。其快速传输、简洁易用的界面、安全的点对点传输方式和集成的即时通讯功能让文件共享变得简单。应用场景包括办公协作、教育交流、家庭共享以及数据备份，使飞鸽传书成为提升局域网内文件交互效率的利器。 1. ...
飞鸽传书Windows版下载指南：高效局域网通讯工具
最新发布
weixin_42602368的博客
08-09 265
在当今数字化时代，局域网通讯软件已经成为企业、学校甚至家庭进行即时通讯和文件共享的重要工具。它不仅仅简化了信息的交流，还在一定程度上提升了工作效率和协作的便利性。然而，对于局域网通讯软件的选择和使用，用户往往会面临一系列的问题，比如如何保证传输的文件安全，如何提升批量文件传输的效率，网络打印如何实现和优化等等。为了帮助用户更好地理解和使用这些软件，本章将从局域网通讯软件的基本概念和特点出发，逐渐深入到文件传输、网络打印、加密传输以及群组管理等多个方面，探讨如何发挥这类软件的最大效用。
一个软件网络连接异常_飞鸽传书软件下载-飞鸽传书短信平台下载
weixin_39994270的博客
11-06 488
飞鸽传书是一款非常好用的、操作简单、便捷的互动界面，用户们可以在这里进行最方便的短信通信等，软件中，用户们还可以进行文件的快速的传输使用等，有需要的用户们就来下载吧~ 飞鸽传书介绍： 1、通过WiFi网络进行LAN通信，即时间流量和高速文件传输。 2、远程多媒体共享、图像、音乐和视频文件电影院。 3、使用Feige网络打印机进行跨平台打印的打印共享。 不需要安...
信使iptux_for_linux和飞鸽传书
weixin_42145772的博客
03-12 2454
信使iptux_for_linux和飞鸽传书 　　转载来源：http://blog.sina.com.cn/s/blog_76edd3f90102yzp0.html 　　安卓手机——设置——全部——更多——网络共享与便携式热点——WLAN热点——开启——保持WLAN热点开启——始终——设置WLAN热点——安全性WPA2 PSK——密码xxxxxxxx——勾选显示密码 　　安卓手机——始终打开飞鸽传...
局域网内文件传输速度_跨平台传输文件方案大汇总（中篇）——可能全网最全的传输方案了...
weixin_39754616的博客
12-04 1135
继续上篇第二类：利用已安装的常用软件进行跨平台传输文件， 相信大部分人电脑或者手机都会安装聊天软件类：如QQ、微信、钉钉等 还有就是常用的网盘类软件：百度网盘、天翼云盘等 也有不少人使用奶牛快传，类似于网盘类先上传再分享。 以上软件比较常用就不一一介绍如何使用，下面重点介绍第三类传输方案。第三类：需要安装第三方软件国内常用文件传输软件：1. 闪传官网地址: http://www.shanchuan...
html文件怎么传给手机app,手机向电脑传输文件该用什么app好？2019局域网传输软件推荐...
weixin_27427397的博客
06-24 1154
类型：系统工具大小：24M语言：中文 评分：10.0更新：2019-04-03立即下载有时候我们想把手机上的文件或者照片放在电脑上欣赏或者使用，但是有时候会烦恼没带数据线无法上传到电脑上去，就很难受，但是现在非常方便，只需要手机上下载一个软件，电脑上不需要安装任何插件，就可以快速的无线传输文件和照片了，但是很多软件包含广告和插件，应该怎么选择这些软件比较好呢，下面小编来推荐几个传输app，绝对实用...
新版飞鸽传书手机版：M8专享 文件互传功能
通过以上分析，我们可以了解到，飞鸽传书手机版是一个适用于特定设备（如M8）的文件传输工具，它利用点对点无线技术在手机之间传输文件，并计划在未来增加Wi-Fi网络支持来扩展应用范围。此外，它还具有用户友好的...
手机版飞鸽传书（2）：PC版
01-30
【中文名】无线牵 【英文名】Wireless Linker 【组成】PC端（PC版）WirelessLinker-PC.jar、Mobile端（手机版）WirelessLinker.jar 【作者】火种工作室(Tinder Studio) 【邮箱】tinderstudio@163.com 【使用注意】...
飞鸽传书 手机版 M8 可用的飞鸽传书
03-25
《飞鸽传书：手机版M8的无线文件传输利器》 在移动设备的日常使用中，文件传输是一项不可或缺的功能。而“飞鸽传书”作为一款高效、便捷的文件分享工具，尤其适用于智能手机用户，尤其是那些拥有M8设备的用户。这款...
手机版飞鸽传书（1）：PC端
01-30
【中文名】无线牵 【英文名】Wireless Linker 【组成】PC端（PC版）WirelessLinker-PC.jar、Mobile端（手机版）WirelessLinker.jar 【作者】火种工作室(Tinder Studio) 【邮箱】tinderstudio@163.com 【使用注意】...
JAD中文名字解决方法
babala_234的专栏
01-12 391
最近正好在弄JAD，碰到中文无法显示的问题，之前就碰到过，但没有及时总结出来，此次又得重新研究，还好找到一个比较方便的方法，写个记录备查~！ 对程序生成的jar文件，首先我们最好用混淆器进行混淆，这样可以减少其大小，而且一定程度的保护自己的代码（也不一定要混淆的！可以省略这步）混淆完成后，用rar打开jar文件，找到MANIFEST.MF文件，把它提取出来，用记事本打开，例如：Manifest-V...
3ds max坐标转换成opengl 坐标系
babala_234的专栏
12-09 314
原理不分析了，直接上数据分析 Max: Quat: (quat -0.772327 0.105251 0.0845889 0.620708) OGL: Quat:: -0.772327 , 0.084589 , -0.105251 , 0.620708   Max: Position: [-29.6717,-109.273,7.91964] O...
CLDC/MIDP的基本结构
babala_234的专栏
10-14 313
粗略的说j2me把设备分为两类，一种是联接设备（ connected device），一种是有限联接设备（Connected, Limited Device）。前一种对应于那些有电源的，电力充裕，较大的设备。例如：电视机，冰箱等，后一种对应于主要使用电池，小型的设备，例如：手机，pda等。这里我主要只涉及第二种，有限联接设备（Connected, Limited Device）。sun把J2me的...
J2ME CLDC概述
babala_234的专栏
10-14 238
什么是CLDC       CLDC（Connected Limited Device Configuration，联网的受限设备配置）是用来开发在无线设备上运行的应用程序所要用到的一组最小的 API。CLDC 描述了所有无线移动设备所需的一个最小级别的功能集合。       对于 Java ME 平台，CLDC 为移动电话、双向寻呼机以及类似设备定义了基本配置（Java 语言、虚拟机功能和基本...
J2ME平台PNG图片的压缩与解压缩
babala_234的专栏
12-11 218
在J2ME平台上PNG图片格式几乎成为了标准，无数台手持设备上运行的J2ME程序几乎都选用PNG来显示图像，包括大量的手机游戏以及手机应用，所以对PNG文件格式的了解，可以更有效的减少Jar Size，保护自有知识产权。PNG文件格式：PNG文件格式分为PNG-24和PNG-8，其最大的区别是PNG-24是用24位来保存一个像素值，是真彩色，而PNG-8是用8位索引值来在 调色盘中索引一个颜...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值