Java 程序没有进入while循环？
我正在开发一个连接到服务器并来回对话的程序 服务器最初发送一个Java 程序没有进入while循环？,java,sockets,loops,io,client-server,Java,Sockets,Loops,Io,Client Server,我正在开发一个连接到服务器并来回对话的程序 服务器最初发送一个字符串，然后我发回第一封信服务器发送第二封，我发送第三封，依此类推 谁不发送字符串的最后一个字母，谁就发送“完成！” 我的程序工作到了获取字符串并分解为字符的地步，但似乎不会进入while循环，我不知道为什么 下面是我的代码和我试图通过的测试用例 有人能解释一下为什么我的代码不起作用（我认为这与while循环有关），以及我需要做些什么来修复它吗 我的代码 import java.io.IOException; import java.
字符串import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class Program2 {
static String rec;
public static void goClient(){
try{
String server = "localhost";
int port = 4321;
Socket socket = new Socket(server, port);
InputStream inStream = socket.getInputStream();
OutputStream outStream = socket.getOutputStream();
Scanner scan = new Scanner(inStream);
PrintWriter out = new PrintWriter(outStream);
rec = scan.nextLine();
System.out.println(rec);
char[] array = new char[rec.length()];
for(int i = 0; i < rec.length(); i++){
array[i] = rec.charAt(i);
System.out.println(array[i]);
}
if(array.length % 2 == 0){
while(scan.hasNext()){
for(int x = 0; x < array.length; x+=2){
String str;
str = Character.toString(array[x]);
System.out.print(str);
out.println(str);
str = scan.nextLine();
System.out.print(str);
}
}
}
if(array.length % 2 != 0){
while(scan.hasNext()){
for(int x = 0; x < array.length - 1; x+=2){
String str;
str = Character.toString(array[x]);
System.out.print(str);
out.println(str);
str = scan.nextLine();
System.out.print(str);
}
}
out.println("done!");
}
scan.close();
socket.close();
} catch (IOException e) {}
}
}
import java.io.IOException；
导入java.io.InputStream；
导入java.io.OutputStream；
导入java.io.PrintWriter；
导入java.net.Socket；
导入java.util.Scanner；
公共课程2{
静态字符串记录；
公共静态void goClient（）{
试一试{
String server=“localhost”；
int端口=4321；
套接字=新的套接字（服务器、端口）；
InputStream inStream=socket.getInputStream（）；
OutputStream outStream=socket.getOutputStream（）；
扫描仪扫描=新扫描仪（流内）；
PrintWriter out=新的PrintWriter（分流）；
rec=scan.nextLine（）；
系统输出打印项次（rec）；
char[]数组=新字符[rec.length（）]；
对于（int i=0；iimport static org.junit.Assert.*;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.CountDownLatch;
import org.junit.Before;
import org.junit.Test;
public class Program2Test {
@Before
public void wait2SecondsBeforeEachTest() {
try {
Thread.sleep( 2000 );
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
@Test
public void test0() {
Runnable client = new Runnable() {
@Override
public void run() {
Program2.goClient();
}
};
final CountDownLatch gate = new CountDownLatch( 1 );
Runnable server = new Runnable() {
@Override
public void run() {
ServerSocket server = null;
try {
server = new ServerSocket( 4321 );
Socket client = server.accept();
PrintWriter out = new PrintWriter( client.getOutputStream(), true );
Scanner in = new Scanner ( client.getInputStream() );
out.println( "Lorem" );
String actual = in.nextLine();
assertEquals( "Incorrect result", "L", actual );
out.println( "o" );
actual = in.nextLine();
assertEquals( "Incorrect result", "r", actual );
out.println( "e" );
actual = in.nextLine();
assertEquals( "Incorrect result", "m", actual );
out.println( "done!" );
assertFalse( "Client hasn't closed its socket", in.hasNext() );
client.close();
gate.countDown();
}
catch (IOException e) {
e.printStackTrace();
}
finally {
try {
if (server != null) {
server.close();
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}
};
Thread serverThread = new Thread( server );
serverThread.start();
Thread clientThread = new Thread( client );
clientThread.start();
int count = 0;
while (serverThread.isAlive() && count++ < 300) {
try {
Thread.sleep( 10 );
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
assertTrue( "Client did not arrive or did not finish correctly", gate.getCount() == 0 );
}
@Test
public void test1() {
Runnable client = new Runnable() {
@Override
public void run() {
Program2.goClient();
}
};
final CountDownLatch gate = new CountDownLatch( 1 );
Runnable server = new Runnable() {
@Override
public void run() {
ServerSocket server = null;
try {
server = new ServerSocket( 4321 );
Socket client = server.accept();
PrintWriter out = new PrintWriter( client.getOutputStream(), true );
Scanner in = new Scanner ( client.getInputStream() );
out.println( "Let it be." );
String actual = in.nextLine();
assertEquals( "Incorrect result", "L", actual );
out.println( "e" );
actual = in.nextLine();
assertEquals( "Incorrect result", "t", actual );
out.println( " " );
actual = in.nextLine();
assertEquals( "Incorrect result", "i", actual );
out.println( "t" );
actual = in.nextLine();
assertEquals( "Incorrect result", " ", actual );
out.println( "b" );
actual = in.nextLine();
assertEquals( "Incorrect result", "e", actual );
out.println( "." );
actual = in.nextLine();
assertEquals( "Incorrect result", "done!", actual );
assertFalse( "Client hasn't closed its socket", in.hasNext() );
client.close();
gate.countDown();
}
catch (IOException e) {
e.printStackTrace();
}
finally {
try {
if (server != null) {
server.close();
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}
};
Thread serverThread = new Thread( server );
serverThread.start();
Thread clientThread = new Thread( client );
clientThread.start();
int count = 0;
while (serverThread.isAlive() && count++ < 300) {
try {
Thread.sleep( 10 );
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
assertTrue( "Client did not arrive or did not finish correctly", gate.getCount() == 0 );
}
@Test
public void test2() {
Runnable client = new Runnable() {
@Override
public void run() {
Program2.goClient();
}
};
final CountDownLatch gate = new CountDownLatch( 1 );
Runnable server = new Runnable() {
@Override
public void run() {
ServerSocket server = null;
try {
server = new ServerSocket( 4321 );
Socket client = server.accept();
PrintWriter out = new PrintWriter( client.getOutputStream(), true );
Scanner in = new Scanner ( client.getInputStream() );
out.println( "Upside Down" );
String actual = in.nextLine();
assertEquals( "Incorrect result", "U", actual );
out.println( "p" );
actual = in.nextLine();
assertEquals( "Incorrect result", "s", actual );
out.println( "i" );
actual = in.nextLine();
assertEquals( "Incorrect result", "d", actual );
out.println( "e" );
actual = in.nextLine();
assertEquals( "Incorrect result", " ", actual );
out.println( "D" );
actual = in.nextLine();
assertEquals( "Incorrect result", "o", actual );
out.println( "w" );
actual = in.nextLine();
assertEquals( "Incorrect result", "n", actual );
out.println( "done!" );
assertFalse( "Client hasn't closed its socket", in.hasNext() );
client.close();
gate.countDown();
}
catch (IOException e) {
e.printStackTrace();
}
finally {
try {
if (server != null) {
server.close();
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}
};
Thread serverThread = new Thread( server );
serverThread.start();
Thread clientThread = new Thread( client );
clientThread.start();
int count = 0;
while (serverThread.isAlive() && count++ < 300) {
try {
Thread.sleep( 10 );
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
assertTrue( "Client did not arrive or did not finish correctly", gate.getCount() == 0 );
}
}
import static org.junit.Assert.*；
导入java.io.IOException；
导入java.io.PrintWriter；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.util.Scanner；
导入java.util.concurrent.CountDownLatch；
导入org.junit.Before；
导入org.junit.Test；
公共课程测试{
@以前
public void wait2secondsforeeachtest（）{
试一试{
《睡眠》（2000年）；
}
捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
@试验
公共void test0（）{
Runnable客户端=新的Runnable（）{
@凌驾
公开募捐{
Program2.goClient（）；
}
};
最终倒计时闩锁门=新倒计时闩锁（1）；
Runnable服务器=新的Runnable（）{
@凌驾
公开募捐{
serversocketserver=null；
试一试{
服务器=新服务器套接字（4321）；
Socket client=server.accept（）；
PrintWriter out=新的PrintWriter（client.getOutputStream（），true）；
Scanner in=new Scanner（client.getInputStream（））；
out.println（“Lorem”）；
字符串实际值=in.nextLine（）；
资产质量（“结果不正确”，“L”，实际）；
out.println（“o”）；
实际值=in.nextLine（）；
资产质量（“结果不正确”，“r”，实际）；
out.println（“e”）；
实际值=in.nextLine（）；
资产质量（“结果不正确”，“m”，实际）；
out.println（“完成！”）；
assertFalse（“客户端尚未关闭其套接字”，在.hasNext（）中）；
client.close（）；
门。倒计时（）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
}
最后{
试一试{
如果（服务器！=null）{
server.close（）；
}
}
捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
};
线程服务器线程=新线程（服务器）；
serverThread.start（）；
线程clientThread=新线程（客户端）；
clientThread.start（）；
整数计数=0；
while（serverThread.isAlive（）&&count++<300）{
试一试{
睡眠（10）；
}
捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
assertTrue（“客户端未到达或未正确完成”，gate.getCount（）==0）；
}
@试验
公共void test1（）{
Runnable客户端=新的Runnable（）{
@凌驾
公开募捐{
Program2.goClient（）；
}
};
最终倒计时闩锁门=新倒计时闩锁（1）；
Runnable服务器=新的Runnable（）{
@凌驾
公开募捐{
serversocketserver=null；
试一试{
服务器=新服务器套接字（4321）；
Socket client=server.accept（）；
PrintWriter out=新的PrintWriter（client.getOutputStream（），true）；
Scanner in=new Scanner（client.getInputStream（））；
out.println（“顺其自然”）；
字符串实际值=in.nextLine（）；
资产质量（“结果不正确”，“L”，实际）；
out.println（“e”）；
实际值=in.nextLine（）；
资产质量（“结果不正确”，“t”，实际）；
out.println（“”）；
实际值=in.nextLine（）；
资产质量（“结果不正确”、“i”、实际）；
Lorem
L
o
r
e
m
java.net.BindException: Address already in use: JVM_Bind
at java.net.DualStackPlainSocketImpl.bind0(Native Method)
at java.net.DualStackPlainSocketImpl.socketBind(Unknown Source)
at java.net.AbstractPlainSocketImpl.bind(Unknown Source)
at java.net.PlainSocketImpl.bind(Unknown Source)
at java.net.ServerSocket.bind(Unknown Source)
at java.net.ServerSocket.<init>(Unknown Source)
at java.net.ServerSocket.<init>(Unknown Source)
at Program2Test$4.run(Program2Test.java:112)
at java.lang.Thread.run(Unknown Source)
java.net.BindException: Address already in use: JVM_Bind
at java.net.DualStackPlainSocketImpl.bind0(Native Method)
at java.net.DualStackPlainSocketImpl.socketBind(Unknown Source)
at java.net.AbstractPlainSocketImpl.bind(Unknown Source)
at java.net.PlainSocketImpl.bind(Unknown Source)
at java.net.ServerSocket.bind(Unknown Source)
at java.net.ServerSocket.<init>(Unknown Source)
at java.net.ServerSocket.<init>(Unknown Source)
at Program2Test$6.run(Program2Test.java:199)
at java.lang.Thread.run(Unknown Source)
server = new ServerSocket( 4321 );
Socket socket = new Socket(server, port);