目录
正题：执行数据库的DML语言---增删改（没有查哟）在java中有三个接口分别定义了对数据库的调用的不同的方式：
题目一：从控制台中读入一个文件名，判断该文件是否存在你的某个盘下。如果该文件存在，则在原文件相同路径下创建一个文件名为“copy_原文件名”的新文件，该文件内容为原文件的拷贝。
聚合函数（早上）
——count：计数。count(*)≈count(1)>count(主键)
count(*)：MySQL对count(*)底层优化，count(0)。
count(1)
count(主键)
count(字段)
——min：最小值
——max：最大值
——sum：求和
——avg：平均值
数值型函数
主要是对数值型进行处理。
——ceiling(x)：向上取整
——floor(x)：向下取整
——round(x)：四舍五入
——truncate(x,y)：返回数字x截断为y位小数的结果
——PI：圆周率，π
——rand：返回0到1的随机数
——abs：绝对值
-- 绝对值
select ABS(-4) 4的绝对值,ABS(-1.1);
-- 向下取整，向上取整，四舍五入
select CEILING(4.1),FLOOR(1.1),ROUND(-4.4)
-- 取余
select MOD(60,11);
-- 随机数
select RAND(),RAND(),RAND()
-- 截断
select TRUNCATE(2.33999999,2);字符串型函数
对字符串进行处理。
——length(s)：字符串的长度
——concat(s1,s2,.....sn)：合并字符串
——lower(str)：将字母转成小写
——upper(str)：将字母转成大写
——left(str,x)：返回字符串str的左边的x个字符
——right(str,x)：返回字符串str右边的x个字符
——trim：去掉左右两边的空格
——replace：替换
——substring：截取
——reverse：反转
select LEFT('abcdefg',2);
select RIGHT('abcdefg',2);
select REVERSE('hijklmn');
select REPLACE('abcdefg','abc','x');日期和时间函数
date,time,datetime,timestamp,year。
获取时间和日期
——【curdate】和【current_date】，返回当前的系统日期。
——【curtime】和【current_time】，返回当前的系统时间。
——【now】和【sysdate】，返回当前的系统时间和日期。
select CURRENT_DATE();
select CURTIME();
select now();时间戳和日期转换函数
【UNIX_TIMESTAMP】获取unix时间戳函数
【FROM_UNIXTIME】将时间戳转换为时间格式
select UNIX_TIMESTAMP();
select FROM_UNIXTIME(1660785720);根据日期获取年月日的数值
select MONTH(SYSDATE());
select MONTHNAME(SYSDATE());
select DAYNAME(SYSDATE());
select DAYOFWEEK(SYSDATE());
select WEEK(SYSDATE());
select DAYOFMONTH(SYSDATE());
select YEAR(SYSDATE());时间日期的计算
-- 日期加法
select DATE_ADD(SYSDATE(),INTERVAL 70 DAY);
-- 日期减法
select DATE_SUB(SYSDATE(),INTERVAL 10 DAY);
-- 时间间隔
select DATEDIFF('2023-01-01',SYSDATE());
-- 日期格式化
select DATE_FORMAT(SYSDATE(),'%W %M %D %Y');加密函数
-- 把传入的参数的字符串按照md5算法进行加密，得到一个32位的16进制的字符串
select MD5('123456');md5算法是不可逆的。
流程控制函数
可以进行条件判断，用来实现SQL语句的逻辑。
——if(test,t,f)：如果test是真，则返回t，否则返回f
——ifnull(arg1,arg2)：如果arg1不是空，返回arg1，否则返回arg2
——nullif(arg1,arg2)：如果arg1=arg2返回null，否则返回arg1
select IF(2 > 1,'a','b');
select IFNULL(sal,0);
select NULLIF(age,0);对一系列的值进行判断：
-- 输出学生的各科的成绩，以及评级，60以下D，60-70是C，71-80是B，80以上是A
SELECT
*,
CASE
WHEN score < 60 THEN 'D' WHEN score >= 60
AND score < 70 THEN 'C' WHEN score >= 70
AND score < 80 THEN 'B' WHEN score >= 80 THEN
'A'
END AS '评级'
FROM
mystudent;
-- 行转列
SELECT
user_name,
max( CASE course WHEN '数学' THEN score ELSE 0 END ) '数学',
max( CASE course WHEN '语文' THEN score ELSE 0 END ) '语文',
max( CASE course WHEN '英语' THEN score ELSE 0 END ) '英语'
FROM
mystudent
GROUP BY
user_name数据库设计
三范式
-
第一范式：要求有主键，并且要求每一个字段的原子性不能再分。
-
第二范式：要求所有的非主键字段完全依赖主键，不能产生部分依赖
-
第三范式：所有非主键字段和主键字段之间不能产生传递依赖。
第一范式
不符合第一范式表结构：
| id | name | 联系方式 |
|---|---|---|
| 1001 | aaa | aaa@163.com , 13314569878 |
| 1002 | bbb | bbb@163.com , 13245678945 |
| 1003 | ccc | ccc@163.com , 15000456987 |
符合第一范式的表结构：
| id | name | 邮箱 | 手机号 |
|---|---|---|---|
| 1001 | aaa | aaa@163.com | 12321321321 |
| 1002 | bbb | bbb@163.com | 32132654654 |
| 1003 | ccc | ccc@163.com | 45654654654 |
必须有主键，这是数据库设计的基本要求，一般情况下我们采用数值型或定长字符串，列不能再分，比如：联系方式。
关于第一范式，保证每一行的数据是唯一，每个表必须有主键。
第二范式
建立在第一范式的基础上，要求所有非主键字段完全依赖于主键，不能产生部分依赖。
| 学号 | 性别 | 姓名 | 课程编号 | 课程名称 | 教室 | 成绩 |
|---|---|---|---|---|---|---|
| 1001 | 男 | a | 2001 | java | 301 | 89 |
| 1002 | 女 | b | 2002 | mysql | 302 | 90 |
| 1003 | 男 | c | 2003 | html | 303 | 91 |
| 1004 | 男 | d | 2004 | python | 304 | 52 |
| 1005 | 女 | e | 2005 | c++ | 305 | 67 |
| 1006 | 男 | f | 2006 | c# | 306 | 84 |
解决方案：
学生表：学号是主键
| 学号 | 性别 | 姓名 |
|---|---|---|
| 1001 | 男 | a |
| 1002 | 女 | b |
| 1003 | 男 | c |
| 1004 | 男 | d |
| 1005 | 女 | e |
| 1006 | 男 | f |
课程表：课程编号是主键
| 课程编号 | 课程名称 | 教室 |
|---|---|---|
| 2001 | java | 301 |
| 2002 | mysql | 302 |
| 2003 | html | 303 |
| 2004 | python | 304 |
| 2005 | c++ | 305 |
| 2006 | c# | 306 |
成绩表：学号和课程编号为联合主键
| 学号 | 课程编号 | 成绩 |
|---|---|---|
| 1001 | 2001 | 89 |
| 1002 | 2002 | 90 |
| 1003 | 2003 | 91 |
| 1004 | 2004 | 52 |
| 1005 | 2005 | 67 |
| 1006 | 2006 | 84 |
第三范式
建立在第二范式基础上，非主键字段不能传递依赖于主键字段。
不满足第三范式：
| 学号 | 姓名 | 课程编号 | 课程名称 |
|---|---|---|---|
| 1001 | a | 2001 | java |
| 1002 | b | 2002 | mysql |
| 1003 | c | 2003 | html |
| 1004 | d | 2004 | python |
| 1005 | e | 2005 | c++ |
| 1006 | f | 2006 | c# |
解决方案：
学生表：学号是主键
| 学号 | 姓名 | 课程编号 |
|---|---|---|
| 1001 | a | 2001 |
| 1002 | b | 2002 |
| 1003 | c | 2003 |
| 1004 | d | 2004 |
| 1005 | e | 2005 |
| 1006 | f | 2006 |
课程表：课程编号是主键
| 课程编号 | 课程名称 |
|---|---|
| 2001 | java |
| 2002 | mysql |
| 2003 | html |
| 2004 | python |
| 2005 | c++ |
| 2006 | c# |
常见的表关系
一对一
学生信息表分为基本信息表和信息信息表。
-
分为两张表，共享主键。
-
分两张表，用外键连接。
一对多
两张表，外键在多的一方。
-
分两张表存储，在多的一方加外键
-
这个外键字段引用是一的一方的主键
多对多
-
分三张表存储，在学生表存储学生信息，在课程表存储课程信息。
-
在成绩表中存储学生和课程的对应关系。
JDBC（下午）
JDBC是什么？
JDBC指的是Java数据库连接，是一种标准Java应用编程接口,用来连接java编程和广泛的数据库
数据的持久化：
把数据永久的保存起来。主要的方式还是得存到硬盘上。 持久化的实现过程大部分是通过数据库来完成。
JDBC编程需要：
1.数据库驱动：
所有连接数据库都要实现的最大接口：java.sql.Driver
如何加载驱动？
通过反射：class.forName("com.mysql.jdbc.Driver");
mysql:com.mysql.jdbc.Driver
oracle:oracle.jdbc.driver.OracleDriver
2.url地址：
需要链接数据库，其实就是链接一个服务器。
我们之前链接服务器的时候用的是IP地址+端口号，但是针对于连接数据库的话，有一个专门的协议：jdbc协议：
jdbc协议：jdbc:mysql://主机名称（主机地址）：端口号/数据库的名字
(这是我的地址)eg:jdbc:mysql://127.0.0.1:3306/wy?useUnicode=true&characterEncoding=utf8
3.数据库的用户名：
4.数据库的密码：
导入jar包
链接数据库需要导入外部依赖，需要引入mysql的驱动（指的是引入的jar包）
jar包：点击进入官网
我这里用的是5.1.17的，这里不推荐用8.0的，因为8.0变样了，而且非常的私有化，然后还需要解放私有化，非常麻烦，最关键的是，我不会。
我们首先需要导入jar包：在项目下建立一个文件夹：lib
然后把jar包放到文件夹里，之后右键点击add a liabrary
以上的都是准备工作，我们来真正链接数据库：
获取以上的内容
String url="jdbc:mysql://127.0.0.1:3306/wy?useUnicode=true&characterEncoding=utf8";
String username="root";//你自己的用户名字
String password="root";//你自己的用户密码
//驱动的全类名
String driverName="com.mysql.jdbc.Driver";加载驱动类：
Class clazz = Class.forName(driverName);实例化Driver对象
Driver driver=(Driver)clazz.getDeclaredConstructor().newInstance();注册驱动
DriverManager.registerDriver(driver);获取链接
Connection connection=DriverManager.getConnection(url,username,password);接下来可以用Objects的nonNull的方法来判断是否连接成功了：
System.out.println(Objects.nonNull(connection)?"数据库连接成功":"数据库连接失败");
这下步骤太麻烦，而且在代码中，不易改变，所以我们用封装+外部文件获取驱动的方式，封装一个方法：
获取JDBC连接的方法
jdbc.properties文件：注意，是文件，读取外部的properties属性文件，用外部文件获取驱动
mysql.url=jdbc:mysql://127.0.0.1:3306/wy?useUnicode=true&characterEncoding=utf8
mysql.username=root
mysql.password=020323
mysql.driverName=com.mysql.jdbc.Driver方法：
public static Connection connection(){
Properties properties = new Properties();
Connection connection=null;
try {
properties.load(Test01.class.getClassLoader().getResourceAsStream("jdbc.properties"));
String url = properties.getProperty("mysql.url");
String driverName = properties.getProperty("mysql.driverName");
String username = properties.getProperty("mysql.username");
String password = properties.getProperty("mysql.password");
Class.forName(driverName);//加载器驱动类（可以省略实例化对象和注册驱动的过程）
connection = DriverManager.getConnection(url, username, password);
} catch (SQLException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
return connection;
}使用属性配置文件的好处：
1.实现了代码和数据的分离，如果需要修改配置信息,直接在属性文件中修改即可。不需要深入代码
2.如果修改了配置信息，省去了编译的过程
3.符合OCP原则
正题：执行数据库的DML语言---增删改（没有查哟）
在java中有三个接口分别定义了对数据库的调用的不同的方式：
1.Statement：用来执行静态sql语句并返回它所生成的结果对象
2.PreparedStatement：预编译，可以使用此对象多次高效的执行该语句
3.CallableStatement:用来执行sql的存储过程//不学
我们每次开启数据库连接，相对应的也要关闭连接：我们也封装一个工具类：
public static void close(Connection conn, Statement statement){
if(Objects.nonNull(statement)){
try {
statement.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
if(Objects.nonNull(conn)){
try {
conn.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}首先建立连接、创建Statement对象
Connection conn =null;
Statement statement=null;
try {
conn = JDBCUtil.connection();
statement = conn.createStatement();
//增加
String sql="INSERT INTO teacher (name) VALUES ('法外狂徒')";
// //返回值是执行sql语句影响的行数
//修改
// String sql="UPDATE teacher set name='jay'";
//删除
// String sql="DELETE FROM teacher where name='jay'";
int i = statement.executeUpdate(sql);
System.out.println(i);
System.out.println("操作成功！！！");
} catch (SQLException e) {
throw new RuntimeException(e);
}finally {
JDBCUtil.close(conn,statement);
}那么我们要进行查询操作该怎么做呢：
首先获取连接，获取可以执行sql语句的statement对象，定义sql，执行查询的sql，会得到一个ResultSet,ResultSet就是封装了查询结果的一个对象，遍历结果集
@Test
public void test01() {
// 1.获取连接
Connection conn = JDBCUtil.getConnection();
Statement stmt = null;
ResultSet rs = null;
try {
// 2.获取可以执行sql语句的stmt对象
stmt = conn.createStatement();
// 3.定义sql
String sql = "select id tid,name tname from teacher where id = 7";
// 4.执行查询的sql，会得到一个ResultSet
// ResultSet就是封装了查询结果的一个对象
rs = stmt.executeQuery(sql);
// 5.遍历结果集ResultSet
while(rs.next()) {
int id = rs.getInt("tid");
String name = rs.getString("tname");
System.out.println("id:" + id + ",name:" + name);
}
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
// 6.关闭资源
JDBCUtil.close(conn,stmt,rs);
}
}关闭资源的方法:
public static void close(Connection conn, Statement stmt, ResultSet rs) {
if(Objects.nonNull(stmt)) {
try {
stmt.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
if(Objects.nonNull(conn)){
try {
conn.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
if(Objects.nonNull(rs)){
try {
rs.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}JAVA上机题3道（晚上）
题目一：
从控制台中读入一个文件名，判断该文件是否存在你的某个盘下。如果该文件存在，则在原文件相同路径下创建一个文件名为“copy_原文件名”的新文件，该文件内容为原文件的拷贝。
首先肯定是要判断该文件名到底存不存在：
我们定义一个方法：用来判断是否存在该文件，如果存在，获取父路径并拼接用来创建文件，如果不存在则打印“你输入的文件不存在”
private static File createFile(String fileName) throws IOException {
File file = new File(fileName);
if (file.exists()) {
//获取父路径并拼接
File copyFile = new File(file.getParent() + "/copy_" + file.getName());
//复制后的路径
System.out.println(copyFile);
//创建文件
copyFile.createNewFile();
//返回创建的文件
return copyFile;
} else {
System.out.println("你输入的文件不存在");
}
return null;
}
}文件创建完成后，进行传输文件内容工作：
判断是否创建完成，我这里用是否为空来判断：
文件传输我这里没有解决异常（try...catch）而是选择抛异常的方式：
private static boolean copyFile(String fileName) throws IOException {
File copyFile = createFile(fileName);
//判断拷贝是否为空
if (copyFile == null) {
return false;
}
InputStream inputStream = new FileInputStream(fileName);//读源文件
OutputStream outputStream = new FileOutputStream(copyFile);//写到复制出的文件中
int len = 0;
while ((len = inputStream.read()) != -1) {
outputStream.write(len);
}
inputStream.close();
outputStream.close();
return true;
}主方法：
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件名：");
String fileName = "C:/summerjava/" + sc.next();
boolean flag = false;
try {
flag = copyFile(fileName);
} catch (IOException e) {
throw new RuntimeException(e);
}
System.out.println(flag);//创建成功
}
题目二：
随机生成10个百位以内数字并存入集合中(任意集合均可，自行决定)。利用自己擅长的方式对其10个数字进行排序，排序后按小到大方式输出。
看到这个题，首先一个知识点：随机数、第二个存入到集合里、第三个进行排序，（我这里用的是冒泡排序法）
随机生成百位以内数字：
int ran=new Random().nextInt(100)
List<Integer> list = new ArrayList<>();
for (int i = 0; i <10 ; i++) {
list.add(new Random().nextInt(100));
}//生成的10个随机数字，并存入到集合中
System.out.println("随机生成的："+list);
for (int i = 0; i <list.size() ; i++) {
for (int j = i; j <list.size() ; j++) {
if(list.get(i)>=list.get(j)){
int temp=list.get(i);
list.set(i,list.get(j));
list.set(j,temp);
}
}
}
System.out.println("排序后"+list);
题目三：
随机生成100个，10位字符串。字符由a-z,A-Z,0-9随机组成。并将生成的100个字符串存入容器中(提示:数组，集合)。假定从键盘输入一一个字符串，判断这个字符串是否在生成的100字符中。并给出友好提示。
我首先定义一个方法用来生成十位随机字符串：
public static String random(){
String chars = "qwertyuioplkjhgfdsazxcvbnm0123456789QWERTYUIOPLKJHGFDSAZXCVBNM";
StringBuffer value = new StringBuffer();
for (int i = 0; i < 10; i++) {
value.append(chars.charAt((int)(Math.random() * 62)));
}
return value.toString();
}
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
Boolean flag = false;
String [] arr =new String[100];
for (int i = 0; i <arr.length ; i++) {
arr[i]=random();
if(str==arr[i]){
flag=true;
}
//System.out.println(arr[i]);//可以打印看看字符串都有什么
}
System.out.println("您输入的字符串:"+str+(flag?"在":"不在")+"随机生成的字符中"); 
总结
今天学习了JDBC，这是一个全新的内容，对我来说相当难，它的作用就是将前面的Mysql和java相结合，Mysql进行数据存储，java则对数据库中的数据进行增删改操作 ，代码量太大看不懂
2378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
