2022-8-18 第七小组学习日记 (day42)JDBC+练习题

——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');

SQL存储过程实例

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 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 
            for (int j = i; 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[i]=random();
            if(str==arr[i]){
                flag=true;
            }
            //System.out.println(arr[i]);//可以打印看看字符串都有什么
        }
        System.out.println("您输入的字符串:"+str+(flag?"在":"不在")+"随机生成的字符中");

总结

今天学习了JDBC，这是一个全新的内容，对我来说相当难，它的作用就是将前面的Mysql和java相结合，Mysql进行数据存储，java则对数据库中的数据进行增删改操作，代码量太大看不懂

相关阅读:
HTML 超链接 a 标签
 数据挖掘神经网络算法,人工神经网络分析方法
 【EMQX 5.0】2.2.4 Authentication 认证
 分页条件搜索
 计算机外设：显示器是如何工作的？
聪明的红绿灯，已经学会主动给你开路了
 FDbus NDK以及QNX交叉编译
 项目实战第三十三讲：标准中心-属性体系
 聊聊神经网络的优化算法
 HTML5期末大作业【红色的电影售票平台网站】web前端 html+css+javascript网页设计实例企业网站制作
原文地址：https://blog.csdn.net/weixin_56982770/article/details/126404278

2022-8-18 第七小组 学习日记 (day42)JDBC+练习题

聚合函数（早上）