Java - 网络编程基础

最新推荐文章于 2022-03-01 12:05:46 发布
最新推荐文章于 2022-03-01 12:05:46 发布
阅读量200 收藏
点赞数
分类专栏： 网络编程 文章标签： java socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/saienenen/article/details/111242868
版权

1. 网络编程入门

1.1 网络编程概述

  • 计算机网络
    是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系
    统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统

在这里插入图片描述

  • 网络编程
    在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换

1.2 网络编程三要素

  • IP 地址
    要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数
    据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识
  • 端口
    网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区
    分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序
    了。也就是应用程序的标识
  • 协议
    通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定
    的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则
    被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守
    才能完成数据交换。常见的协议有UDP协议和TCP协议

PS：详细的知识不在里描述

1.3 InetAddress 类

InetAddress：此类表示Internet协议（IP）地址

  • 相关方法
方法名说明
static InetAddress getByName(String host)确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
String getHostName()获取此IP地址的主机名
String getHostAddress()返回文本显示中的IP地址字符串
public class InetAddressDemo {
	public static void main(String[] args) throws UnknownHostException {
		//InetAddress address = InetAddress.getByName("itheima");
		InetAddress address = InetAddress.getByName("192.168.1.66");
		//public String getHostName()：获取此IP地址的主机名
		String name = address.getHostName();
		//public String getHostAddress()：返回文本显示中的IP地址字符串
		String ip = address.getHostAddress();
		System.out.println("主机名：" + name);
		System.out.println("IP地址：" + ip);
	}
}

2.UDP 通信程序

2.1 UDP发送数据

  • Java中的UDP通信

    • UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发
      送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念
    • Java提供了DatagramSocket类作为基于UDP协议的Socket

  • 构造方法

方法名说明
DatagramSocket创建数据报套接字并将其绑定到本机地址上的任何可用端口
DatagramPacket(byte[] buf,int len,InetAddress add,int port)创建数据包,发送长度为len的数据包到指定主机的指定端口
  • 相关方法
方法名说明
void send(DatagramPacket p)发送数据报包
void close()关闭数据报套接字
void receive(DatagramPacket p)从此套接字接受数据报包

  • 发送数据的步骤

    • 创建发送端的Socket对象(DatagramSocket)
    • 创建数据，并把数据打包
    • 调用DatagramSocket对象的方法发送数据
    • 关闭发送端

  • 代码演示

public class SendDemo {
	public static void main(String[] args) throws IOException {
		//创建发送端的Socket对象(DatagramSocket)
		// DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
		DatagramSocket ds = new DatagramSocket();
		//创建数据，并把数据打包
		//DatagramPacket(byte[] buf, int length, InetAddress address, int port)
		//构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
		byte[] bys = "hello,udp,我来了".getBytes();
		DatagramPacket dp = new DatagramPacket(bys,bys.length,InetAddress.getByName("192.168.1.66"),10086);
		//调用DatagramSocket对象的方法发送数据
		//void send(DatagramPacket p) 从此套接字发送数据报包
		ds.send(dp);
		//关闭发送端
		//void close() 关闭此数据报套接字
		ds.close();
	}
}

2.2 UDP接收数据

  • 接收数据的步骤

    • 创建接收端的Socket对象(DatagramSocket)
    • 创建一个数据包，用于接收数据
    • 调用DatagramSocket对象的方法接收
    • 解析数据包，并把数据在控制台显示
    • 关闭接收端

  • 构造方法

方法名说明
DatagramPacket(byte[] buf, int len)创建一个DatagramPacket用于接收长度为len的数据包
  • 相关方法
方法名说明
byte[] getData()返回数据缓冲区
int getLength()返回要发送的数据的长度或接收的数据的长度
  • 代码演示
public class ReceiveDemo {
	public static void main(String[] args) throws IOException {
		//创建接收端的Socket对象(DatagramSocket)
		DatagramSocket ds = new DatagramSocket(12345);
		while (true) {
			//创建一个数据包，用于接收数据
			byte[] bys = new byte[1024];
			DatagramPacket dp = new DatagramPacket(bys, bys.length);
			//调用DatagramSocket对象的方法接收数据
			ds.receive(dp);
			//解析数据包，并把数据在控制台显示
			System.out.println("数据是：" + new String(dp.getData(), 0,
			dp.getLength()));
		}
	}
}

