1.system.out.write 为什么可以将流里的字符在控制台打印出来
2.java中如何实现从客户端发送文件到服务器端?
3.解析System.outoprinlt();输出语句的奥秘
4.javaç½ç»ç¼ç¨ PrintWriter
5.System.out.writeåSystem.out.println
6.javaï¼System.out.println();
system.out.write 为什么可以将流里的字符在控制台打印出来
你可以看下
System.out.print的源码。。也就是PrintStream里面print方法的源码。。
public void print(String s) {
if (s == null) {
s = "null";
}
write(s);
}
就是调用的write方法而已。。报名缴费系统源码
所以你那个System.out.write(i);和System.out.print(i)是一样 的哈
java中如何实现从客户端发送文件到服务器端?
服务器端源码:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/
***
* 文件名:ServerReceive.java
* 实现功能:作为服务器接收客户端发送的文件
*
* 具体实现过程:
* 1、建立SocketServer,等待客户端的连接
* 2、当有客户端连接的时候,按照双方的约定,这时要读取一行数据
* 其中保存客户端要发送的文件名和文件大小信息
* 3、根据文件名在本地创建文件,并建立好流通信
* 4、循环接收数据包,mysql搜索源码将数据包写入文件
* 5、当接收数据的长度等于提前文件发过来的文件长度,即表示文件接收完毕,关闭文件
* 6、文件接收工作结束
public class ServerReceive {
public static void main(String[] args) {
/**与服务器建立连接的通信句柄*/
ServerSocket ss = null;
Socket s = null;
/**定义用于在接收后在本地创建的文件对象和文件输出流对象*/
File file = null;
FileOutputStream fos = null;
/**定义输入流,使用socket的inputStream对数据包进行输入*/
InputStream is = null;
/**定义byte数组来作为数据包的存储数据包*/
byte[] buffer = new byte[ * 5];
/**用来接收文件发送请求的字符串*/
String comm = null;
/**建立socekt通信,等待服务器进行连接*/
try {
ss = new ServerSocket();
s = ss.accept();
} catch (IOException e) {
e.printStackTrace();
}
/**读取一行客户端发送过来的powdvd源码输出约定信息*/
try {
InputStreamReader isr = new InputStreamReader(s.getInputStream());
BufferedReader br = new BufferedReader(isr);
comm = br.readLine();
} catch (IOException e) {
System.out.println("服务器与客户端断开连接");
}
/**开始解析客户端发送过来的请求命令*/
int index = comm.indexOf("/#");
/**判断协议是否为发送文件的协议*/
String xieyi = comm.substring(0, index);
if(!xieyi.equals("")){
System.out.println("服务器收到的协议码不正确");
return;
}
/**解析出文件的名字和大小*/
comm = comm.substring(index + 2);
index = comm.indexOf("/#");
String filename = comm.substring(0, index).trim();
String filesize = comm.substring(index + 2).trim();
/**创建空文件,用来进行接收文件*/
file = new File(filename);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
System.out.println("服务器端创建文件失败");
}
}else{
/**在此也可以询问是否覆盖*/
System.out.println("本路径已存在相同文件,进行覆盖");
}
/**以上就是客户端代码中写到的服务器的准备部分*/
/
*** 服务器接收文件的关键代码*/
try {
/**将文件包装到文件输出流对象中*/
fos = new FileOutputStream(file);
long file_size = Long.parseLong(filesize);
is = s.getInputStream();
/**size为每次接收数据包的长度*/
int size = 0;
/**count用来记录已接收到文件的长度*/
long count = 0;
/**使用while循环接收数据包*/
while(count < file_size){
/**从输入流中读取一个数据包*/
size = is.read(buffer);
/**将刚刚读取的数据包写到本地文件中去*/
fos.write(buffer, 0, size);
fos.flush();
/**将已接收到文件的长度+size*/
count += size;
System.out.println("服务器端接收到数据包,大小为" + size);
}
} catch (FileNotFoundException e) {
System.out.println("服务器写文件失败");
} catch (IOException e) {
System.out.println("服务器:客户端断开连接");
}finally{
/
*** 将打开的文件关闭
* 如有需要,也可以在此关闭socket连接
* */
try {
if(fos != null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ServerReceive
客户端源码:
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
/
***
* 文件名:ClientSend.java
* 实现功能:作为客户端向服务器发送一个文件
*
* 具体实现过程:
* 1、建立与服务器端的连接,IP:.0.0.1, port:
* 2、c 源码 socket将文件的名字和大小通过自定义的文件传输协议,发送到服务器
* 3、循环读取本地文件,将文件打包发送到数据输出流中
* 4、关闭文件,结束传输
*
* */
public class ClientSend {
public static void main(String[] args) {
/**与服务器建立连接的通信句柄*/
Socket s = null;
/**定义文件对象,即为要发送的cf解封源码文件
* 如果使用绝对路径,不要忘记使用'/'和'\'的区别
* 具体区别,请读者自行查询
* */
File sendfile = new File("API.CHM");
/**定义文件输入流,用来打开、读取即将要发送的文件*/
FileInputStream fis = null;
/**定义byte数组来作为数据包的存储数据包*/
byte[] buffer = new byte[ * 5];
/**定义输出流,使用socket的outputStream对数据包进行输出*/
OutputStream os = null;
/**检查要发送的文件是否存在*/
if(!sendfile.exists()){
System.out.println("客户端:要发送的文件不存在");
return;
}
/**与服务器建立连接*/
try {
s = new Socket(".0.0.1", );
}catch (IOException e) {
System.out.println("未连接到服务器");
}
/**用文件对象初始化fis对象
* 以便于可以提取出文件的大小
* */
try {
fis = new FileInputStream(sendfile);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
/**首先先向服务器发送关于文件的信息,以便于服务器进行接收的相关准备工作
* 具体的准备工作,请查看服务器代码。
*
* 发送的内容包括:发送文件协议码(此处为)/#文件名(带后缀名)/#文件大小
* */
try {
PrintStream ps = new PrintStream(s.getOutputStream());
ps.println("/#" + sendfile.getName() + "/#" + fis.available());
ps.flush();
} catch (IOException e) {
System.out.println("服务器连接中断");
}
/
*** 此处睡眠2s,等待服务器把相关的工作准备好
* 也是为了保证网络的延迟
* 读者可自行选择添加此代码
* */
try {
Thread.sleep();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
/**之前的准备工作结束之后
* 下面就是文件传输的关键代码
* */
try {
/**获取socket的OutputStream,以便向其中写入数据包*/
os = s.getOutputStream();
/** size 用来记录每次读取文件的大小*/
int size = 0;
/**使用while循环读取文件,直到文件读取结束*/
while((size = fis.read(buffer)) != -1){
System.out.println("客户端发送数据包,大小为" + size);
/**向输出流中写入刚刚读到的数据包*/
os.write(buffer, 0, size);
/**刷新一下*/
os.flush();
}
} catch (FileNotFoundException e) {
System.out.println("客户端读取文件出错");
} catch (IOException e) {
System.out.println("客户端输出文件出错");
}finally{
/
*** 将打开的文件关闭
* 如有需要,也可以在此关闭socket连接
* */
try {
if(fis != null)
fis.close();
} catch (IOException e) {
System.out.println("客户端文件关闭出错");
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ClientSend
解析System.outoprinlt();输出语句的奥秘
解析System.out.println();输出语句的奥秘
1. 示例代码:
Object a;
System.out.println(a);
该语句调用java.lang.System类的out字段,out是一个PrintStream类型的引用变量。原始代码在java.lang.System中为:
public final static PrintStream out = null;
出是“标准字节输出流”。
2. PrintStream类:
PrintStream是“打印流”,称为“字节输出流”。有另一种打印流,即PrintWriter,称为“字符输出流”。
3. 打印Object:
调用PrintStream类的方法打印Object,并在行末结束。
4. 方法源码:
public void println(Object x)。
解析:
依赖java.lang.Thread类中的public static Thread currentThread()方法。
该方法返回当前正在执行的线程对象引用。
中断线程。
执行流程如图所示。
代码中出现的synchronized (this) {
}
涉及并发编程中的“锁”问题。
javaç½ç»ç¼ç¨ PrintWriter
ç½ç»ç¼ç¨ è¾å ¥è¾åºæµé½ç¨äºè¿å¶æµåï¼å符æµä¼åºé®é¢ï¼åftpçå½ä»¤å·®ä¸éçæ¦å¿µï¼å¦æç¨å符çï¼å¯è½ä¼åºé®é¢ï¼å¦æç¨äºè¿å¶æµè¯å®ä¸ä¼é
System.out.writeåSystem.out.println
System.outçç±»å为PrintStreamï¼
System.out.println('a'); å®é ä¸è°ç¨æ¯PrintStreamçprintln(char c)æ¹æ³ï¼èprintln(char c)æ¹æ³çæºä»£ç 为ï¼
public void println(String x) {
synchronized (this) {
print(x);
newLine();
}
}
å¯è§Printlnè°ç¨äºprint(char c)æ¹æ³ï¼print(char c)æ¹æ³çæºä»£ç å¦ä¸ï¼
public void print(char c) {
write(String.valueOf(c));
}
å¯è§è°ç¨çæ¯write(String s)æ¹æ³ï¼write(String s)ç代ç 为ï¼
private void write(String s) {
try {
synchronized (this) {
ensureOpen();
textOut.write(s);
textOut.flushBuffer();
charOut.flushBuffer();
if (autoFlush && (s.indexOf('\n') >= 0))
out.flush();
}
}
catch (InterruptedIOException x) {
Thread.currentThread().interrupt();
}
catch (IOException x) {
trouble = true;
}
}
å½å符串ä¸å«æ'\n'æ¶ä¼å·æ°outï¼æ¤å¤çoutæ¯OutStream对象çå®ä¾ãprintln(String s)æåè°ç¨newLine() æ¹æ³ï¼newLine()ç代ç å¦ä¸:
private void newLine() {
try {
synchronized (this) {
ensureOpen();
textOut.newLine();
textOut.flushBuffer();
charOut.flushBuffer();
if (autoFlush)
out.flush();
}
}
catch (InterruptedIOException x) {
Thread.currentThread().interrupt();
}
catch (IOException x) {
trouble = true;
}
}
newLine()ä¼å·æ°outã
System.out.write(a); è°ç¨çæ¯PrintStream.write(int b)æ¹æ³
write(int b) çæºä»£ç å¦ä¸ï¼
public void write(int b) {
try {
synchronized (this) {
ensureOpen();
out.write(b);
if ((b == '\n') && autoFlush)
out.flush();
}
}
catch (InterruptedIOException x) {
Thread.currentThread().interrupt();
}
catch (IOException x) {
trouble = true;
}
}
çè¿æºä»£ç ååºè¯¥æç½ä¸¤è ä¹é´çå·®å¼äºï¼println(String s)ä¸ä½ä¼å·æ°outï¼èä¸è¿ä¼åæ¶å·æ°textOutåcharOutï¼èwrite(int b)åªæå½b == '\n'æ¶æå·æ°outãè¿ä¹æ¯ä¸ºä»ä¹å äºSystem.out.write('\n'); åå°±è½æ¾ç¤ºåºæ¥äºï¼é®é¢å°±å¨äºout没æå·æ°ã
楼主ç第äºä¸ªé®é¢å¾å¥½è§£éï¼å 为å¨print(String s)ä¸ï¼ä¼å·æ°textOutåcharOutã
textOutåcharOutæ¯ä»ä¹ï¼çä¸ä¸PrintStreamä¸çå®ä¹ï¼
private BufferedWriter textOut;
private OutputStreamWriter charOut;
textOutåcharOutå¨init(OutputStreamWriter osw)æ¹æ³ä¸åå§åï¼init(OutputStreamWriter osw)ç代ç å¦ä¸ï¼
private void init(OutputStreamWriter osw) {
this.charOut = osw;
this.textOut = new BufferedWriter(osw);
}
init()å½æ°å¨æé å½æ°ä¸è¢«è°ç¨
public PrintStream(OutputStream out, boolean autoFlush) {
this(autoFlush, out);
init(new OutputStreamWriter(this));
}
å¯è§ï¼textOutåcharOutæä½çè¾åºæµåoutæ¯ä¸æ ·çï¼å æ¤å¯¹textOutåcharOutå·æ°åæ¶å·æ°äºoutï¼å æ¤print(String s)å³ä¾¿æ²¡æ'\n'ï¼ä¹åæ ·ä¼ç´æ¥è¾åºåºæ¥ã
javaï¼System.out.println();
outæ¯Systemæä¾çç¨äºæ åè¾åºçæµï¼å¨æ²¡æéå®åçæ åµä¸ï¼ä¼ç´æ¥æå°å°ç»ç«¯ï¼èprintlnè¿ä¸ªæ¹å¼å®é ä¸æ¯PrintStreamç±»æä¾çåè½
éå®åé误è¾åºå¨jdkä¸æä¸æ®µè¯´æï¼
é常ï¼æ¤æµå¯¹åºäºæ¾ç¤ºå¨è¾åºæè ç±ä¸»æºç¯å¢æç¨æ·æå®çå¦ä¸ä¸ªè¾åºç®æ ãæç §æ¯ä¾ï¼æ¤è¾åºæµç¨äºæ¾ç¤ºé误æ¶æ¯ï¼æè æ¾ç¤ºé£äºå³ä½¿ç¨æ·è¾åºæµï¼åé out çå¼ï¼å·²ç»éå®åå°é常ä¸è¢«è¿ç»çè§çæä¸æ件æå ¶ä»ç®æ ï¼ä¹åºè¯¥ç«å»å¼èµ·ç¨æ·æ³¨æçå ¶ä»ä¿¡æ¯ã