黑马程序员java基础网络编程必须掌握的经典代码

----------------------
ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

1.需求：建立一个文本转换服务器。

客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。

而且客户度可以不断的进行文本转换。当客户端输入over时，转换结束。

分析：

客户端：

既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。

源：键盘录入。

目的：网络设备，网络输出流。

而且操作的是文本数据。可以选择字符流。

步骤

1，建立服务。

2，获取键盘录入。

3，将数据发给服务端。

4，后去服务端返回的大写数据。

5，结束，关资源。

都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。

<span style="font-size:18px;">import java.io.*;
import java.net.*;

class  TransClient
{
public static void main(String[] args) throws Exception
{
Socket s = new Socket("192.168.1.254",10005);
//定义读取键盘数据的流对象。
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

//定义目的，将数据写入到socket输出流。发给服务端。
//BufferedWriter bufOut =
//new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);

//定义一个socket读取流，读取服务端返回的大写信息。
BufferedReader bufIn =
new BufferedReader(new InputStreamReader(s.getInputStream()));

String line = null;

while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;

out.println(line);
//			bufOut.write(line);
//			bufOut.newLine();
//			bufOut.flush();

String str =bufIn.readLine();
System.out.println("server:"+str);
}

bufr.close();
s.close();
}
}
/*
服务端：
源：socket读取流。
目的：socket输出流。
都是文本，装饰。
*/
class  TransServer
{
public static void main(String[] args) throws Exception
{
ServerSocket ss = new ServerSocket(10005);

Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");

//读取socket读取流中的数据。
BufferedReader bufIn =
new BufferedReader(new InputStreamReader(s.getInputStream()));

//目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。
//BufferedWriter bufOut =
//new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

PrintWriter out = new PrintWriter(s.getOutputStream(),true);

String line = null;
while((line=bufIn.readLine())!=null)
{
System.out.println(line);

out.println(line.toUpperCase());
//			bufOut.write(line.toUpperCase());
//			bufOut.newLine();
//			bufOut.flush();
}

s.close();
ss.close();
}
}/*
该例子出现的问题。
现象：客户端和服务端都在莫名的等待。
为什么呢？
因为客户端和服务端都有阻塞式方法。这些方法么没有读到结束标记。那么就一直等
而导致两端，都在等待。
*/

2.需求：上传图片。

/*
客户端。
1，服务端点。
2，读取客户端已有的图片数据。
3，通过socket 输出流将数据发给服务端。
4，读取服务端反馈信息。
5，关闭。

*/
import java.io.*;
import java.net.*;
class  PicClient
{
public static void main(String[] args)throws Exception
{
if(args.length!=1)
{
System.out.println("请选择一个jpg格式的图片");
return ;
}

File file = new File(args[0]);
if(!(file.exists() && file.isFile()))
{
System.out.println("该文件有问题，要么补存在，要么不是文件");
return ;

}

if(!file.getName().endsWith(".jpg"))
{
System.out.println("图片格式错误,请重新选择");
return ;
}

if(file.length()>1024*1024*5)
{
System.out.println("文件过大，没安好心");
return ;
}

Socket s = new Socket("192.168.1.254",10007);

FileInputStream fis = new FileInputStream(file);

OutputStream out = s.getOutputStream();

byte[] buf = new byte[1024];

int len = 0;

while((len=fis.read(buf))!=-1)
{
out.write(buf,0,len);
}

//告诉服务端数据已写完
s.shutdownOutput();

InputStream in = s.getInputStream();

byte[] bufIn = new byte[1024];

int num = in.read(bufIn);
System.out.println(new String(bufIn,0,num));

fis.close();
s.close();
}
}

/*
服务端

这个服务端有个局限性。当A客户端连接上以后。被服务端获取到。服务端执行具体流程。
这时B客户端连接，只有等待。
因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法。所以
暂时获取不到B客户端对象。

那么为了可以让多个客户端同时并发访问服务端。
那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。

如何定义线程呢？

只要明确了每一个客户端要在服务端执行的代码即可。将该代码存入run方法中。
*/

class PicThread implements Runnable
{

private Socket s;
PicThread(Socket s)
{
this.s = s;
}
public void run()
{

int count = 1;
String ip  = s.getInetAddress().getHostAddress();
try
{
System.out.println(ip+"....connected");

InputStream in = s.getInputStream();

File dir =  new File("d:\\pic");

File file = new File(dir,ip+"("+(count)+")"+".jpg");

while(file.exists())
file = new File(dir,ip+"("+(count++)+")"+".jpg");

FileOutputStream fos = new FileOutputStream(file);

byte[] buf = new byte[1024];

int len = 0;
while((len=in.read(buf))!=-1)
{
fos.write(buf,0,len);
}

OutputStream out = s.getOutputStream();

out.write("上传成功".getBytes());

fos.close();

s.close();
}
catch (Exception e)
{
throw new RuntimeException(ip+"上传失败");
}
}
}

class  PicServer
{
public static void main(String[] args) throws Exception
{
ServerSocket ss = new ServerSocket(10007);

while(true)
{
Socket s = ss.accept();

new Thread(new PicThread(s)).start();

}

//ss.close();
}
}

3.客户端通过键盘录入用户名。
服务端对这个用户名进行校验。

如果该用户存在，在服务端显示xxx，已登陆。

并在客户端显示 xxx，欢迎光临。

如果该用户存在，在服务端显示xxx，尝试登陆。

并在客户端显示 xxx，该用户不存在。

