A. 关于java socket编程
先运行服务器端类，然后再运行客户端类，就可以了
/**
*服务器端类
*/
public class Server {
public static void main(String[] args) throws IOException{
Server server = new Server();
server.start();
}
public void start() throws IOException{
//ServerSocket 对当前服务器的服务端口的绑定
//这个端口号不能重复绑定，不能同时执行两边
ServerSocket ss = new ServerSocket(8888);
while(true){
//accept 开始等待（IO Block）客户连接（启动监听），如果没有客户端连接，一直挂起等待下去。
//如果有客户端连接，才会继续执行下去，返回的Socket实例s 代表对于客户端连接。
Socket s = ss.accept();
//创建并启动客户服务线程，为客户服务
//当前线程再次返回到accept等待，下一个客户连接
new Service(s).start();//创建线程
}
}
class Service extends Thread{
Socket s;
public Service(Socket s){
this.s = s;
}
public void run(){
try{
//s代表客户端
//s 中的in代表从客户传递过来的流
//s 中的out代表从服务器到客户端传输流
InputStream in = s.getInputStream();
Scanner sc = new Scanner(in);//System.in是操作系统后台
OutputStream out = s.getOutputStream();
//out.write("您好！您需要点啥？\n".getBytes("GBK"));
//out.flush();//清理缓冲，确保发送到客户端
while(true){
String str = sc.nextLine();//IO Block
if(str.equals("连接服务器")){
out.write("连接成功!\n".getBytes("GBK"));
out.flush();
break;
}
}
}catch(IOException e){
e.printStackTrace();
}
}
}
}
/**
*客户端类
*/
public class Client {
public static void main(String[] args) throws IOException{
// new Socket() 连接到指定的服务器端口，当前用的是本机的端口
Socket s = new Socket("localhost", 8888);
//返回s代表连接到了服务器
//s代表对服务器的连接
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
out.write("连接服务器\n".getBytes("gbk"));
out.flush(); //清理缓冲，确保发送到服务端
Scanner sc = new Scanner(in);
String str = sc.nextLine();
System.out.println(str); //把从服务器返回的信息，打印到控制台。
out.flush();
}
}
B. 请问，Java网络编程中像socket以及多线程这些，哪些地方用到现在工作基本都用框架，感觉即使
网络编程的前景很不错的，随着移动互联网的普及与发展，手机应用不回断深入我们生活的方方答面面，移动系统和软件应用的开发领域，成为了未来很具有潜力的行业之一。
在未来5年内，合格软件人才的需求将远大于供给。其中，尤以JAVA、PHP、HTML5与CSS3开发、Asp.net开发人才最为缺乏。
C. java socket编程怎么实现
分为两种模式：TCP和UDP
TCP有客户端（Client）和服务端(Server)的概念，服务端指定一个ip和端口（port）并且监听是否有客户端接入，客户端通过ip+port连接到服务端，通过socket得到输入输出流，他们之间的通信都是通过流（Stream）进行的,一个服务端可以接入多个客户端，客户端之间的通信依赖于服务端的转发。
UDP并没有严格的客户端和服务端的区别，你只需要建立一个socket指定你要发送的目标ip和port就行了，他是以数据包的形式发送数据（DataPacket）,数据包里面存放的是byte[],有需要的话可补充具体实现源码
D. java socket编程 readline()读取问题，为啥在client端刚连接上就开始无限循环，停不下来
改一下
scan.nextLine();//阻塞，排除是socket建立太慢导致的
String str=null;
这两行删除,没用
str=br.readLine();
这个改成
br=scan.readLine();
然后你再试一下
顺便再说一下,这个程序我写过,我开始想的也是客户端发送的数据服务器端可以实时接收,但是我发现我错了,因为Scanner 的阻塞,如果客户端发送消息服务器端必须也得发送一个消息才能收到,这个内容可以是任意内容,比如一个回车,如果想让客户端 或服务器端可以实时接收到消息,在控制台中是不可能实现的,除非使用swing框架,一个文本框负负责发送,一个文本框负责接收,不过听他们说swing现在企业中根本不用了,所有我也就没有深入研究,劝你也放弃吧,研究这个没什么用,除非你能在网页上实现,或者做一个程序,至于我写的源码,如果你要我可以发给你
对了再说下你这个问题出现的原因
你这个是因为循环中没有阻塞语句,而且br没有接收到值,所有它会一直打印null
E. Java需要学习哪些内容
第一：对于Java面向对象概念的理解。学习Java的第一个难点就是如何理解Java的面向对象回编程概念，涉及到类、接答口、多态等概念。在理解这些Java开发概念的过程中，应该从Java面向对象编程过程入手，涉及到类的定义、对象的创建和方法的调用，在这个基础上可以逐渐形成自身的Java编程思想。
第二：对于Java模块化编程的理解。Java是抽象程度比较高的编程语言，所以对于初学者来说，可以先从模式编程入手，然后进一步提升自身对于模块化编程的理解。对于Java程序员来说，模块化编程能力对于自身的Java开发能力有非常直接的影响。另外，在理解Java模块化编程的过程中，也会逐渐提升自身的抽象能力。
第三：Java的开发框架。Java开发与开发框架有非常紧密的联系，初学者可以先从Spring开发框架开始学习，比如从SpringBoot开始学起就是不错的选择。Spring系列框架当前已经非常庞大了，基于Spring也能够完成“一站式”解决方案。Spring框架的学习过程并不复杂，但是需要完成一系列实验。
F. java socket网络编程
//==============Server.java=================//
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) throws IOException {
ServerSocket s = new ServerSocket(12345);
System.out.println("服务器就绪,请启动客户端.");
Socket so = s.accept();
byte[] buff = new byte[1024];
int read = so.getInputStream().read(buff);
String[] abc=new String(buff,0,read).split("\\D+");
int a = Integer.parseInt(abc[0]);
int b = Integer.parseInt(abc[1]);
int c = Integer.parseInt(abc[2]);
if(!cbt(a,b,c))
so.getOutputStream().write("输入的数据无法组成三角形.".getBytes());
else
so.getOutputStream().write(getArea(a,b,c).getBytes());
so.getOutputStream().flush();
so.close();
s.close();
}
private static String getArea(int a, int b, int c) {
float s = (a+b+c)/2f;
return "面积: "+Math.sqrt(s*(s-a)*(s-b)*(s-c));
}
private static boolean cbt(int a, int b, int c) {
return a>0&&b>0&&c>0&&a+b>c&&b+c>a&&a+c>b;
}
}
//=================Client.java======================//
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
System.out.println("输入三角形的三边并用逗号隔开,如: (3,4,5) ");
byte[] buff=new byte[64];
int r = System.in.read(buff);
String ipaddr = "localhost";//根据情况改变,在本机调试就不改了
Socket so = new Socket(ipaddr,12345);
so.getOutputStream().write(new String(buff,0,r).getBytes());
r = so.getInputStream().read(buff);
so.close();
String rs = new String(buff,0,r);
System.out.println(rs);
}
}
//先启动Server,再启动Client
G. Java的Socket编程
要通信首先要建立socket链接。
1 ab客户端与服务端建立socket链接
2 a客户端发送消息到服务端
3 服务端收到消息后，发送到指定的b客户端
4 b客户端处理来自服务端的消息
H. 通过java编程中socket应用,编写一个基于c/s架构的局域网通信软件,
//服务器端
importjava.io.*;
importjava.net.*;
importjava.util.*;
publicclassChatServer{
booleanstarted=false;
ServerSocketss=null;
Socketsocket=null;
List<Client>clients=newArrayList<Client>();
publicstaticvoidmain(String[]args){
newChatServer().start();
}
publicvoidstart(){
try{
ss=newServerSocket(8888);
started=true;
}catch(BindExceptione){
System.out.println("端口使用中。。。。。");
System.out.println("请关掉相关程序，并重新运行服务器！");
System.exit(0);
}catch(IOExceptione){
e.printStackTrace();
}
try{
while(started){
socket=ss.accept();
Clientc=newClient(socket);
newThread(c).start();
clients.add(c);
}
}catch(IOExceptione){
e.printStackTrace();
}
}classClientimplementsRunnable{
privateSocketsocket=null;
privateDataInputStreamdis=null;
privateDataOutputStreamdos=null;
privatebooleanbConnected=false;
publicClient(Socketsocket){
bConnected=true;
this.socket=socket;
try{
dis=newDataInputStream(socket.getInputStream());
dos=newDataOutputStream(socket.getOutputStream());
}catch(IOExceptione){
e.printStackTrace();
}
}
publicvoidsend(Stringstr){
try{
dos.writeUTF(str);
}catch(IOExceptione){
clients.remove(this);
System.out.println("对方退出了，我从List里面去掉了！");
}
}
@Override
publicvoidrun(){
try{
while(bConnected){
Strings=dis.readUTF();
System.out.println(s);
for(inti=0;i<clients.size();i++){
Clientc=clients.get(i);
c.send(s);
}
}
}catch(EOFExceptione){
System.out.println("clientclosed!");
}catch(IOExceptione){
e.printStackTrace();
}finally{
try{
if(dis!=null)dis.close();
if(dos!=null)dos.close();
if(socket!=null)socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}
}
//客户端
importjava.awt.event.*;
importjava.awt.*;
importjava.io.*;
importjava.net.*;
{
TextFieldtfTxt=newTextField();
TextAreataContent=newTextArea();
Socketsocket=null;
DataOutputStreamdos=null;
DataInputStreamdis=null;
booleanbConnected=false;
ThreadtRecv=newThread(newServer());
publicstaticvoidmain(String[]args){
newChatClient().launchFrame();
}
publicvoidlaunchFrame(){
setBounds(400,300,300,300);
setVisible(true);
this.setTitle("ChatClient");
this.add(tfTxt,BorderLayout.SOUTH);
this.add(taContent,BorderLayout.NORTH);
this.pack();
this.addWindowListener(newWindowAdapter(){
@Override
publicvoidwindowClosing(WindowEvente){
disconnect();
setVisible(false);
System.exit(0);
}
});
tfTxt.addActionListener(newTFMonitor());
connect();
tRecv.start();
}
publicvoidconnect(){
try{
socket=newSocket("127.0.0.1",8888);
dos=newDataOutputStream(socket.getOutputStream());
dis=newDataInputStream(this.socket.getInputStream());
System.out.println("Connected!");
bConnected=true;
}catch(UnknownHostExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
}
publicvoiddisconnect(){
try{
dos.close();
dis.close();
socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
/*
try{
bConnected=false;
tRecv.join();
}catch(InterruptedExceptione){
e.printStackTrace();
}finally{
try{
dos.close();
dis.close();
socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
*/
}
{
@Override
publicvoidactionPerformed(ActionEvente){
Stringstr=tfTxt.getText().trim();
//taContent.setText(str);
tfTxt.setText("");
try{
//System.out.println(socket);
dos.writeUTF(str);
dos.flush();
//dos.close();
}catch(IOExceptione1){
e1.printStackTrace();
}
}
}
{
@Override
publicvoidrun(){
try{
while(bConnected){
Strings=dis.readUTF();
//System.out.println(s);
taContent.setText(taContent.getText()+s+' ');
}
}catch(IOExceptione){
System.out.println("talkover,byebye");
//e.printStackTrace();
}
}
}
}
I. java简单的socket框架实现字符串连接,应该怎么做
///简单的Client/Server程序设计
//服务端
import java.io.*;
import java.net.*;
public class Service {
public static void main(String args[]) {
try {
ServerSocket server = null;
try {
server = new ServerSocket(4700);
// 创建一个ServerSocket在端口4700监听客户请求
} catch (Exception e) {
System.out.println("can not listen to:" + e);
// 出错，打印出错信息
}
System.out.println("server------------------------------");
Socket socket = null;
try {
socket = server.accept();
// 使用accept()阻塞等待客户请求，有客户
// 请求到来则产生一个Socket对象，并继续执行
} catch (Exception e) {
System.out.println("Error." + e);
// 出错，打印出错信息
}
String line;
BufferedReader is = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
// 由Socket对象得到输入流，并构造相应的BufferedReader对象
PrintWriter os = new PrintWriter(socket.getOutputStream());
// 由Socket对象得到输出流，并构造PrintWriter对象
BufferedReader sin = new BufferedReader(new InputStreamReader(
System.in));
// 由系统标准输入设备构造BufferedReader对象
System.out.println("Client:" + is.readLine());
// 在标准输出上打印从客户端读入的字符串
line = sin.readLine();
// 从标准输入读入一字符串
while (!line.equals("bye")) {
// 如果该字符串为 "bye"，则停止循环
// 向客户端输出该字符串
os.println(line);
// 刷新输出流，使Client马上收到该字符串
os.flush();
// 从Client读入一字符串，并打印到标准输出上
System.out.println("Client:" + is.readLine()+"\n");
line = sin.readLine();
// 从系统标准输入读入一字符串
} // 继续循环
os.close(); // 关闭Socket输出流
is.close(); // 关闭Socket输入流
socket.close(); // 关闭Socket
server.close(); // 关闭ServerSocket
} catch (Exception e) {
System.out.println("Error:" + e);
// 出错，打印出错信息
}
}
}
//客户端
import java.io.*;
import java.net.*;
public class Client {
public static void main(String args[]) {
try {
Socket socket = new Socket("127.0.0.1",4700);
// 向本机的4700端口发出客户请求
BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
// 由系统标准输入设备构造BufferedReader对象
PrintWriter os = new PrintWriter(socket.getOutputStream());
// 由Socket对象得到输出流，并构造PrintWriter对象
BufferedReader is = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
System.out.println("Client------------------------------");
// 由Socket对象得到输入流，并构造相应的BufferedReader对象
String readline;
readline = sin.readLine(); // 从系统标准输入读入一字符串
while (!readline.equals("bye")) {
// 若从标准输入读入的字符串为 "bye"则停止循环
os.println(readline);
// 将从系统标准输入读入的字符串输出到Server
os.flush();
// 刷新输出流，使Server马上收到该字符串
System.out.println("Server:" + is.readLine());
// 从Server读入一字符串，并打印到标准输出上
readline = sin.readLine(); // 从系统标准输入读入一字符串
} // 继续循环
os.close(); // 关闭Socket输出流
is.close(); // 关闭Socket输入流
socket.close(); //关闭Socket
} catch (Exception e) {
System.out.println("Error" + e); //出错，则打印出错信息
}
}
}
//自己去研究代码 还是挺详细的
希望能够帮助到你，望采纳！