Java SE day21_网络编程

最新推荐文章于 2024-04-13 15:17:15 发布
最新推荐文章于 2024-04-13 15:17:15 发布
阅读量209 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45178181/article/details/105504477
版权

Java SE day21_网络编程

如果一个类没有构造方法：

  • A:成员全部是静态的(Math,Arrays,Collections)

  • B:单例设计模式(Runtime)

  • C:类中有静态方法返回该类的对象(InetAddress)

     class Demo {
 private Demo(){}

 	public static Demo getXxx() {
 	return new Demo();
 	}
 }

看InetAddress的成员方法：

  • public static InetAddress getByName(String host):根据主机名或者IP地址的字符串表示得到IP地址对象
package cn.itcast_01;

import java.net.InetAddress;
import java.net.UnknownHostException;

/*
 * 如果一个类没有构造方法：
 * A:成员全部是静态的(Math,Arrays,Collections)
 * B:单例设计模式(Runtime)
 * C:类中有静态方法返回该类的对象(InetAddress)
 * 		class Demo {
 * 			private Demo(){}
 * 
 * 			public static Demo getXxx() {
 * 				return new Demo();
 * 			}
 * 		}
 * 
 * 看InetAddress的成员方法：
 * public static InetAddress getByName(String host):根据主机名或者IP地址的字符串表示得到IP地址对象
 */
public class InetAddressDemo {
	public static void main(String[] args) throws UnknownHostException {
		// public static InetAddress getByName(String host)
		// InetAddress address = InetAddress.getByName("liuyi");
		// InetAddress address = InetAddress.getByName("192.168.12.92");
		InetAddress address = InetAddress.getByName("192.168.12.63");

		// 获取两个东西：主机名，IP地址
		// public String getHostName()
		String name = address.getHostName();
		// public String getHostAddress()
		String ip = address.getHostAddress();
		System.out.println(name + "---" + ip);
	}
}

协议：
通信的规则

UDP：
	把数据打包
	数据有限制
	不建立连接
	速度快
	不可靠

TCP：
	建立连接通道
	数据无限制
	速度慢
	可靠

UDP协议接收数据：

  • A:创建接收端Socket对象
  • B:创建一个数据包(接收容器)
  • C:调用Socket对象的接收方法接收数据
  • D:解析数据包，并显示在控制台
  • E:释放资源

案例（UDP的Socket）

package cn.itcast_02;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
 * UDP协议接收数据：
 * A:创建接收端Socket对象
 * B:创建一个数据包(接收容器)
 * C:调用Socket对象的接收方法接收数据
 * D:解析数据包，并显示在控制台
 * E:释放资源
 */
public class ReceiveDemo {
	public static void main(String[] args) throws IOException {
		// 创建接收端Socket对象
		// DatagramSocket(int port)
		DatagramSocket ds = new DatagramSocket(10086);

		// 创建一个数据包(接收容器)
		// DatagramPacket(byte[] buf, int length)
		byte[] bys = new byte[1024];
		int length = bys.length;
		DatagramPacket dp = new DatagramPacket(bys, length);

		// 调用Socket对象的接收方法接收数据
		// public void receive(DatagramPacket p)
		ds.receive(dp); // 阻塞式

		// 解析数据包，并显示在控制台
		// 获取对方的ip
		// public InetAddress getAddress()
		InetAddress address = dp.getAddress();
		String ip = address.getHostAddress();
		// public byte[] getData():获取数据缓冲区
		// public int getLength():获取数据的实际长度
		byte[] bys2 = dp.getData();
		int len = dp.getLength();
		String s = new String(bys2, 0, len);
		System.out.println(ip + "传递的数据是:" + s);

		// 释放资源
		ds.close();
	}
}
----------------------------------------------------------
package cn.itcast_02;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/*
 * UDP协议发送数据：
 * A:创建发送端Socket对象
 * B:创建数据，并把数据打包
 * C:调用Socket对象的发送方法发送数据包
 * D:释放资源
 */