最多就登录三次。

import java.io.*;
import java.net.*;

class  LoginClient
{
public static void main(String[] args) throws Exception
{
Socket s = new Socket("192.168.1.254",10008);

BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

PrintWriter out = new PrintWriter(s.getOutputStream(),true);

BufferedReader bufIn =
new BufferedReader(new InputStreamReader(s.getInputStream()));

for(int x=0; x<3; x++)
{
String line = bufr.readLine();
if(line==null)
break;
out.println(line);

String info = bufIn.readLine();
System.out.println("info:"+info);
if(info.contains("欢迎"))
break;
}
bufr.close();
s.close();
}
}

class UserThread implements Runnable
{
private Socket s;
UserThread(Socket s)
{
this.s = s;
}
public void run()
{
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
try
{
for(int x=0; x<3; x++)
{
BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));

String name = bufIn.readLine();
if(name==null)
break;

BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));

PrintWriter out = new PrintWriter(s.getOutputStream(),true);

String line = null;

boolean flag = false;

b111
while((line=bufr.readLine())!=null)
{
if(line.equals(name))
{
flag = true;
break;
}
}

if(flag)
{
System.out.println(name+",已登录");
out.println(name+",欢迎光临");
break;
}
else
{
System.out.println(name+",尝试登录");
out.println(name+",用户名不存在");
}
}
s.close();
}
catch (Exception e)
{
throw new RuntimeException(ip+"校验失败");
}
}
}
class  LoginServer
{
public static void main(String[] args) throws Exception
{
ServerSocket ss = new ServerSocket(10008);

while(true)
{
Socket s = ss.accept();

new Thread(new UserThread(s)).start();
}
}
}

4.RandomAccessFile

该类不是算是IO体系中子类。

而是直接继承自Object。

但是它是IO包中成员。因为它具备读和写功能。

内部封装了一个数组，而且通过指针对数组的元素进行操作。

可以通过getFilePointer获取指针位置，

同时可以通过seek改变指针的位置。

其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数可以看出，该类只能操作文件。

而且操作文件还有模式：只读r，，读写rw等。

如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。

如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
//writeFile_2();
//readFile();

//System.out.println(Integer.toBinaryString(258));

}

public static void readFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","r");

//调整对象中指针。
//raf.seek(8*1);

//跳过指定的字节数
raf.skipBytes(8);

byte[] buf = new byte[4];

raf.read(buf);

String name = new String(buf);

int age = raf.readInt();

System.out.println("name="+name);
System.out.println("age="+age);

raf.close();

}

public static void writeFile_2()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.seek(8*0);
raf.write("周期".getBytes());
raf.writeInt(103);

raf.close();
}

public static void writeFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

raf.write("李四".getBytes());
raf.writeInt(97);
raf.write("王五".getBytes());
raf.writeInt(99);

raf.close();
}
}

5.有五个学生，每个学生有3门课的成绩，

从键盘输入以上数据（包括姓名，三门课成绩），

输入的格式：如：zhagnsan，30，40，60计算出总成绩，

并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。

1，描述学生对象。

2，定义一个可操作学生对象的工具类。

思想：

1，通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。

2，因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。
所以可以使用TreeSet。

3，将集合的信息写入到一个文件中。

import java.io.*;
import java.util.*;

class Student implements Comparable<Student>//封装学生对象，并实现Comparable接口
{
private String name;
private int ma,cn,en;
private int sum;

Student(String name,int ma,int cn,int en)//初始化学生对象
{
this.name = name;
this.ma = ma;
this.cn = cn;
this.en = en;
sum = ma + cn + en;
}

public int compareTo(Student s)//实现compareTo方法
{
int num = new Integer(this.sum).compareTo(new Integer(s.sum));
if(num==0)
return this.name.compareTo(s.name);
return num;
}

public String getName()
{
return name;
}
public int getSum()
{
return sum;
}

public int hashCode()//只要用到带有hash的类就需要实现hashCode与equals方法
{
return name.hashCode()+sum*78;

}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s = (Student)obj;

return this.name.equals(s.name) && this.sum==s.sum;
}

public String toString()//改写输出格式
{
return "student["+name+", "+ma+", "+cn+", "+en+"]";
}
}

class StudentInfoTool
{
public static Set<Student> getStudents()throws IOException
{
return getStudents(null);
}

public static Set<Student> getStudents(Comparator<Student> cmp)throws IOException
{
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));//只要想到键盘录入就要想到

String line = null;

Set<Student> stus  = null;
if(cmp==null)                     //判断比较器是否为空
stus = new TreeSet<Student>();
else
stus = new TreeSet<Student>(cmp);
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;

String[] info = line.split(",");  //按照","将学生信息进行分割

Student stu = new Student(info[0],Integer.parseInt(info[1]),
Integer.parseInt(info[2]),
Integer.parseInt(info[3]));

stus.add(stu);
}

bufr.close();

return stus;
}

public static void write2File(Set<Student> stus)throws IOException
{
BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));

for(Student stu : stus)
{
bufw.write(stu.toString()+"\t");
bufw.write(stu.getSum()+"");
bufw.newLine();
bufw.flush();
}

bufw.close();

}
}

class StudentInfoTest
{
public static void main(String[] args) throws IOException
{

Comparator<Student> cmp = Collections.reverseOrder();

Set<Student> stus = StudentInfoTool.getStudents(cmp);

StudentInfoTool.write2File(stus);
}
}

----------------------
ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------