2.3 3UDP通信程序练习

  • 案例需求

UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束

UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收

  • 代码实现
/*
    UDP发送数据：
        数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();

        //自己封装键盘录入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = br.readLine()) != null) {
            //输入的数据是886，发送数据结束
            if ("886".equals(line)) {
                break;
            }

            //创建数据，并把数据打包
            byte[] bys = line.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.1.66"), 12345);

            //调用DatagramSocket对象的方法发送数据
            ds.send(dp);
        }

        //关闭发送端
        ds.close();
    }
}

/*
    UDP接收数据：
        因为接收端不知道发送端什么时候停止发送，故采用死循环接收
 */
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);

        while (true) {
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            //调用DatagramSocket对象的方法接收数据
            ds.receive(dp);

            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
        }

        //关闭接收端
//        ds.close();
    }
}

3.TCP 通信

3.1 TCP 发送数据

  • Java中的TCP通信

    • Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过
      Socket产生IO流来进行网络通信。
    • Java为客户端提供了Socket类，为服务器端提供了ServerSocket类

  • 构造方法

方法名说明
Socket(InetAddress address,int port)创建流套接字并将其连接到指定IP指定端口号
Socket(String host, int port)创建流套接字并将其连接到指定主机上的指定端口号
  • 相关方法
方法名说明
InputStream getInputStream()返回此套接字的输入流
OutputStream getOutputStream()返回此套接字的输出流
  • 实例代码
