十八十九天笔记总结
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了十八十九天笔记总结相关的知识，希望对你有一定的参考价值。
一：网络编程三要素+UDP协议
1.1
1.网络通信介绍
2.tcp/ip
3.udp/ip
1.2
Socket通信
*网络编程三要素：
ip:
一个计算的标示（找到这个计算机）
端口：
应用程序都会对应一个端口，用来进行通信，有效端口：0~65535，其中0~1024系统使用或保留端口（360查看端口）。
协议：
总共有2种协议（TCP,UDP）
*举例说明：
1.找到刘诗诗(ip)
2.对着刘诗诗的而耳朵说话(端口)
3.协议
1.3
三要素详解：
特殊的IP地址:
127.0.0.1 本地回环地址 用来做一些本地测试
ping IP地址 ; 用来检测本机是否可以和指定的IP地址的计算机可以进行正常通讯
ipconfig 用来查看IP地址
xxx.xxx.xxx.255广播地址
端口号:
物理端口 物理设备对应的端口 , 网卡口
逻辑端口 用来标示我们的计算机上的进程 , 端口号的有效范围应该是 0-65535 ,
其中0-1024被系统占用或者保留
协议:
UDP
把数据打成一个数据包 , 不需要建立连接
数据包的大小有限制不能超过64k
因为无连接,所以属于不可靠协议(可能丢失数据)
因为无连接 ,所以效率高
TCP
需要建立连接,形成连接通道
数据可以使用连接通道直接进行传输,无大小限制
因为有链接,所以属于可靠协议
因为有链接,所以效率低
1.4 （InetAddress）
*
/*
* InetAddress:IP地址的描述类
*
A:InetAddress类的概述
为了方便我们对IP地址的获取和操作，java提供了一个类InetAddress供我们使用
此类表示互联网协议(IP) 地址。
B:InetAddress类的常见功能
publicstatic InetAddress getByName(String host)（ host: 可以是主机名,也可以是IP地址的字符串表现形式）
publicString getHostAddress()返回 IP 地址字符串（以文本表现形式）。
publicString getHostName()获取此 IP 地址的主机名。
C:案例演示: InetAddress类的常见功能
*/
package com.edu_01;
import java.net.InetAddress;
import java.net.UnknownHostException;
/*
* InetAddress:IP地址的描述类
*
A:InetAddress类的概述
为了方便我们对IP地址的获取和操作，java提供了一个类InetAddress供我们使用
此类表示互联网协议(IP) 地址。
B:InetAddress类的常见功能
publicstatic InetAddress getByName(String host)（ host: 可以是主机名,也可以是IP地址的字符串表现形式）
publicString getHostAddress()返回 IP 地址字符串（以文本表现形式）。
publicString getHostName()获取此 IP 地址的主机名。
C:案例演示: InetAddress类的常见功能
*/
public class InetAddressDemo {
publicstatic void main(String[] args) throws Exception {
//通过主机ip获取InetAddress对象
InetAddressaddress = InetAddress.getByName("192.168.20.25");
//publicString getHostAddress()返回 IP 地址字符串（以文本表现形式）。
System.out.println(address.getHostAddress());
//publicString getHostName()获取此 IP 地址的主机名。
System.out.println(address.getHostName());
}
}
1.5（也叫socket编程，套接字编程，网络编程，叫法不一样都是一个东西）
* Socket套接字：（利用qq聊天的案例画图进行讲解）
网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。
Socket原理机制：
通信的两端都有Socket。
网络通信其实就是Socket间的通信。
数据在两个Socket间通过IO传输。
packagecom.edu_02;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/**
*UDP协议特点：
* 1.数据通过打包之后进行发送
* 2.不需要进行连接
* 3.数据大小有限制
* 4.协议属于不安全协议
* 5.效率比较高
*/
public class UdpClient {
publicstatic void main(String[] args) throws Exception {
//1.创建udp协议发送端的socket对象
//publicDatagramSocket() throws SocketException
DatagramSocketds = new DatagramSocket();
byte[]buf = "hello".getBytes();
intlength = buf.length;
InetAddressaddress = InetAddress.getByName("192.168.20.254");
intport = 8888;
//2.创建数据包
//publicDatagramPacket(byte[] buf, int length,InetAddress address,int port)
DatagramPacketdp = new DatagramPacket(buf, length, address, port);
/**
* 1.你要发送的数据
* 2.发送的数据的长度
* 3.你要发送给的电脑ip
* 4.端口
*/
//发送数据
ds.send(dp);
//释放资源
ds.close();
}
}
package com.edu_02;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UdpServer {
publicstatic void main(String[] args) throws Exception {
//创建接收端的socket对象
DatagramSocketds = new DatagramSocket(8888);
//创建一个数据包，用来接收来自发送端的数据,是一个空的数据包
byte[]buf = new byte[1024];
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length);
//接受来自发送端的数据
//publicvoid receive(DatagramPacket p)throws IOException
//程序在这里接收到来自发送端的数据之前一直处于阻塞状态
ds.receive(dp);
//解析一下数据包中的数据
//publicbyte[] getData()返回数据缓冲区
byte[]data = dp.getData();
//publicint getLength()返回将要发送或接收到的数据的长度
intlen = dp.getLength();
System.out.println(newString(data,0,len));
//释放资源
ds.close();
}
}
1.6
分协议进行讲解网络编程
*UDP协议：（写一个标准demo）
特点：1.把数据打包
2.不需要建立连接，也称为面向无连接协议
3.数据需打包，数据大小有限制64k
4.无需建立连接，所以不可靠
5.速度快
UDP通信步骤：
发送端步骤：
/*
* UDP发送数据的步骤:
* A:创建UDP发送数据端Socket对象
* B:创建数据包,并给出数据,把数据打包
* C:通过Socket对象发送数据包
* D:释放资源
*/
接收端步骤：
/*
* UDP协议接收数据步骤：
* A:创建UDP接收数据端Socket对象
* B:创建一个接收数据的数据包
* C:接收数据,数据在数据包中
* D:解析数据包，并把数据显示在控制台
* E:释放资源
*/
1.8 键盘录入数据实现数据的动态发送
package com.edu_03;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
/**
*1.8 键盘录入数据实现数据的动态发送
*
*/
public class UdpClient {
publicstatic void main(String[] args) throws Exception {
//1.创建发送端的socket对象
DatagramSocketds = new DatagramSocket();
InetAddressaddress = InetAddress.getByName("192.168.20.254");
intport = 9999;
//2.创建键盘录入对象
Scannersc = new Scanner(System.in);
Stringline;
while((line=sc.nextLine())!=null) {
//键盘录入的数据line
byte[]buf = line.getBytes();
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length, address, port);
//发送数据包
ds.send(dp);
}
//释放资源
ds.close();
}
}
package com.edu_03;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UdpServer {
publicstatic void main(String[] args) throws Exception {
//创建接收端的socket对象
DatagramSocketds = new DatagramSocket(9999);
//接受来自客户端的数据
while(true) {
//创建数据包
byte[]buf = new byte[1024];
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length);
//接受来自客户端的数据
ds.receive(dp);
//解析数据包中的数据
byte[]data = dp.getData();
intlen = dp.getLength();
System.out.println(newString(data, 0, len));
}
}
}
1.10 多线程实现聊天室（相当于是将发送数据端和接收数据端合并）
package com.edu_04;
import java.net.DatagramSocket;
import java.net.SocketException;
public class ChatRoom {
publicstatic void main(String[] args) throws Exception {
//启动发送线程和接收县城
//启动发送线程
newThread(new UdpCilent(new DatagramSocket())).start();
//启动接收线程
newThread(new UdpServer(new DatagramSocket(9999))).start();
}
}
package com.edu_04;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;
public class UdpCilent implements Runnable{
DatagramSocketds ;
publicUdpCilent(DatagramSocket ds){
this.ds= ds;
}
@Override
publicvoid run() {
try{
InetAddressaddress = InetAddress.getByName("192.168.20.255");
intport = 9999;
//2.创建键盘录入对象
Scannersc = new Scanner(System.in);
Stringline;
while((line=sc.nextLine())!=null) {
//键盘录入的数据line
byte[]buf = line.getBytes();
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length, address, port);
//发送数据包
ds.send(dp);
}
//释放资源
ds.close();
}catch (Exception e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
package com.edu_04;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UdpServer implements Runnable{
DatagramSocketds ;
publicUdpServer(DatagramSocket ds){
this.ds= ds;
}
@Override
publicvoid run() {
try{
//接受来自客户端的数据
while(true) {
//创建数据包
byte[]buf = new byte[1024];
intlength = buf.length;
DatagramPacketdp = new DatagramPacket(buf, length);
//接受来自客户端的数据
ds.receive(dp);
//获取发送信息的人的ip地址
Stringip = dp.getAddress().getHostAddress();
//解析数据包中的数据
byte[]data = dp.getData();
intlen = dp.getLength();
System.out.println(ip+":"+newString(data, 0, len));
}
}catch (Exception e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
二：TCP协议要点
2.1
*TCP协议：（写一个demo）
特点：1.需要建立通道
2.传送大量数据无限制
3.面向连接
4.可靠
5.速度慢
TCp协议书写步骤：
发送端：
/*
* TCP协议发送数据步骤：
* A:创建TCP协议发送端Socket对象
* 指定服务器IP及端口
Socket sk = newSocket("192.168.3.120" , 9527) ;
* B:获取输出流,并写数据
OutputStream outputStream =sk.getOutputStream() ;
outputStream.write("hello,TCP我来了".getBytes());
* C:释放资源
sk.close() ;
*
* java.net.ConnectException: Connectionrefused: connect
* TCP协议是不能直接运行客户端的，必须先运行服务器。因为他是一种可靠的协议。
*/
接收端：
/*
* TCP协议接收数据步骤：
* A:创建TCP协议接收端Socket对象
ServerSocket ss = new ServerSocket(9527) ;
* B:监听客户端连接
Socket sk = ss.accept() ;
* C:获取输入流,并读取数据,显示在控制台
// 读取数据
byte[]bytes = new byte[1024] ;
intlen = inputStream.read(bytes) ;
//public InetAddress getInetAddress()获取IP地址
InetAddressinetAddress = sk.getInetAddress() ;
Stringip = inetAddress.getHostAddress() ;
//输出
System.out.println(ip+ "发来数据是: " + new String(bytes , 0 , len));
* D:释放资源
sk.close() ;
*/
package com.edu_05;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/**
*tcp:
* 1.必须建立链接，这个协议又被称为面向链接协议
* 2.发送数据没有大小限制
* 3.协议比较安全
* 4.效率低
*
* 先运行客户端的时候抛出异常：
*java.net.ConnectException: Connection refused: connect
* 因为服务器端还没有准备好跟你的客户端建立连接呢，你就来了，所以抛出异常，因为tcp
* 协议是面向连接的一个协议
*
*/
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
//创建tcp协议发送端的socket对象
//publicSocket(String host,int port)
Socketsk = new Socket("192.168.20.254", 10086);
//2.publicOutputStream getOutputStream()throws IOException
//从通道中获取输出流对象
OutputStreamos = sk.getOutputStream();
//3.给通道中写数据
os.write("hello".getBytes());
//4.释放资源
sk.close();
}
}
package com.edu_05;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//1.创建服务器端的sokeck对象
//publicServerSocket(int port)throws IOException
ServerSocketss = new ServerSocket(10086);
//2.坚挺来自客户端的连接
//publicSocket accept()throws IOException侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。
Socketsk = ss.accept();
//3.从通道中读取来自客户端的数据
InputStreamis = sk.getInputStream();
//4.读取is
byte[]buf = new byte[1024];
intlen = is.read(buf);
System.out.println(newString(buf, 0, len));
//5.释放资源
sk.close();
}
}
2.2
用TCP协议写一个数据的发送和接收，接收端接收到数据之后给发送端一个反馈
package com.edu_06;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
//创建tcp发送端的sockt对象
Socketsk = new Socket("192.168.20.254", 10000);
//从通道中获取输出流
OutputStreamos = sk.getOutputStream();
//网通道中写数据
os.write("今晚约吗".getBytes());
//接受来自服务器端的反馈
InputStreamis = sk.getInputStream();
//解析is
byte[]buf = new byte[1024];
int len = is.read(buf);
System.out.println(newString(buf, 0, len));
//释放资源
sk.close();
}
}
package com.edu_06;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//创建服务器端的socket对象
ServerSocketss = new ServerSocket(10000);
//监听来自客户端的连接
Socketsk = ss.accept();
//从通道中获取输入流读取数据
InputStreamis = sk.getInputStream();
//解析is
byte[]buf = new byte[1024];
intlen = is.read(buf);
System.out.println(newString(buf, 0, len));
//给客户端一个反馈
OutputStreamos = sk.getOutputStream();
os.write("不约".getBytes());
//释放资源
sk.close();
}
}
2.4
需求: 客户端键盘录入数据,服务器端接收数据在控制台输出
package com.edu_07;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
/**
* 2.4
需求: 客户端键盘录入数据,服务器端接收数据在控制台输出
*
*/
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
//创建tcp发送端socket对象
Socketsk = new Socket("192.168.20.254", 20000);
//创建键盘录入对象
Scannersc = new Scanner(System.in);
Stringline;
while((line=sc.nextLine())!=null) {
//将line这个数据写如通道
OutputStreamos = sk.getOutputStream();
os.write(line.getBytes());
}
sk.close();
}
}
package com.edu_07;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//创建服务器端的socket对象
ServerSocketss = new ServerSocket(20000);
//监听来自客户端的连接
Socketsk = ss.accept();
while(true) {
InputStreamis = sk.getInputStream();
byte[]buf = new byte[1024];
intlen = is.read(buf);
System.out.println(newString(buf, 0, len));
}
}
}
2.5
需求：客户端键盘录入数据，服务端将数据写入文件
package com.edu_08;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
/**
* 2.5
需求：客户端键盘录入数据，服务端将数据写入文件
客户端
一次写一行
服务端：
一次读取一行，将读取到的内容写入文件
*/
//创建tcp客户端socket对象
Socketsk = new Socket("192.168.20.254", 10010);
BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));
//创建键盘录入对象
Scannersc = new Scanner(System.in);
Stringline;
while((line=sc.nextLine())!=null) {
//往通道中写数据，一次写一行
bw.write(line);
bw.newLine();
bw.flush();
}
sk.close();
}
}
package com.edu_08;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//创建服务器端的socket对象
ServerSocketss = new ServerSocket(10010);
//监听客户端连接
Socketsk = ss.accept();
//从sk的通道中读取数据，一次读取一行
BufferedReaderbr = new BufferedReader(new InputStreamReader(sk.getInputStream()));
BufferedWriterbw = new BufferedWriter(new FileWriter("a.txt"));
//一次读取一行数据
Stringline;
while((line=br.readLine())!=null) {
//line就是已经读取到的数据，我们现在需要将line这个数据写入文件
bw.write(line);
bw.newLine();
bw.flush();
}
sk.close();
bw.close();
br.close();
}
}
2.6
需求：客户端读取文本文件中的内容发送给服务端，服务端将内容控制台输出 packagecom.edu_09;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
/**
*2.6
需求：客户端读取文本文件中的内容发送给服务端，服务端将内容控制台输出
* 客户端：
* 1.读取文本文件，一次读取一行
* 2.将读取到的内容写入通道，一次写一行
* 3.释放资源
* 服务器端：
* 1.从通道中读取数据，一次读取一行
* 2.输出
*/
public class TcpClient {
publicstatic void main(String[] args) throws Exception {
//创建socket对象
Socketsk = new Socket("192.168.20.254", 2000);
BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));
//读取文本一次读取一行
BufferedReaderbr = new BufferedReader(new FileReader("a.txt"));
Stringline;
while((line=br.readLine())!=null) {
//line就是我读取到的数据，我需要将这个数据写入通道，一次写一行
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
br.close();
bw.close();
sk.close();
}
}
package com.edu_09;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
publicstatic void main(String[] args) throws Exception {
//创建服务器端的socket对象
ServerSocketss = new ServerSocket(2000);
//蒋婷来自于客户端的连接
Socketsk = ss.accept();
//创建BufferedReader一次读取一行数据
BufferedReaderbr = new BufferedReader(new InputStreamReader(sk.getInputStream()));
Stringline;
while((line=br.readLine())!=null) {
System.out.println(line);
}
//释放资源
br.close();
sk.close();
}
}
2.7
* 需求: 上传文本文件
*
* 客户端:
* a: 读取文本文件中的数据
* b: 发送到服务器端
*
* 服务器:
* a: 读取流通道中的数据
* b: 把数据写入到文本文件中
2.9
提问：我们以后倒是使用udp协议还是tcp协议呢？
在咱们以后使用的软件当中基本都是udp和tcp混用的
mysql数据库：
-- 写sql语句，发送给服务端执行
-- 在后面可以写注释
-- 创建库，day16
CREATE DATABASEday16 DEFAULT CHARACTER SET utf8;
-- 使用day16这个数据库
USE day16;
-- 查询day16这个库中的所有的表
SHOW TABLES;
-- 需求：创建学生表(id,name,age)
CREATE TABLEstudent(
-- 字段名称字段类型
id INT,
NAME VARCHAR(20),
age INT
);
-- 查询表中的数据
SELECT * FROMstudent;
-- 查询一个表结构
DESC student;
-- 删除student表
DROP TABLEstudent;
-- 添加一个地址字段(gender varchar(2))
ALTER TABLEstudent ADD COLUMN gender VARCHAR(2);
-- 修改gender字段类型为varchar(3)
ALTER TABLEstudent MODIFY COLUMN gender VARCHAR(3);
-- 将gender字段修改为sex字段 varchar(2)
ALTER TABLEstudent CHANGE COLUMN gender sex VARCHAR(2);
-- 添加一个地址字段
ALTER TABLEstudent ADD COLUMN address VARCHAR(20);
-- 删除sex和address字段
ALTER TABLEstudent DROP COLUMN sex,DROP COLUMN address;
-- 将student这个表的表名改为stu
ALTER TABLE stuRENAME TO student;
-- 查看表的数据
-- select 字段名称(如果查询所有字段*) from student;
-- 查看表数据
SELECT * FROMstudent;
-- 给表中插入3条数据（插入所有字段）
INSERT INTOstudent VALUES(1,‘刘德华‘,50,‘中国香港‘);
INSERT INTOstudent VALUES(2,‘陈奕迅‘,40,‘中国香港‘);
INSERT INTOstudent VALUES(3,‘韩红‘,50,‘河北‘);
-- 当需要插入所有字段的时候我们可以直插入部分字段吗？插入不了
INSERT INTOstudent VALUES(1,‘成龙‘,60,‘中国香港‘);
-- 指向给表中只想插入id字段和name字段，请问怎么办？
INSERT INTOstudent(id,NAME) VALUES(4,‘郭德纲‘);
-- 将所有学生的年龄改为50岁,修改所有学生的年龄，用的非常少
UPDATE student SETage=50;
-- 将id为3的学生姓名改为房祖名
UPDATE student SETNAME=‘房祖名‘ WHERE id=3;
-- 修改多个字段，修改id为2的学生姓名为张学友，年龄改为60
UPDATE student SETNAME=‘张学友‘,age=60 WHERE id=2;
-- 删除全表数据,本质上是一条一条进行删除的，效率比较慢
DELETE FROMstudent;
-- 删除id为3的数据
DELETE FROMstudent WHERE id=3;
-- 使用truncate table 表名，删除全表数据，并不是一条条删，而是直接将全表数据删除，效率比较快
TRUNCATE TABLEstudent;
-- delete from和truncate table 这两种删除全表的方式有什么区别呢？
-- 1.delete from一条条删除，truncate table直接将全表数据干掉
-- 2.delete from可以按条件删除一条数据，truncate table只能删除全表数据，不能按照条件删除
-- 3.delete from无法重置自增长主键，truncate table可以重置自增长主键
-- 查询数据
-- 查询所有列
SELECT * FROMstudent;
-- 查询指定字段，查询id,name
SELECT id,NAMEFROM student;
-- 查询时指定别名，name--姓名，address--住址
SELECT NAME AS ‘姓名‘,address AS ‘住址‘ FROM student;
-- 上面指定别名的as是可以省略的
SELECT NAME ‘姓名‘ FROM student;
-- 添加servlet,jsp字段
ALTER TABLEstudent ADD COLUMN servlet INT,ADD COLUMN jsp INT;
-- 给每条学生数据添加上servlet和jsp的成绩
UPDATE student SETservlet=50,jsp=60 WHERE id=1;
UPDATE student SETservlet=60,jsp=70 WHERE id=2;
UPDATE student SETservlet=70,jsp=80 WHERE id=3;
-- 合并servlet和jsp这两个列进行查询，查询每个学生的servlet和jsp的成绩总和
-- 合并列查询有一个特点：只能合并数值类型的字段
SELECT NAME ‘姓名‘,(servlet+jsp) ‘总成绩‘ FROM student;
-- 查询时添加常量列，给student表添加一个常量列 班级--java001
SELECT NAME ‘姓名‘,address ‘地址‘,‘java001‘ AS ‘班级‘ FROM student;
-- 查询你们班的学生都来自于哪里
SELECT NAME ‘姓名‘,address ‘地址‘ FROM student;
-- 去除重复值来查询每一个学生来自于哪里
SELECT DISTINCTaddress FROM student;
-- 去除重复值的另一种写法
SELECTDISTINCT(address) FROM student;
-- 查询id为1并且，并且servlet成绩等于50的学生(交集 and)
SELECT * FROMstudent WHERE id=1 AND servlet=50;
-- 查询id为1或者来自中国香港的学生（并集 or）
SELECT * FROMstudent WHERE id=1 OR address=‘中国香港‘;
-- 查询servlet成绩大于60分的学生
SELECT * FROMstudent WHERE servlet>60;
-- 查询jsp成绩小于等于70的学生
SELECT * FROMstudent WHERE jsp<=70;
-- 另一种写法
SELECT * FROMstudent WHERE jsp<70 OR jsp=70;
-- 查询jsp的成绩大于等于70并且小于等于80的学生
SELECT * FROMstudent WHERE jsp<=80 AND jsp>=70;
-- 上面写法的另一种语法,between...and...包前也包后
SELECT * FROMstudent WHERE jsp BETWEEN 70 AND 80;
-- 查询学生年龄不等于30岁的学生
SELECT * FROMstudent WHERE age<>30;
-- 给student表中添加一个数据
INSERT INTOstudent VALUES(4,‘郭德纲‘,NULL,‘‘,80,90);
-- 查询age字段为null的学生(IS NULL)
SELECT * FROMstudent WHERE age IS NULL;
-- 查询address字段为空字符串的学生(=‘‘)
SELECT * FROMstudent WHERE address=‘‘;
-- 查询age字段不为null的学生(is not null)
SELECT * FROM student WHERE age IS NOT NULL;
-- 查询address字段不为‘‘的学生(<>‘‘)
SELECT * FROMstudent WHERE address<>‘‘;
-- 模糊查询(like),like后面跟的是符号
-- %任意多个字符
-- _一个字符
-- 查询姓刘的学生(like ‘刘%‘)
SELECT * FROMstudent WHERE NAME LIKE ‘刘%‘;
-- 查询姓名中含有刘这个字的学生
SELECT * FROMstudent WHERE NAME LIKE ‘%刘%‘;
-- 查询姓刘，且姓名有3个字的学生
SELECT * FROMstudent WHERE NAME LIKE ‘刘__‘;
-- 聚合函数
-- 查询servlet的总成绩(sum -- 求和函数)
SELECTSUM(servlet) FROM student;
-- 查询每个学生的servlet平均分（avg,平均函数）
SELECTAVG(servlet) FROM student;
-- 查询学生的servlet的最高成绩(max ,最大值函数)
SELECTMAX(servlet) FROM student;
-- 查询所有学生的servlet的最低成绩(min,求取最小值函数)
SELECTMIN(servlet) FROM student;
-- 求取这张学生表中有多少条数据(count(*))
-- 效率比较低
SELECT COUNT(*)FROM student;
-- 根据某一个字段求取学生表中的数据条数,当一个字段数值为null的时候，是不予计算的
-- 但是这种方式求取得统计值的时候效率会更高，但是有时候数据不够准确
SELECT COUNT(age)FROM student;
-- 求取本班中香港和河北的学生分别有多少人
-- 1.给学生使用address这个字段进行分组（group by） 2.求取每一组中的学生人数
-- address count
-- 香港 2
-- 河北 1
SELECTaddress,COUNT(*) FROM student GROUP BY address;
-- 查询人数大于1的地域(group by 分组字段 having 筛选条件)
SELECTaddress,COUNT(*) FROM student GROUP BY address HAVING COUNT(*)>1;
-- 分页查询 limit 起始行数,查询的条数 注意：起始行数从0开始
-- 假设我的表中有20条数据，分为4也显示
-- 第一页：limit 0,5
-- 第二页：limit 5,5
-- 第三页：limit 10,5
-- 第四页：limit 15,5
-- 结论：查询某一页要现实的数据的时候可以利用如下公式 limit (当前页数-1)*每页显示的条数,每页现实的条数
-- student表中目前有4条数据，分为2页显示，每页显示2条
-- 查询第一页的显示数据：
SELECT * FROMstudent LIMIT 0,2;
-- 查询第二页现实的数据
SELECT * FROMstudent LIMIT 2,2;
-- 按照id字段的升序进行排序
-- asc,升序，数字从小到大，字母a-z
-- desc,降序，数字从大到小，字母z-a
SELECT * FROMstudent ORDER BY id DESC;
-- 按照servlet的成绩的降序进行排序
SELECT * FROMstudent ORDER BY servlet DESC;
-- 当有多个排序条件的时候，先按照第一个条件排序，如果第一个条件相同则按照第二个条件进行排序
-- 先按照学生的年龄升序进行排序，年龄相同按照学生的servelt成绩的升序进行排序
SELECT * FROMstudent ORDER BY age ASC,servlet ASC;
DESC student;
SELECT * FROMstudent;
--------------------------------------------------------------------
-- 数据约束：给表添加一些数据约束从而可以达到约束用户操作数据的效果
-- 1：默认值约束（default）
-- :当给这个字段没有添加值的时候，会给一个默认值,如果给默认值约束的字段添加的值为null的时候，那么他的字段值就为null
-- 创建一个stu表
CREATE TABLE stu(
id INT,
NAME VARCHAR(20),
-- 给性别gender这个字段添加一个默认值约束
gender VARCHAR(2)DEFAULT ‘男‘
);
-- 给stu表中添加几个数据
INSERT INTO stuVALUES(1,‘张三‘,‘男‘);
INSERT INTOstu(id,NAME) VALUES(2,‘李四‘);
-- 给stu表中插入数据，性别为null
INSERT INTO stuVALUES(3,‘刘诗诗‘,NULL);
-- 2.非空约束(not null),插入的字段不为null，而且必须插入数据
CREATE TABLE stu(
-- 给stu表中的id字段添加一个非空约束
id INT NOT NULL,
NAME VARCHAR(20),
gender VARCHAR(2)
);
-- 给这张表中添加一个元素，不插入id字段的值
INSERT INTOstu(NAME,gender) VALUES(‘郭德纲‘,‘男‘);
-- 给这张表添加一条数据，id字段的值直接给成null,这样的话是插入不进去的。。
-- 唯一约束(unique)
-- 给stu表添加一个唯一约束
CREATE TABLE stu(
-- 给stu表中的id字段添加唯一约束
id INT UNIQUE,
NAME VARCHAR(20),
gender VARCHAR(2)
);
-- 给表中插入两条id相同的数据
INSERT INTO stuVALUES(1,‘刘德华‘,‘男‘);
INSERT INTO stuVALUES(1,‘张学友‘,‘男‘);-- Duplicate entry ‘1‘ for key ‘id‘,无法插入重复的id值
-- 给表中插入一条id为null的数据，当给id添加了唯一约束之后，依然可以给他插入多条null值，不会出现重复
INSERT INTO stuVALUES(NULL,‘吴奇隆‘,‘男‘);
INSERT INTO stuVALUES(NULL,‘刘诗诗‘,‘女‘);
-- 经过我们的分析，我们认定我们的这个id字段(唯一+非空)--主键(primary key)
-- 注意：
-- 1.一般来说我们需要给每一张表都设定一个主键字段(非空+唯一)，用来标示一条信息的唯一性
-- 2.我们一般不会将业务字段设定为主键字段，比如name字段，一般我们会给每一张表添加一个id字段作为主键字段
-- 3.建议给每张表添加一个主键字段，用来标示每一条数据的唯一性
CREATE TABLE stu(
-- 给stu表中的id字段设置为主键（唯一+非空）
id INT PRIMARYKEY,
NAME VARCHAR(20),
gender VARCHAR(2)
);
-- 给表中插入两条id为1的学生信息
INSERT INTO stuVALUES(1,‘华仔‘,‘男‘);
INSERT INTO stuVALUES(1,‘华建‘,‘男‘);-- Duplicate entry ‘1‘ for key ‘PRIMARY‘
-- 给表中插入id为null的元素
INSERT INTO stuVALUES(NULL,‘杰伦‘,‘男‘);-- Column ‘id‘ cannot be null
-- 上面的实验我们可以得出结论，当我们给id字段设置了主键约束后，这个id字段就非空+唯一了
-- 自增长约束(auto_increment)
-- 给stu表中的id字段添加一个主键自增长约束
CREATE TABLE stu(
-- 给stu表中的id字段设置主键自增长约束，我们其实就将id这个字段交给了数据库自己去维护，我们自己不需要去动他
id INT PRIMARY KEYAUTO_INCREMENT,
NAME VARCHAR(20),
gender VARCHAR(2)
);
-- 给stu表中添加两条数据
INSERT INTOstu(NAME,gender) VALUES(‘华仔‘,‘男‘);
INSERT INTOstu(NAME,gender) VALUES(‘周杰伦‘,‘男‘);
INSERT INTOstu(NAME,gender) VALUES(‘周杰伦‘,‘男‘);
INSERT INTO stu(NAME,gender)VALUES(‘周杰伦‘,‘男‘);
-- 删除id为4的数据
DELETE FROM stuWHERE id=4;
-- 给表中添加一条数据
INSERT INTOstu(NAME,gender) VALUES(‘张学友‘,‘男‘);
-- delete from 这种删除数据的方式，无法重置自增长的主键
-- 删除stu的全表数据
DELETE FROM stu;
-- 添加一条数据
INSERT INTOstu(NAME,gender) VALUES(‘张学友‘,‘男‘);
-- 删除全表数据的truncate table 表名，删除全表数据，这种删除全表数据的方式可以重置主键
TRUNCATE TABLEstu;
-- 给表中添加一条数据
INSERT INTOstu(NAME,gender) VALUES(‘华仔‘,‘男‘);以上是关于十八十九天笔记总结的主要内容，如果未能解决你的问题，请参考以下文章
Android开发笔记（一百八十八）工作管理器WorkManager