public class SendDemo {
	public static void main(String[] args) throws IOException {
		// 创建发送端Socket对象
		// DatagramSocket()
		DatagramSocket ds = new DatagramSocket();

		// 创建数据，并把数据打包
		// DatagramPacket(byte[] buf, int length, InetAddress address, int port)
		// 创建数据
		byte[] bys = "hello,udp,我来了".getBytes();
		// 长度
		int length = bys.length;
		// IP地址对象
		InetAddress address = InetAddress.getByName("192.168.12.92");
		// 端口
		int port = 10086;
		DatagramPacket dp = new DatagramPacket(bys, length, address, port);

		// 调用Socket对象的发送方法发送数据包
		// public void send(DatagramPacket p)
		ds.send(dp);

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

案例（键盘输入接受）

package cn.itcast_04;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/*
 * 多次启动接收端：
 * 		java.net.BindException: Address already in use: Cannot bind
 * 		端口被占用。
 */
public class ReceiveDemo {
	public static void main(String[] args) throws IOException {
		// 创建接收端的Socket对象
		DatagramSocket ds = new DatagramSocket(12345);

		while (true) {
			// 创建一个包裹
			byte[] bys = new byte[1024];
			DatagramPacket dp = new DatagramPacket(bys, bys.length);

			// 接收数据
			ds.receive(dp);

			// 解析数据
			String ip = dp.getAddress().getHostAddress();
			String s = new String(dp.getData(), 0, dp.getLength());
			System.out.println("from " + ip + " data is : " + s);
		}

		// 释放资源
		// 接收端应该一直开着等待接收数据，是不需要关闭
		// ds.close();
	}
}
-----------------------------------------------------------
package cn.itcast_04;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
 * 数据来自于键盘录入
 * 键盘录入数据要自己控制录入结束。
 */
public class SendDemo {
	public static void main(String[] args) throws IOException {
		// 创建发送端的Socket对象
		DatagramSocket ds = new DatagramSocket();

		// 封装键盘录入数据
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = null;
		while ((line = br.readLine()) != null) {
			if ("886".equals(line)) {
				break;
			}

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

			// 发送数据
			ds.send(dp);
		}

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

案例（多线程聊天）

package cn.itcast_05;

import java.io.IOException;
import java.net.DatagramSocket;

/*
 * 通过多线程改进刚才的聊天程序，这样我就可以实现在一个窗口发送和接收数据了
 */
public class ChatRoom {
	public static void main(String[] args) throws IOException {
		DatagramSocket dsSend = new DatagramSocket();
		DatagramSocket dsReceive = new DatagramSocket(12306);

		SendThread st = new SendThread(dsSend);
		ReceiveThread rt = new ReceiveThread(dsReceive);

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(rt);

		t1.start();
		t2.start();
	}
}
----------------------------------------
package cn.itcast_05;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class ReceiveThread implements Runnable {
	private DatagramSocket ds;

	public ReceiveThread(DatagramSocket ds) {
		this.ds = ds;
	}

	@Override
	public void run() {
		try {
			while (true) {
				// 创建一个包裹
				byte[] bys = new byte[1024];
				DatagramPacket dp = new DatagramPacket(bys, bys.length);

				// 接收数据
				ds.receive(dp);

				// 解析数据
				String ip = dp.getAddress().getHostAddress();
				String s = new String(dp.getData(), 0, dp.getLength());
				System.out.println("from " + ip + " data is : " + s);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}
---------------------------------------------
package cn.itcast_05;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class SendThread implements Runnable {

	private DatagramSocket ds;

	public SendThread(DatagramSocket ds) {
		this.ds = ds;
	}

	@Override
	public void run() {
		try {
			// 封装键盘录入数据
			BufferedReader br = new BufferedReader(new InputStreamReader(
					System.in));
			String line = null;
			while ((line = br.readLine()) != null) {
				if ("886".equals(line)) {
					break;
				}

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

				// 发送数据
				ds.send(dp);
			}

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

}

TCP连接

  • TCP协议发送数据：
    A:创建发送端的Socket对象
    这一步如果成功，就说明连接已经建立成功了。
    B:获取输出流，写数据
    C:释放资源

  • 连接被拒绝。TCP协议一定要先看服务器。
    java.net.ConnectException: Connection refused: connect

  • TCP协议接收数据：
    A:创建接收端的Socket对象
    B:监听客户端连接。返回一个对应的Socket对象
    C:获取输入流，读取数据显示在控制台
    D:释放资源

package cn.itcast_06;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

/*
 * TCP协议发送数据：
 * A:创建发送端的Socket对象
 * 		这一步如果成功，就说明连接已经建立成功了。
 * B:获取输出流，写数据
 * C:释放资源
 * 
 * 连接被拒绝。TCP协议一定要先看服务器。
 * java.net.ConnectException: Connection refused: connect
 */
public class ClientDemo {
	public static void main(String[] args) throws IOException {
		// 创建发送端的Socket对象
		// Socket(InetAddress address, int port)
		// Socket(String host, int port)
		// Socket s = new Socket(InetAddress.getByName("192.168.12.92"), 8888);
		Socket s = new Socket("192.168.12.92", 8888);

		// 获取输出流，写数据
		// public OutputStream getOutputStream()
		OutputStream os = s.getOutputStream();
		os.write("hello,tcp,我来了".getBytes());

		// 释放资源
		s.close();
	}
}
--------------------------------------------------
package cn.itcast_06;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/*
 * TCP协议接收数据：
 * A:创建接收端的Socket对象
 * B:监听客户端连接。返回一个对应的Socket对象
 * C:获取输入流，读取数据显示在控制台
 * D:释放资源
 */
public class ServerDemo {
	public static void main(String[] args) throws IOException {
		// 创建接收端的Socket对象
		// ServerSocket(int port)
		ServerSocket ss = new ServerSocket(8888);

		// 监听客户端连接。返回一个对应的Socket对象
		// public Socket accept()
		Socket s = ss.accept(); // 侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。

		// 获取输入流，读取数据显示在控制台
		InputStream is = s.getInputStream();

		byte[] bys = new byte[1024];
		int len = is.read(bys); // 阻塞式方法
		String str = new String(bys, 0, len);

		String ip = s.getInetAddress().getHostAddress();

		System.out.println(ip + "---" + str);

		// 释放资源
		s.close();
		// ss.close(); //这个不应该关闭
	}
}

案例（阻塞）

package cn.itcast_07;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class ClientDemo {
	public static void main(String[] args) throws IOException {
		// 创建客户端Socket对象
		Socket s = new Socket("192.168.12.92", 9999);

		// 获取输出流
		OutputStream os = s.getOutputStream();
		os.write("今天天气很好,适合睡觉".getBytes());

		// 获取输入流
		InputStream is = s.getInputStream();
		byte[] bys = new byte[1024];
		int len = is.read(bys);// 阻塞
		String client = new String(bys, 0, len);
		System.out.println("client:" + client);

		// 释放资源
		s.close();
	}
}
-----------------------------------------------------
package cn.itcast_07;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {
	public static void main(String[] args) throws IOException {
		// 创建服务器Socket对象
		ServerSocket ss = new ServerSocket(9999);

		// 监听客户端的连接
		Socket s = ss.accept(); // 阻塞

		// 获取输入流
		InputStream is = s.getInputStream();
		byte[] bys = new byte[1024];
		int len = is.read(bys); // 阻塞
		String server = new String(bys, 0, len);
		System.out.println("server:" + server);

		// 获取输出流
		OutputStream os = s.getOutputStream();
		os.write("数据已经收到".getBytes());

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

案例（键盘录入-输出控制台）

package cn.itcast_08;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

/*
 * 客户端键盘录入，服务器输出到控制台
 */
public class ClientDemo {
	public static void main(String[] args) throws IOException {
		// 创建客户端Socket对象
		Socket s = new Socket("192.168.12.92", 22222);

		// 键盘录入数据
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// 把通道内的流给包装一下
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
				s.getOutputStream()));

		String line = null;
		while ((line = br.readLine()) != null) {
			// 键盘录入数据要自定义结束标记
			if ("886".equals(line)) {
				break;
			}
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		// 释放资源
		// bw.close();
		// br.close();
		s.close();
	}
}
----------------------------------------------------------------
package cn.itcast_08;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {
	public static void main(String[] args) throws IOException {
		// 创建服务器Socket对象
		ServerSocket ss = new ServerSocket(22222);

		// 监听客户端连接
		Socket s = ss.accept();

		// 包装通道内容的流
		BufferedReader br = new BufferedReader(new InputStreamReader(
				s.getInputStream()));
		String line = null;
		while ((line = br.readLine()) != null) {
			System.out.println(line);
		}

		// br.close();
		s.close();
		// ss.close();
	}
}

案例（多线程Scket）

package cn.itcast_13;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadServer {
	public static void main(String[] args) throws IOException {
		// 创建服务器Socket对象
		ServerSocket ss = new ServerSocket(19191);

		// 监听客户端连接
		Socket s = ss.accept();

		// 封装通道内流
		BufferedInputStream bis = new BufferedInputStream(s.getInputStream());
		// 封装图片文件
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("mn.jpg"));

		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = bis.read(bys)) != -1) {
			bos.write(bys, 0, len);
			bos.flush();
		}

		// 给一个反馈
		OutputStream os = s.getOutputStream();
		os.write("图片上传成功".getBytes());

		bos.close();
		s.close();
	}
}
----------------------------------------------------------
package cn.itcast_13;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

public class UploadClient {
	public static void main(String[] args) throws IOException {
		// 创建客户端Socket对象
		Socket s = new Socket("192.168.12.92", 19191);

		// 封装图片文件
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				"林青霞.jpg"));
		// 封装通道内的流
		BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());

		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = bis.read(bys)) != -1) {
			bos.write(bys, 0, len);
			bos.flush();
		}
		
		s.shutdownOutput();

		// 读取反馈
		InputStream is = s.getInputStream();
		byte[] bys2 = new byte[1024];
		int len2 = is.read(bys2);
		String client = new String(bys2, 0, len2);
		System.out.println(client);

		// 释放资源
		bis.close();
		s.close();
	}
}
----------------------------------------------------
package cn.itcast_15;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class UserThread implements Runnable {
	private Socket s;

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

	@Override
	public void run() {
		try {
			// 封装通道内的流
			BufferedReader br = new BufferedReader(new InputStreamReader(
					s.getInputStream()));
			// 封装文本文件
			// BufferedWriter bw = new BufferedWriter(new
			// FileWriter("Copy.java"));

			// 为了防止名称冲突
			String newName = System.currentTimeMillis() + ".java";
			BufferedWriter bw = new BufferedWriter(new FileWriter(newName));

			String line = null;
			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();

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

}
小杜杂谈
关注
专栏目录
搭建一个基于https://www.zuoye.com:22222访问的web网站
qq_54013154的博客
08-10 3368
要求：搭建一个基于https://www.zuoye.com:22222访问的web网站，网站首页在/www/https/,内容为zuoye 好了话不多说我们开始。 前期：在进行这个实验是需要装两个安装包：httpd和mod_ssl. 1、[root@192 ~]# rpm -q httpd（装包详情、挂载等不会敲得小伙伴可以看我上一期的博文。） 2、装mod_ssl的包 [root@192 ~]# cd /etc/yum.repos.d [root@192 yum.repos.d]# yum -y in
210619AA 馒头商学院：快速入门新媒体运营（10个章节）
06-25
210619AA 馒头商学院：快速入门新媒体运营（10个章节）
2222222
hehehahaaeer的博客
03-13 1130
@TOC看看能不能用哈 如何获取积分 据说写博客就可以获得10积分，我来看看是不是这么简单就可以了。 作者：weixin_42269504 来源：CSDN 原文：https://blog.csdn.net/weixin_42269504/article/details/81103957 版权声明：本文为博主原创文章，转载请附上博文链接！ 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢...
Java SE day06_面向对象4
m0_45178181的博客
03-29 174
Java SE 面向对象4抽象类(掌握)(4)抽象类的几个小问题抽象类代码 抽象类(掌握) (1)把多个共性的东西提取到一个类中，这是继承的做法。 但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。 也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。 所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。 而一个没有具体的方法体的方...
Java SE day08_常用对象
m0_45178181的博客
03-31 201
Java SE day08_常用对象Object类(掌握) Object类(掌握) (1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。 (2)Object类的构造方法有一个，并且是无参构造 这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造 (3)要掌握的方法： A:toString() 返回对象的字符串表示，默认是由类的全路径+'@...
Java SE day16_IO流2
m0_45178181的博客
04-08 153
Java SE day16_IO流2递归(理解)递归案例（获取目录中的java文件）案例(删除所有目录文件)IO流(掌握)FileOutputStream 递归(理解) (1)方法定义中调用方法本身的现象 举例：老和尚给小和尚讲故事，我们学编程 (2)递归的注意事项； A:要有出口，否则就是死递归 B:次数不能过多，否则内存溢出 C:构造方法不能递归使用 递归案例（兔子）： package c...
Day19-【Java SE进阶】网络编程
最新发布
没有人的博客
04-13 980
可以让设备中的程序与网络上其他设备中的程序进行数据交互(实现网络通信的)。java.net,*包下提供了网络编程的解决方案!基本的通信架构基本的通信架构有2种形式:CS架构(Client客户端/Server服务端)、BS架构(Browser浏览器/Server服务端)。网络通信的关键三要素IP地址IP(Internet Protocol):全称”互联网协议地址”，是分配给上网设备的唯一标志。IP地址有两种形式:IPV4、IPV6IPv6:共128位，号称可以为地球每一粒沙子编号。
Java-SE自学day01_数据类型
qq_44671988的博客
03-04 1289
这些基本数据类型在 Java 编程中非常基础且重要，它们用于定义变量、数组、方法参数和返回值等。了解它们的取值范围和特性有助于编写高效且正确的代码。Java中有八种基本数据类型，它们分为四大类：整型、浮点型、字符型和布尔型。
Java SE day 24 网络
Zhangxiangyiyi的博客
07-15 364
1.1 协议和七层模型1.2 TCP/IP协议2.1 socket编程2.2 TCP协议通信2.2.1 服务端编程2.2.2 客户端实现2.3 UDP协议通信2.3.1 服务端实现2.3.2 客户端实现
VIP09_JavaSE_JavaIO_File_day0307-1.rar
10-08
Java SE中的Java IO和File类是Java编程中非常重要的部分，尤其对于处理文件和目录的操作。在"VIP09_JavaSE_JavaIO_File_day0307-1.rar"这个压缩包中，我们可以预想它包含的是一个关于Java IO和File类的课程或教程的...
day01_video.zip
01-21
12. **Java SE和Java ME**：Java SE（Standard Edition）是标准版，适用于桌面应用；Java ME（Micro Edition）则针对嵌入式设备和移动设备。 13. **数据库连接**：Java通过JDBC（Java Database Connectivity）API与...
javase_day01
11-06
在JDK1.5之后，这些架构分别被更名为Java SE、Java EE和Java ME。 为了编写和运行Java程序，我们需要安装Java开发工具包（JDK），它包含了JRE（Java Runtime Environment，Java运行时环境）和开发工具。JRE包括JVM...
JAVA_SE_Day03
Anoraker的小屋
01-16 5197
运算符号 算术运算符 +正号 -负号 +加 -减 *乘 /除 %取模(取余) ++自增 --自减 +字符串链接 赋值运算符 =赋值 += -= *= /= %= 比较运算符(关系运算符)返回值为boolean ==相等于 !=不等于 <小于 >大于 <=小于等于 >=大于等于 instanceof(关键字)检查是否是类的对象 “Hello” instanceof String 逻辑运算符 & 与(两个同时满足) ｜或(一个满足即可成立) !非(取反) &amp
【刘打打】day1_学习Java笔记（Java语言概述_环境变量配置）
刘打打的博客
07-28 329
目录 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该
黑马ssm整合mysql数据库
m0_45178181的博客
08-15 627
ssm整合的mysql数据库完整版 关注我，有更多黑马程序员的笔记，干货也会慢慢发出来了哦 关注我不迷路，一起来看看吧. -- 会员 CREATE TABLE member( id VARCHAR(32) PRIMARY KEY, NAME VARCHAR(20), nickname VARCHAR(20), phoneNum VARCHAR(20), email VARCHAR(50) ); CREATE TABLE product
hashmap源码解析
m0_45178181的博客
08-06 373
hashmap源码解析jdk7 ：hashmap jdk7 ：hashmap 1.第一次存入hashmap中 2.采用头插法 头插法代码 源码头插法 3.put是有返回值的，当put是相同的key时，会返回当前被覆盖的value值。（hashmap中是没有的，在linkedhashmap是有的） ...
Java SE day23_JDK8新特性
m0_45178181的博客
04-16 349
JDK8的新特性Lambda表达式的使用案例（lambda的6种情况）案例（java内置的4大核心函数式接口）方法引用的使用案例（方法引用）一、构造器引用案例（构造器和数组引用）Stream案例（Stream方法）测试Stream的中间操作 Lambda表达式的使用 1.举例： (o1,o2) -> Integer.compare(o1,o2); 2.格式： -> :lambd...
Java SE day18_IO流4
m0_45178181的博客
04-12 192
这里写目录标题读写基本数据类型案例（读写基本数据类型）内存操作流：案例（内存操作流）打印流案例（打印文件） 读写基本数据类型 可以读写基本数据类型的数据 数据输入流：DataInputStream DataInputStream(InputStream in) 数据输出流：DataOutputStream DataOutputStream(OutputStream out) 案例（读写...
Java SE Day1：Object类equals与toString深入解析
今日的Java SE第1天学习任务围绕Object类及其常用API展开，主要聚焦于equals方法和toString方法的深入理解。以下是三个练习的详细解析： 1. **练习一：Object类equals方法** String类的equals方法用于比较两个字符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值