/*
    TCP发送数据的步骤
        1:创建客户端的Socket对象(Socket)
        2:获取输出流，写数据
        3:释放资源
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        //Socket​(InetAddress address, int port) 创建流套接字并将其连接到指定IP地址的指定端口号
//        Socket s = new Socket(InetAddress.getByName("192.168.1.66"),10000);
        //Socket​(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
        Socket s = new Socket("192.168.1.66",10000);

        //获取输出流，写数据
        //OutputStream getOutputStream​() 返回此套接字的输出流
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());

        //释放资源
        s.close();
    }
}

3.2 TCP接收数据

  • 构造方法
方法名说明
ServletSocket(int port)创建绑定到指定端口的服务器套接字
  • 相关方法
方法名说明
Socket accept()监听要连接到此的套接字并接受它
  • 示例代码
/*
    TCP接收数据的步骤
        1:创建服务器端的Socket对象(ServerSocket)
        2:获取输入流，读数据，并把数据显示在控制台
        3:释放资源
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        //ServerSocket​(int port) 创建绑定到指定端口的服务器套接字
        ServerSocket ss = new ServerSocket(10000);

        //Socket accept​() 侦听要连接到此套接字并接受它
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys,0,len);
        System.out.println("数据是：" + data);

        //释放资源
        s.close();
        ss.close();
    }
}

3.3 TCP通信程序练习

  • 案例需求
    客户端：发送数据，接受服务器反馈
    服务器：收到消息后给出反馈

  • 案例分析

    • 客户端创建对象，使用输出流输出数据
    • 服务端创建对象，使用输入流接受数据
    • 服务端使用输出流给出反馈数据
    • 客户端使用输入流接受反馈数据

  • 代码实现

/*
    服务器：接收到的数据在控制台输出
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端的连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //获取输入流
//        InputStream is = s.getInputStream();
//        InputStreamReader isr = new InputStreamReader(is);
//        BufferedReader br = new BufferedReader(isr);
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        //释放资源
        ss.close();
    }
}

/*
    客户端：数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //数据来自于键盘录入，直到输入的数据是886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            if("886".equals(line)) {
                break;
            }

            //获取输出流对象
//            OutputStream os = s.getOutputStream();
//            os.write(line.getBytes());
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        s.close();
    }
}

3.4 TCP通信程序练习

  • 案例需求

客户端：数据来自于键盘录入, 直到输入的数据是886，发送数据结束
服务端：接收到数据在控制台输出

  • 案例分析

    • 客户端创建对象，使用键盘录入循环接受数据，接受一行发送一行，直到键盘录入886为止
    • 服务端创建对象，使用输入流按行循环接受数据，直到接受到null为止

  • 代码实现

/*
    服务器：接收到的数据在控制台输出
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端的连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //获取输入流
//        InputStream is = s.getInputStream();
//        InputStreamReader isr = new InputStreamReader(is);
//        BufferedReader br = new BufferedReader(isr);
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        //释放资源
        ss.close();
    }
}


/*
    客户端：数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //数据来自于键盘录入，直到输入的数据是886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            if("886".equals(line)) {
                break;
            }

            //获取输出流对象
//            OutputStream os = s.getOutputStream();
//            os.write(line.getBytes());
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        s.close();
    }
}

3.5 TCP通信程序练习

  • 案例需求
    客户端：数据来自于键盘录入，直到输入的数据是886,发送数据结束
    服务端：接受到的数据写入文本文件中

  • 案例分析

    • 客户端创建对象，使用键盘录入循环接受数据，接受一行发送一行，直到键盘录入886为止
    • 服务端创建对象，创建输出流对象指向文件，每接受一行数据后使用输出流输出到文件中，直到接受到null为止

  • 代码实现

/*
    服务器：接收到的数据写入文本文件
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\s.txt"));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
        ss.close();
    }
}

/*
    客户端：数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //数据来自于键盘录入，直到输入的数据是886，发送数据结束
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null) {
            if("886".equals(line)) {
                break;
            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        s.close();
    }
}

3.6 TCP通信程序练习

  • 案例需求
    客户端：数据来自于文本文件
    服务器：接收到的数据写入文本文件

  • 案例分析

    • 创建客户端，创建输入流对象指向文件，从文件循环读取数据，每读取一行就使用输出流给服务器输出一行
    • 创建服务端，创建输出流对象指向文件，从客户端接受数据，每接受一行就给文件中输出一行

  • 代码实现

/*
    服务器：接收到的数据写入文本文件
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
        ss.close();
    }
}

/*
    客户端：数据来自于文本文件
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
		
        //释放资源
        br.close();
        s.close();
    }
}

3.7 TCP通信程序练习

  • 案例需求

客户端：数据来自于文本文件，接收服务器反馈
服务器：接收到的数据写入文本文件，给出反馈

  • 案例分析

    • 创建客户端对象，创建输入流对象指向文件，每读入一行数据就给服务器输出一行数据，输出结束后使用shutdownOutput()方法告知服务端传输结束
    • 创建服务器对象，创建输出流对象指向文件，每接受一行数据就使用输出流输出到文件中，传输结束后。使用输出流给客户端反馈信息
    • 客户端接受服务端的回馈信息

  • 相关方法

方法名说明
void shutdownInput()将此套接字的输入流放置在“流的末尾”
void shutdownOutput()禁止用此套接字的输出流
  • 代码实现
/*
    客户端：数据来自于文本文件，接收服务器反馈
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

//        System.out.println(22222);

        //自定义结束标记
//        bw.write("886");
//        bw.newLine();
//        bw.flush();

        //public void shutdownOutput​()
        s.shutdownOutput();

        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine(); //等待读取数据
        System.out.println("服务器的反馈：" + data);

        //释放资源
        br.close();
        s.close();
    }
}

/*
    服务器：接收到的数据写入文本文件，给出反馈
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        //监听客户端连接，返回一个对应的Socket对象
        Socket s = ss.accept();

        //接收数据
        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        //把数据写入文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));

        String line;
        while ((line=br.readLine())!=null) { //等待读取数据
//            if("886".equals(line)) {
//                break;
//            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

//        System.out.println(11111);

        //给出反馈
        BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bwServer.write("文件上传成功");
        bwServer.newLine();
        bwServer.flush();

        //释放资源
        bw.close();
        ss.close();
    }
}

3.8 TCP通信程序练习

  • 案例需求

客户端：数据来自于文本文件，接收服务器反馈
服务器：接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程

  • 案例分析

    • 创建客户端对象，创建输入流对象指向文件，每读入一行数据就给服务器输出一行数据，输出结束后使用shutdownOutput()方法告知服务端传输结束
    • 创建多线程类，在run()方法中读取客户端发送的数据，为了防止文件重名，使用计数器给文件名编号，接受结束后使用输出流给客户端发送反馈信息。
    • 创建服务端对象，每监听到一个客户端则开启一个新的线程接受数据。
    • 客户端接受服务端的回馈信息

  • 代码实现

public class ServerThread implements Runnable {
    private Socket s;

    public ServerThread(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {
        try {
            //接收数据写到文本文件
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//            BufferedWriter bw = new BufferedWriter(new FileWriter("myNet\\Copy.java"));
            //解决名称冲突问题
            int count = 0;
            File file = new File("myNet\\Copy["+count+"].java");
            while (file.exists()) {
                count++;
                file = new File("myNet\\Copy["+count+"].java");
            }
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));

            String line;
            while ((line=br.readLine())!=null) {
                bw.write(line);
                bw.newLine();
                bw.flush();
            }

            //给出反馈
            BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
            bwServer.write("文件上传成功");
            bwServer.newLine();
            bwServer.flush();

            //释放资源
            s.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/*
    服务器：接收到的数据写入文本文件，给出反馈，代码用线程进行封装，为每一个客户端开启一个线程
 */
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //创建服务器Socket对象
        ServerSocket ss = new ServerSocket(10000);

        while (true) {
            //监听客户端连接，返回一个对应的Socket对象
            Socket s = ss.accept();
            //为每一个客户端开启一个线程
            new Thread(new ServerThread(s)).start();
        }

//        ss.close();
    }
}

/*
    客户端：数据来自于文本文件，接收服务器反馈
 */
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //创建客户端Socket对象
        Socket s = new Socket("192.168.1.66",10000);

        //封装文本文件的数据
        BufferedReader br = new BufferedReader(new FileReader("myNet\\InetAddressDemo.java"));
        //封装输出流写数据
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        s.shutdownOutput();

        //接收反馈
        BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String data = brClient.readLine(); //等待读取数据
        System.out.println("服务器的反馈：" + data);

        //释放资源
        br.close();
        s.close();
    }
}
不回头~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础-TCP协议案例
二丫的博客
10-27 215
TCP协议案例 利用我们之前学习的TCP协议，传输字符、文件、通过服务器接收之后显示、保存到文件、给客户端反馈！ 练习1： 客户端：发送消息，接收服务器反馈 服务器：接收数据，给出反馈 练习2： 客户端：数据来源于键盘录入，知道输入的数据是886，发送数据结束 服务器：接收到的诗句在控制台显示 练习3： 客户端：数据来自于键盘录入，知道输入的数据是886，发送结束 服务器：接收到的数据写入文本文件 练习4： 客户端：数据来自于文本文件 服务器
java实现控制台输入用户管理系统
05-11
java实现控制台输入，登录用户管理系统。根据菜单选择自己要做的操作，权限不同操作不同。
Java——IO流
LYQ
06-01 4556
IO流它是一种数据的流从源头流到目的地。比如文件拷贝，输入流和输出流都包括了。输入流从文件中读取数据存储到进程(process)中，输出流从进程中读取数据然后写入到目标文件。
网络编程
HYJ940228的博客
08-15 264
1.网络编程入门 1.1 网络编程概述【理解】 计算机网络 是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统 网络编程 在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换 1.2 网络编程三要素【理解】 IP地址 要想让网络中的计算机能够...
请从控制台反复输入字符串信息，程序将字符串信息存储到文件Info.txt(文件为当前项目工程根目录下的一个文件)中。当用户输入：”886”时，结束输入。通过流资源,读取出文件中内容
m0_60386582的博客
08-12 731
import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.util.Scanner; public class Write{ public static void main(String[] args) throws IOException { Scanner sc = new Scanner(System.in); .
Java-Java网络编程教程
最新发布
11-14
Java网络编程是Java开发中的重要组成部分，它允许Java应用程序通过网络进行通信，实现数据的传输。本教程将针对Java的网络编程进行详细讲解，旨在帮助Java学习者掌握这一核心技术。 一、TCP/IP基础 在Java网络编程...
butte-java-note编程文档
06-14
2. **Java基础**：这部分内容可能包括Java语法、面向对象编程概念、异常处理、集合框架、I/O流、网络编程等基础知识，为初学者提供了一个全面的入门指南。 3. **设计模式**：设计模式是解决常见软件设计问题的经验...
Java网络编程基础用法详解.rar
07-10
1. **Java网络编程基础** - Java网络编程主要依赖于Java的`java.net`和`java.io`包，它们提供了丰富的类和接口来处理网络连接。 - `Socket`和`ServerSocket`是Java网络编程的核心类，分别用于客户端和服务器端通信...
基础深化和提高-网络编程
11-11
Java网络编程是指使用Java编程语言进行网络通信和相关操作的技术。通过Java的网络编程能力，开发人员可以创建客户端-服务器应用程序、实现数据传输、远程调用等功能。 Java的网络编程通常涉及以下几个方面： ...
java网络编程基础
03-19
java网络编程基础 java网络编程基础 java网络编程基础
java 网络编程——day23
飞鸿踏雪泥
10-03 439
找到本机主机名和IP地址package day23;import java.net.InetAddress; import java.net.UnknownHostException; public class IPDemo { public static void main(String[] args) throws UnknownHostException { InetAd
java-网络编程
凌歆的博客
03-01 302
网络编程 1.网络编程的定义 在网络通信协议下，实现网络互联的不同计算机上运行的程序间可以进行数据交换 1.2 网络编程的三要素 IP地址：计算机的标识符 端口：应用程序的标识符 协议：计算机之间连接和通信的规则 1.3 IP地址 ipv4：32bit地址，一般用10进制点表示法，例如：192.168.1.1 ipv6：128bit地址，8组十六进制数组成 1.4 Inet Address类 此类表示Internet协议（IP）地址 相关方法 方法名 说明 s
网络编程（部分）详细
weixin_49125164的博客
08-14 348
网络编程入门 1.1网络编程概述 计算机网络 是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 网络编程 ​ 在网络通信协议下，实现网络互连的同计算机上运行的程序间可以进行数据交换。 网络编程的两个主要问题（实现网络通信的主要问题）： ​ 如何准确地定位网络上一台或多台主机：定位主机的特定的应用 ​ 找到主机后如何高效地进行数据传输 1.2网络编程的三要素 ​ IP地址 ​
UDP传输（三）：数据来自于键盘录入，键盘录入数据要自己控制录入结束。
wangyanming123的博客
05-08 523
UDP传输：数据来自于键盘录入，键盘录入数据要自己控制录入结束。
java模拟用户登录_Java 实现模拟用户登录的示例代码
weixin_42575325的博客
02-13 3974
创建一个用户类类型的集合，手动输入用户库主要是判定输入的用户名和密码是否与库中的匹配做好区别是用户名输入错误还是密码输入错误的提示。定义用户类public class User{String username;String keyword;public User(String username, String keyword) {this.username = username;this.keyw...
JAVA编程题（持续更新中。。。）
Li_CSDN_Li的博客
04-12 1150
for循环练习1 在控制台输出1-5和5-1的数据 public class Demo02Practice { public static void main(String[] args) { //在控制台输出1-5 for (int i = 1; i <= 5; i++) { System.out.println(i); ...
day22【网络编程】下
IT学院
03-23 124
1.网络编程入门 1.1 网络编程概述【理解】 计算机网络 是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统 网络编程 在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换 1.2 网络编程三要素【理解】 IP地址 ...
【黑马程序员】网络编程——Java复习笔记
u014461902的博客
11-21 392
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-网络编程什么是网络编程?用Java语言实现计算机间数据的信息传递和资源共享网络编程的三要素 IP地址:网络中计算机的唯一标识 a:点分十进制 xxx.xxx.xxx.xxx b:IP地址的组成 网络号段+主机号段 :InetAddress类 是个没有构造方法的类 用于获取ip等
JAVA网络编程07---TCPdemo1客户端发送服务端接收并写入txt文件
qq_43064077的博客
10-17 408
回忆一下我们之前学习使用IO流实现键盘录入数据的时候的过程 使用字节输出流的时候 InputStream OutputStream都是抽象类我们要使用他们的具体类 先创建一个字节输出流,参数就是一个文件的地址 FileOutPutStream（String pathname） FileOutPutStream（File file） 或者用 BufferedOutputStream(OutputStream output ) 参数是一个字节输出流，因为OutputStream是一个抽象类我们要使用他的子
Java网络编程基础入门教程
1. **套接字（Socket）编程**：这是Java网络编程的基础，它提供了两台机器间进程通信的能力。Socket类代表了网络上的一个连接点，ServerSocket则用于监听客户端的连接请求。 2. **URL和URLConnection**：Java通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值