ORACLE完整笔记及JAVA习题

29.

30.能从循环语句中跳出的是（ACD） A.return B.for C.break D.continue

31.下列那两个语句能够创建一个inputstream输入流并且打开文件file.txt准备读取（B） A.FileInputStream in = new FileReader（new File（”File.txt”））; B. FileInputStream in = new FileInputStream（new File（”File.txt”））; C. InputStream in = new FileReader（”File.txt”）; D. InputStream in = new FileInputStream(”File.txt”);

E. InputStream in = new InputStreamFileReader(”File.txt”,”read”);

32.下列哪些方法可以定义新线程类（AB） A.继承thread类。 B.实现runnable接口。

C.在类中添加一个run（）方法。 D.创建一个thread实例。 （线程部分创建的内容）

33.想要构造arraylist的一个实例，这个类继承了list接口，一下正确的是（C） A. List mylist = new List();

B. ArrayList mylist = new Object(); C. List mylist = new ArrayList();

D. ArrayList mylist = new ArrayList();

（D和C都是可以的，但是D一般不用，因为，用父类List可以方便代码复用，团队开发，和转化为组件）

34.下列关键字可以修饰构造函数的是（ABCD） A.protected B .public C. private D. default

（特征修饰符应该都不行：static，final，abstract，synchronize等） 35.关于集合描述错误的是（BCD）

A．Map是独立接口，没有继承collection接口，queue继承map接口。 B．没有collection这一个接口。

C．list，set，queue，map都继承自collection接口

D．list，set，queue，map都是独立接口，没有继承其他接口。 E．list，set，queue继承自collection接口。

ORACLE部分

开篇

MVC结构 进行下一步操作 用户 1（等待用户输入）

人机交互界面（浏览器）人机交互界面（浏览器）

2（根据用户输入 选择不同控制器）

6（根据返回结果选择不同的视图） Controller 5（返回数据给控制器） 控制器

3（将用户输入的数据 进行简单处理后 传递给模型层） Model 模型 4（进行业务逻辑判断

之后调用数 据存取方法）

ORACLE-SQL开发

DB 数据库 用户 View 视图 查询：单表查询；多表查询；单行函数与分组函数；

子查询；层次查询；集合运算。 数据操作：增删改 事务控制：

对象管理：表，约束，视图，引用，序列，同义词。

权限控制：用户，权限，角色

数据：能输入到计算机中并能被计算机处理的符号的总称。

数据处理的几个阶段：人工阶段，文件系统阶段，数据库系统阶段。 数据库特点：小数据冗余，独立于应用程序，可分享。 数据管理系统（DBMS）：管理数据库的软件。

ORACLE数据库文件：数据文件，控制文件和重做日志文件。 数据模型的三个层次：概念模型（ER图），逻辑模型（层次模型，关系模型，网状模型），物理模型。

关系模型的组成：关系数据结构、关系操作集合、关系完整性约束。

（关系操作：连接，投影，选择，增加等）（约束：实体完整性约束，参照完整性约束，用户自定义完整性约束）

ORACLE一个数据库可以拥有多个用户，每一个用户有多个数据库对象。

Sys用户：权限最高，存放左右数据字典的表和视图。

Oracle用户System用户：普通dba权限，用户拥有次一级内部数据。 Scott用户：示范用户

Sys用户解锁Scott用户sql命令：alter user scott account unlock; 连接sql语句：connectScott/tiger;（用户名/密码）。 Conn sys/neuedu as sysdba;（sys用户登录） Sql语句 ==结构化查询语言。

第一章：编写简单的查询语句。

结构化查询语言sql（structural query language）：是查询关系型数据库的标准语言。 DQL（SELECT）。 DML（insert，delete， update 修改行）。 结构化查询语言分为5类 TPL （commit，rollback 提交回滚）。 DCL （grant，revoke权限分配）。 DDL （create，drop，alter 对象操作）。

Select的语句涉及的关系包括：选择（行），投影（列），连接（表之间）。 调整sql-developer书写显示tools->preferance->edit->keywords,comment。 练习1：

1.用两种方式查询所有员工信息？2.同下 Select * from emp

Select emp ,empno,job,mgr,hiredate,sal,comm,deptno from emp.

算数运算符可以用在查询语句中。 练习2：

1． 员工转正之后月薪上调20%。查询转正之后的月薪。

Select ename,sal,sal+sal*0.2 from emp

2. 员工试用期6个月，转正之后月薪上调20%，查询所有员工第一年的所得 Select ename,sal*6+sal*1.2*6from emp

Sql中的空值（NULL）的处理，空值参与算术运算结果是空

列别名两种方式：列明列别名或者列名 as列别名，如果列别名中含有空格，必须用双引号引起来！并且加了双引号才可以改变大小写！例子“Annual Salary”就显示为 Annual Salary。 练习3：

员工试用期6个月，转正之后月薪上调20%，查询所有员工姓名，工资收入，奖金，总收入。 Select ename,sal*6+sal*1.2*6 工资收入,comm奖金,sal*6+sal*1.2*6+comm 总收入 from emp

(列别名可以有汉字)

连接运算符可以把两个列的值连接在一起 Select ename||job from emp 显示的是smithclerk的样式 Sql语句中的原义字符串就是原样显示的字句。 消除重复行用DISTINCT关键字。 员工试用期6个月，转正之后月薪上调20%，查询所有员工第一年总收入，要求显示的格式为：***的第一年总收入为***？ SELECT ename || '的第一年的总收入是' || （sal*6+sal*1.2*6 ）AS 员工总收入FROM emp 显示公司有哪几种岗位？ Select distinct deptno from emp 课后作业：

4.在dept表中查询deptno和job两列，并加上distinct做实验？ Select distinct deptno，job from emp

Distinct本身是消除重复行，当两列在一起的时候，会消除两个字段都重复的数据。

第二章：限制数据和排序数据。

Oracle的sql语句中等于是“=”，不等于是“<>”。

Sql语句中的字符型数据是区分大小写的，不区分大小写的是表明列名，关键字！如‘clerk‘和CLERK’

比较日期：中文系统默认的oracle日期格式为DD-MON-RR写成’01-1月-90’。 练习1

1． 查询职位为SALESMAN的员工编号，职位，入职日期

SELECT ename,job,hiredate FROM emp WHERE job='SALESMAN' 2.查询1985年12月31日之前入职的员工姓名及入职日期？ SELECT ename,hiredate FROM emp WHERE hiredate < '31-12月-85' 2． 查询部门编号不在10部门的员工姓名，部门编号？

SELECT ename,deptno FROM emp WHERE deptno <> 10 特殊比较运算符：

BETWEEN…AND…（闭区间范围内部[1000,5000]！这个还可以用于日期型数据！） IN （是否与集合中任意一个相等）

LIKE （部分匹配，通配符：%代表多个字符，_代表一个字符） IS NULL （是否为空值，）

通配符的原义输出方法：

在“_”和“%”的前面加上一个’@’，然后后面用ESCAPE ‘@’就可以了。

例如：SELECT ename FROM emp WHERE ename LIKE'%@_W'ESCAPE ‘@’，名字里面含有_。

练习2

1． 查询入职日期在82到85年的员工姓名，入职日期？

SELECT ename,hiredate FROM emp WHERE hiredate BETWEEN '01-1月-82' AND '31-12月-85'

2． 查询月薪在3000到5000 的员工姓名，月薪

SELECT ename,sal FROM emp WHERE sal BETWEEN 3000AND5000

3． 查询部门号为10或者20 的员工姓名与部门编号？ SELECT ename,deptno FROM emp WHERE deptno IN (10,20) 4.查询经理编号为7902,7566,7788的员工姓名，经理编号

SELECT ename ,mgr FROM emp WHERE mgr IN(7902,7788,7566) 5.查询员工姓名以W开头的员工姓名

SELECT ename FROM emp WHERE ename LIKE'W%' 6.查询员工姓名倒数第二个字符为T的员工姓名 SELECT ename FROM emp WHERE ename LIKE'%T_' 7.查询奖金为空的员工姓名和奖金。

SELECT ename,comm FROM emp WHERE comm ISNULL

逻辑运算符： AND逻辑与

OR逻辑或 NOT逻辑非 练习3，

1.查询工资超过2000并且职位是MANAGER，或者职位是SALSMAN的员工的姓名，职位，工资

SELECT ename ,job,sal FROM emp

WHERE sal>2000AND job ='MANAGER'OR job ='SALESMAN'

2.查询工资超过2000并且职位是MANAGER或SALESMAN的员工姓名，部门，工资 SELECT ename ,job,sal FROM emp

WHERE sal>2000AND(job ='MANAGER'OR job ='SALESMAN')

3.查询部门在10或20，并且工资在3000和5000之间的员工姓名，部门，工资 SELECT ename ,deptno,sal FROM emp

WHERE deptno IN(10,20)AND(sal BETWEEN3000AND5000)

4.查询入职日期在81年，并且职位不是SALES大头的员工姓名，入职日期，部门编号。 SELECT ename ,hiredate,job FROM emp

WHERE hiredate BETWEEN'01-1月-81'AND'12-12月-81'AND job NOTLIKE'SALES%' 5.查询职位为SALESMAN或者MANAGER，部门编号为10或20，姓名包括A的员工的姓名，职位，部门编号。

SELECT ename ,deptno,job FROM emp WHERE deptno IN(10,20)

AND(job IN('SALESMAN','MANAGER'))AND ename LIKE'%A%'

ORDER BY排序子句：必须写在SELECT语句的最后！可以按找列别名排序 ASC升序，DESC降序

注意空值（NULL）在升序中排在最后的，在降序中排在最前面。 练习4.

1.查询部门在20 或30 的员工姓名，部门编号，并按照工资升序排列 SELECT ename,deptno FROM emp ORDERBY sal ASC

2.查询工资在2000-3000之间，部门不再10号的员工姓名，部门编号，工资，并按照部门的升序排列。 SELECT ename,deptno,sal FROM emp WHERE sal BETWEEN2000AND3000AND deptno <>10ORDERBY

SELECT e.ename,d.loc FROM emp e,dept d WHERE e.deptno = d.deptno ANDINSTR(lower(e.ename),'a')<>0或e.ename like ‘%A%’ Oracle中的不等值连接与多于两个表的连接内容比较少，直接写一个代表性的练习题就好了。 4.查询每个员工的的编号，姓名，工资，工资等级，所在工作城市，按照工资等级进行升序排列

SELECT e.empno,e.ename,s.grade,d.loc FROM emp e,dept d,salgrade s WHERE e.deptno = d.deptno

AND e.sal BETWEEN s.losal AND s.hisal ORDERBY s.grade ASC

ORACLE中的外链接与内连接及自身连接

内连接就是按照一定的连接条件，第一个表的每一条记录都能在另一个表找到相应的记录 ，同理外连接就是两个表中按照连接条件是找不到相应记录的，比如，某个员工没有部门，但是还是想把这个员工查出来，就需要用到外连接 外连接的语法规则就是在缺少信息匹配大那一边加上“（+）”，表示加上一个万能行 自身连接：查询员工姓名和直接领导姓名

例子的代码：SELECT e.ename 员工姓名,m.ename 经理姓名 FROM emp e,emp m

WHERE e.mgr = m.empno 练习2.

1.查询所有工作在纽约或(或就是IN,OR)芝加哥的员工姓名，员工编号及其经理姓名经理编号

SELECT e.ename,e.empno,m.ename,m.empno FROM emp e,emp m,dept d WHERE e.mgr = m.empno AND e.deptno = d.deptno

AND d.loc IN('NEW YORK','CHICAGO')

2.在第一题的基础上添加没有经理的King,并按照员工编号排序 SELECT e.ename,e.empno,m.ename,m.empno FROM emp e,emp m,dept d WHERE e.mgr = m.empno(+) AND e.deptno = d.deptno

AND d.loc IN('NEW YORK','CHICAGO') ORDERBY e.empno

Oracle语法规则SQL99的语法规则

SELECT e.ename,d.locSELECT e.ename,d.loc

FROM emp e,dept dFROM emp e CROSSJOIN dept d（交叉连接）

SELECT*SELECT*

FROM emp e,dept dFROM emp e NATURALJOIN dept d（自然连接）

WHERE e.deptno = d.deptnoSELECT*FROM emp JOIN dept（using方法） USING (deptno)相当于从多个相等字段中选一个deptno！

SQL99中用的最广的就是ON字句了，它的功能就是将检索条件和限制条件分开，限制条件放在where里面，而检索条件放在on里面，提高代码的可读性。

SELECT e.ename,d.deptnoSELECTename,deptno FROM emp e,dept dFROM emp JIONdept

WHERE e.deptno = d.deptnoON e.deptno = d.deptno（on子句放的条件更随意） ANDd.loc =‘NEW YORK’WHEREd.loc =‘NEW YORK’

SELECT*FROM EMP,DEPT SELECT*FROM EMPLEFTOUTERJOINDEPT

WHERE DEPT.DEPTNO = EMP.DEPTNO(+)ON EMP.DEPTNO = DEPT.DEPTNO

(无)SELECT*FROM EMPfullOUTERJOIN DEPT ON EMP.DEPTNO = DEPT.DEPTNO （全外连接）

练习3：

1.创建一个员工表和部门表的及交叉连接 SELECT*FROM emp CROSSJOIN dept

2.使用自然连接，显示入职日期在80年5月1日之后的员工，部门名称，入职日期

SELECT ename,deptno,hiredate FROM emp NATURALJOIN dept WHERE hiredate >'01-5月-80' 3.使用USING子句显示工作地点在CHICAGO的员工姓名，部门名称，工作地点

SELECT ename,dname,loc FROM emp JOIN dept USING(deptno)WHERE loc ='CHICAGO' 4.使用ON子句显示工作地点在CHICAGO的员工姓名，部门名称，工作地点,薪资等级 SELECT ename,dname,loc,grade

FROM emp JOIN dept ON emp.deptno = dept.deptno

JOIN salgrade ON emp.sal BETWEEN salgrade.losal AND salgrade.hisal WHERE loc ='CHICAGO'

5.使用左连接查询每个员工的姓名，经理姓名，没有经理的king也要显示出来 SELECT e.ename,m.ename FROM emp e LEFTOUTERJOIN emp m ON e.mgr = m.empno 6.使用右连接查询每个员工的姓名，经理姓名，没有经理的king也要显示出来 SELECT e.ename,m.ename FROM emp m RIGHTJOIN emp e ON e.mgr = m.empno 课后作业：

1.显示smith的姓名，部门名称，直接上级名称。

SELECT e.ename,d.dname,m.ename FROM emp e ,dept d,emp m WHERE e.deptno = d.deptno AND e.mgr = m.empno AND e.ename ='SMITH'

2.显示员工姓名，部门名称，工资，工资级别，要求大于4级。 SELECT e.ename,d.dname,e.sal,s.grade FROM emp e,dept d,salgrade s WHERE e.deptno = d.deptno

AND e.sal BETWEEN s.losal AND s.hisal AND s.grade >4

4.显示员工姓名，参加工作时间，经理名，参加工作时间，要求参加时间比经理早 SELECT e.ename,e.hiredate,m.ename,m.hiredate

FROM emp e ,emp m WHERE e.mgr = m.empno

AND e.hiredate < m.hiredate

第六章分组函数

分组函数：是对表中的一组记录进行操作，每一组能返回一个结果，首先就是要对数据进行分组。组函数只能嵌套两层

MIN：可以用于任何数据类型 MAX：可以用于任何数据类型 AVG：只能用于数值型 SUM：只能用于数值型

COUNT：count *可以计入空值，其他分组函数均是去掉空值计算的！ Groupby 后面只能由两种语句：待分组的列和组函数。 相应的分组过滤字句必须是having里面的， 基础知识没有多少，直接做习题 练习1：

1.查询部门人数大于2的部门编号，部门名称，部门人数 SELECT e.deptno,d.dname,COUNT(e.empno) FROM emp e ,dept d

WHERE e.deptno = d.deptno GROUPBY e.deptno,d.dname HAVINGCOUNT(e.empno)>2 2.查询部门平均工资大于2000，且人数大于2的部门编号，部门名称，部门人数，部门平均工资，并按照部门人数升序排列

SELECT e.deptno,d.dname,COUNT(empno),AVG(sal) FROM emp e,dept d

WHERE e.deptno = d.deptno GROUPBY e.deptno,d.dname HAVINGAVG(sal)>2000 ORDERBYCOUNT(empno)

3．查询部门20 的员工，每个月的工资和及平局工资

SELECTSUM(sal)总工资,AVG(sal)平均工资FROM emp WHERE deptno ='20' 4.查询工作在CHICAGO的员工人数，最高工资及最低工资 SELECTCOUNT(e.empno),MIN(e.sal),MAX(e.sal) FROM emp e,dept d

WHERE e.deptno = d.deptno AND d.loc ='CHICAGO'

5.查询一共有集中岗位类型(去除重复记录并计数)

SELECTCOUNT(DISTINCT job)FROM emp

6.查询每个经理所管理的人数，经理编号，经理姓名，要求包括没有经理的人员信息 SELECT m.empno,m.ename,COUNT(e.empno) FROM emp e,emp m

WHERE e.mgr = m.empno(+) GROUPBY m.empno,m.ename

--1.部门平均工资在2500以上的部门名称及平均工资

SELECTAVG(e.sal),d.dname FROM emp e ,dept d WHERE e.deptno = d.deptno GROUPBY d.deptno,d.dname HAVINGAVG(sal)>2500

--2.查询岗位不以‘SA’开头，并且平均工资在2500以上的岗位及平均工资，按照工资降序

SELECT job,AVG(sal)FROM emp WHERE job <>'SA%' GROUPBY job ORDERBYAVG(sal)DESC

--3.查询部门人数在两个人以上的部门名称，最低工资，最高工资，并对工资进行四舍五入。

SELECT d.dname,round(MIN(e.sal)),round(max(e.sal)) FROM emp e,dept d WHERE e.deptno = d.deptno GROUPBY d.deptno,d.dname HAVINGCOUNT(empno)>2

--4.查询岗位不是salsesman的，工资和大于2500的每种岗位及其工资和

SELECT job,SUM(sal)FROM emp WHERE job <>'SALESMAN' GROUPBY job HAVINGSUM(sal)>2500

--5.显示经理号码，这个经理管理员工的最低工资，没有经理的king也要显示，不包括最底工资小于3000的，按最低工资由低到高排序

SELECT m.empno,min(e.sal) FROM emp e,emp m

WHERE e.mgr = m.empno(+) GROUPBY m.empno

HAVINGMIN(e.sal)>=3000 ORDERBYmin(e.sal)ASC

--6.查询每个部门的最低工资与最高工资的差额

SELECTMAX(sal)-MIN(sal)FROM emp GROUPBY deptno

第七章子查询

子查询先于主查询执行

主查询与子查询之间的运算符可以使用：= ,>,<,IN<=,>=,<>（单行子查询）， ANY,ALL（多行子查询），单行子查询：子查询的返回结果为一行一列，

多行子查询：返回结果是多行一列（包括0行，也就是0行也算多行）

多列子查询：返回的查询结果为多行多列。

子查询可以用在where，having，from 子句中。 单行子查询例题：

--1.工资最高的员工的员工姓名，工资

SELECT ename ,sal FROM emp WHERE sal =(SELECTMAX(sal)FROM emp )

--2.查询和7369相同工作的，并且工资大于7369的员工的姓名，工作，工资

SELECT ename, job,sal

FROM emp WHERE job =(SELECT job FROM emp WHERE empno =7369) AND sal >(SELECT sal FROM emp WHERE empno =7369)

--3.查询部门最低工资比20号部门最低工资高的部门编号和最低工资

SELECT deptno,MIN(sal)FROM emp GROUPBY deptno

HAVINGMIN(sal)>(SELECTMIN(sal)FROM emp WHERE deptno =20) --4.查询什么部门的人数高于各个部门的平均人数 SELECT deptno FROM emp GROUPBY deptno

HAVINGCOUNT(empno)>(SELECTavg(COUNT(empno))FROM emp GROUPBY deptno) --5.查询入职日期最早的那个员工姓名

SELECT ename FROM emp WHERE hiredate =(SELECTMIN(hiredate)FROM emp)

--6.查询工资比smith高，并且工作地点在chicago的员工姓名，工资，部门名称

SELECT e.ename,e.sal,d.dname FROM emp e,dept d WHERE e.deptno = d.deptno AND d.loc ='CHICAGO'AND e.sal >

(SELECT sal FROM emp WHERE ename ='SMITH')

--7.查询入职日期比20部门入职日期最早的员工还要早的员工姓名，入职日期

SELECT ename,min(hiredate)FROM emp WHERE hiredate <(SELECTmin(hiredate)FROM emp WHERE deptno =20)

--8.查询部门人数大于各部门平均人数的部门名称，部门编号，部门人数 SELECT d.dname,e.deptno,COUNT(e.empno)FROM emp e,dept d WHERE e.deptno(+)= d.deptno GROUPBY d.dname,e.deptno HAVINGCOUNT(empno)>

(SELECTAVG(COUNT(empno))FROM emp GROUPBY deptno)

一下练习中演示了多行子查询中多行运算符（IN 、ANY、 ALL）的应用。 --1.查询是经理的员工姓名，工资

SELECT ename,sal FROM emp WHERE empno IN(SELECT mgr FROM emp)

--2.查询部门编号不为10，且工资比10 部门中任意一个员工工资高的员工编号，姓名，职位，工资

SELECT empno,ename,job,sal FROM emp

WHERE deptno <>10AND sal >ANY(SELECT sal FROM emp WHERE deptno =10)

--3.查询部门编号不为10，且工资比10 部门中任意一个员工工资低的员工编号，姓名，职位，工资

SELECT empno,ename,job,sal FROM emp

WHERE deptno <>10AND sal

--4.查询部门编号不为10，且工资比10 部门中所有员工工资低的员工编号，姓名，职位，工资

SELECT empno,ename,job,sal FROM emp

WHERE deptno <>10AND sal

--5.查询部门编号不为10，且工资比10 部门中所有员工工资高的员工编号，姓名，职位，工资

SELECT empno,ename,job,sal FROM emp

WHERE deptno <>10AND sal >ALL(SELECT sal FROM emp WHERE deptno =10)

多列子查询：通过一下的例子可以看出，多列子查询其实就是子查询中出现了多个列！ --1.查询职位和部门与smith完全相同的人员姓名，

SELECT ename FROM emp WHERE(job,deptno)IN(SELECT job,deptno FROM emp WHERE ename ='SMITH')

保存点：使事务回滚到指定点 语法：SAVEPOINT savepointname

ROLLBACK TO savepointname

保存点不结束事务，这与rollback完全不是一回事！！！！！！！！！！

锁及数据状态

锁：在多用户并发访问和操作数据库的时候，保持数据的一致性。 锁是oracle自动管理的，数据库会在执行DML操作时会在受DML影响的行记录上自动加锁，事务结束之后才会释放锁。

事务结束之前的数据状态：可以恢复，可以用select语句查看效果，当前记录上锁，别人无法查看当前的DML操作。

事务结束之后的数据状态：数据变化永久性了，所有回话和用户均可以看到操作后的结果，锁被释放，保存点被清除。

数据合并（merge）

根据指定条件执行插入操作或者是更新操作，如果满足条件执行更新操作，如果不满足则执行插入操作。

优点：避免独立的数据更新，提高效率使用方便，数据仓库中经常使用。 MERGEINTO emp a

USING employees b ON(a.employee_id = b.employee_id) WHENMATCHEDTHEN UPDATESET

a.email = b.email,

a.phone_number = b.phone_number, a.salary = b.salary,

a.manager_id = b.manager_id,

a.department_id = b.department_id WHENNOTMATCHEDTHEN INSERT

(employee_id,email,phone_number,salary,manager_id,department_id) VALUES(b.employee_id,b.email,b.phone_number, b.salary,b.manager_id，b.department_id)

第十二章数据库网络连接

网络连接方式：

Conn用户名/口令@服务命名[as sysdba/sysoper] 其中，服务命名 =主机名：端口号：数据库服务名 网络连接协议：

TCP: 网络传输控制协议

IPC：本地进程通信机制 网络连接的条件：

服务端：配置监听器服务

启动数据库主服务

客户端：配置网络服务名。

服务器端配置监听器服务：

工具：net configuration assistant工具?这个是讲过的。 Net manager 工具

第十三章创建和维护数据库对象（DDL）

数据定义语言包括了数据结构定义语言和数据库对象定义语言。

数据库对象：表，约束，序列，索引，视图，同义词，触发器，存储过程，函数，用户等。 所有对象中只有表能够存储数据的！

对象名命名规则：字母数字下划线$和#，同一用户内不可能有两个命名完全相同的对象，名字不能使oracle的保留字，名字大小写不敏感！

创建表（约束讲完之后统一建表示例）

Default关键字：用于定义表中字段的默认值，默认值的类型必须与定义的数据类型一致。 数据类型： 字符型：

Char：固定占用10个字节，用不了的空着。

Varchar2：长度可变，最小长度为1 ，最大是4000. Clob ：可变长度：最大存储4G 数值型：

Number:既可以表示整数，也可以表示小数。 Number(n):整形

Number(m,n):总长度m，小数位n 日期型：

Date:年月日时分秒

Timestamp：精确到毫秒。 图片类型：

BLOB：最大4G的二进制的数据，存图片，声音，文件 子查询建表：

CREATETABLE manager ASSELECT*FROM emp WHERE job='MANAGER'从此两个表是没有任何关系了！

引用另一个用户的表 SELECT*FROM scott.emp 修改表（结构）

ALTER ..ADD添加列ALTERTABLE emp ADD gender CHAR(2)DEFAULT'男'

ALTER.. MODIFY 修改列列只能修改数据类型，长度及默认值。修改类型已有的行数据

必须先设置为空；修改列的长度，往大长度改没有限制，如果往小改已有的行数据必须为空。修改默认值只会影响新插入的值，以前的默认值是不变的。

ALTERTABLE emp MODIFY gender CHAR(4)或DEFAULT'女'或NUMBER

ALTER…DROP 删除列

删除列至少要留有一列，所有DDL不能回滚，删除时列中可以有数据也可以没有。被外键

引用的列不能被删除。

ALTERTABLE emp DROP（dname）注意括号

修改列的名字：

ALTERTABLE emp RENAMECOLUMN ename TONAME 删除表

DROPTABLE emp

注意：删除表之后所有的数据及结构都会被删除且无法回滚，所有的事务就会提交，所有的视图和同义词被保留但是无效，所有相关的约束索引都删除。 重命名表

RENAME emp TO empl 截断表

TRUNCATETABLE salavg 删除表数据但是保留表结构

截断表truncate和删除数据delete的区别：

Truncate：DDL；只能全部删除；释放表空间；无法回滚

Delete ：DML；可以通过where子句限定条件；数据存入回滚段里面，可以回滚。

第十四章约束

约束：保证数据完整性

约束类型：主键，外键，唯一键，非空约束，检查性约束

外键：如果在某一列上建立了外键，那么该列取值的来源只能是引用的列

只有主键和唯一键所限定的列才能作为外键的引用列。 外键不默认产生非空。 创建表和约束

CREATETABLE department (

dno CHAR(4)CONSTRAINT department_dno_pk PRIMARYKEY, dname VARCHAR(20)CONSTRAINT department_dname_uk UNIQUE, dboss VARCHAR(20)CONSTRAINTNOTNULL,

dloc CHAR(8)CONSTRAINT department_dloc_ck CHECK(dloc IN('南湖校区','浑南校区')) )

CREATETABLECLASS (

cno NUMBER(4), cname VARCHAR(20), dno CHAR(4),

CONSTRAINT class_cno_pk PRIMARYKEY(cno), CONSTRAINT class_cname_uk UNIQUE(cname),

CONSTRAINT class_dno_fk FOREIGNKEY(dno)REFERENCES department (dno) )

外键中的删除

ONDELETECASCADE：父表删除，级联删除子表。

ONDELETESETNULL：父表删除，子表想依赖的行设为空值。

约束的启用与禁用

在大量数据迁移的时候需要禁用启用约束

ALTERTABLE emp DISABLECONSTRAINT emp_empno_pk ALTERTABLE emp ENABLECONSTRAINT emp_empno_pk 追加删除约束，添加非空约束

ALTERTABLE emp ADDCONSTRAINT emp_empno_pk PRIMARYKEY(empno) ALTERTABLE emp MODIFY ename NOTNULL

ALTERTABLE emp DROPUNIQUE(eno)|CONSTRAINT约束名 [CASCADE]CASCADE级联删除相关外键

第十五章视图

六种数表：用来存储用户数据的对象，由行和列组成，也就是字段和记录

据库对象约束：保证数据完整性的规则。约束设置在单个字段或是多个字段的组合上。 视图：虚表，是一个命名的查询，用于改变基表的数据显示，简化查询。 索引：构建于表的单字段或是字段组合，用于加速表中的数据查询。 序列：差生顺序的不重复的数字串，被作为主键约束的参照。 同义词：数据库对象的别名

创建视图语法：

CREATE [ORREPLACE] [FORCE|NOFORCE] VIEW viewname AS subquery

[WITHCHECKOPTION [CONSTRAINT constraintname]] [WITHREADONLY]

REPLACE：有这个视图责备替换

[FORCE|NOFORCE]： 如果基表不存在，强制建立视图 Subquery：子查询 [WITHCHECKOPTION [CONSTRAINT constraintname]]：首先视图是可以执行DML操作的，如果

执行的操作在视图中没有显示就会插入失败，如果视图中可以看到则会插入失败。 [WITHREADONLY]不执行DML语句

第一章：认识Java

毕向东Java基础视频复习笔记

线程

单例设计模式：（多线程与静态结合） 饿汉式：（实例提前加载） class SingleDemo1 {

Private static final SingleDemo1 s = new SingleDemo1(); Private SingleDemo1(){}

Public static SingleDemo1 getInstance()

{

Return s; } }

懒汉式：(实例的延迟加载) Class SingleDemo2 {

Private static SingleDemo2 s = null; Private SingleDemo(){}

Public staticsynchronizedSingleDemo2 getInstance() If(s==null) {

S = new SingleDemo2(); }

Return s; }

懒汉式在多线程创建对象的时候就会出现安全隐患。因此应该在懒汉式上加锁！但是加上同步函数之后，运行比较低效，因此采用同步代码块。修改如下： Class SingleDemo2 {

Private static SingleDemo2 s = null; Private SingleDemo(){}

Public static SingleDemo2 getInstance() {

If (s == null) {

Synchronized(Single.class)//在静态方法中，锁是该类所属的字节码文件。相比较，{步函数用的是this的锁 If(s==null)

S = new SingleDemo2(); } }

Return s; } }

死锁：

package com.neuedu.shuang.thread; class Test implements Runnable {

booleanflag = true;

Test(boolean flag)//用构造函数设置boolean值控制线程分别从if和else中进入。 {

this.flag = flag; }

publicvoid run()//死锁就是两个同步套用同步！所调用的锁正好相反 {

if(flag) {

synchronized(MyLock.lock1) {

System.out.println(\); synchronized(MyLock.lock2) {

System.out.println(\); } } } else {

synchronized(MyLock.lock2) {

System.out.println(\); synchronized(MyLock.lock1) {

System.out.println(\); } } } } }

class MyLock {

static Object lock1 = new Object();//静态方纯属便调用 static Object lock2 = new Object(); }

publicclass DeadLockTest {

publicstaticvoid main(String[] args) {

Thread t1 = new Thread(new Test(true)); Thread t2 = new Thread(new Test(false)); t1.start(); t2.start(); } }

线程间通信

COMMON SENSE：线程安全出现问题之后要加同步（synchronized），加上同步问题没有解决要看两个前提：第一，是不是两个或是两个以上线程；第二，用的是否是同一个锁。 线程间通信：其实就是多个线程操作同一个资源，但是操作的动作不一样。 package com.neuedu.shuang.thread; class Resource//定义一个共有资源 {

String name; String sex; }

class Input implements Runnable//输入方法实现Runnable接口 {

private Resource re;

Input(Resource re)//构造方法传值初始化，防止一个类new一个对象，那样资源就不共享了 {

this.re = re; }

publicvoid run() {

int x = 0;

while(true)//死循环多次输入 {

if(x == 0) {

re.name = \; re.sex = \; } else {

re.name = \王爽\; re.sex = \女\; }

x = (x+1)%2;//x在0和1之间互换，实现交替输出 } } }

class Output implements Runnable//输出方法同上 {

private Resource re; Output(Resource re) {

this.re = re; }

publicvoid run() {

while(true) {

System.out.println(re.name+\+re.sex); } } }

publicclass InputOutputDemo {

publicstaticvoid main(String[] args) { // TODO Auto-generated method stub

Resource r = new Resource();//建立对象资源

Input in = new Input(r);//实例化实现了runnable接口的方法， Output out = new Output(r);

Thread t1 = new Thread(in);//建立两个线程 Thread t2 = new Thread(out);

t1.start();//线程开启 t2.start(); } }

这个线程间通信的小程序没有实现线程之间的同步！所以线程是不安全的！会输出如下结果：“王爽 male\\n John 女”等。

实现线程之间同步的代码如下，主要解决如下问题：将要加上锁的那一部分语句找出来，synchronized的位置要加对，锁所引用的对象要一致。 package com.neuedu.shuang.thread; class Resource//定义一个共有资源 {

String name; String sex; }

class Input implements Runnable//输入方法实现Runnable接口 {

private Resource re;

Input(Resource re)//构造方法传值初始化，防止一个类new一个对象，那样资源就不共享了 {

this.re = re; }

publicvoid run() {

int x = 0;

while(true)//死循环多次输入 {

synchronized (re) {//锁

if(x == 0) {

re.name = \; re.sex = \; } else {

re.name = \王爽\; re.sex = \女\; } }

x = (x+1)%2;//x在0和1之间互换，实现交替输出 } } }

class Output implements Runnable//输出方法同上 {

private Resource re; Output(Resource re) {

this.re = re; }

publicvoid run() {

while(true) {

synchronized(re){ //锁 System.out.println(re.name+\+re.sex); } } } }

publicclass InputOutputDemo {

publicstaticvoid main(String[] args) { // TODO Auto-generated method stub

Resource r = new Resource();//建立对象资源

Input in = new Input(r);//实例化实现了runnable接口的方法， Output out = new Output(r)；

Thread t1 = new Thread(in);//建立两个线程 Thread t2 = new Thread(out);

t1.start();//线程开启 t2.start(); } }

上面的这个小程序虽然实现了同步，但是出现了一个严重的问题，就是input得到执行权之后会不停的输入并覆盖，而output得到执行权之后会不停打印同一内容，此时需要等待唤醒机制，注意：等待（wait）的线程都会在线程池里面！

Wait().notify();notifyAll()都位于Object类里面，而不是定义在Thread类里面，因为等待、唤醒都需要用同步的对象进行引用，而同步可以用于所有对象，所以这三个方法都要定义在祖宗类里面。并且都要用在同步（synchronized）的里面，因为要对监视器（锁进行操作）。

如下实现等待唤醒代码：

package com.neuedu.shuang.thread; class Resource//定义一个共有资源 {

String name; String sex;

booleanflag = false; }

class Input implements Runnable//输入方法实现Runnable接口 {

private Resource re;

Input(Resource re)//构造方法传值初始化，防止一个类new一个对象，那样资源就不共享了 {

this.re = re; }

publicvoid run() {

int x = 0;

while(true)//死循环多次输入 {

synchronized (re) {//等待

if(re.flag){try {re.wait();} catch (InterruptedException e) { e.printStackTrace();}} if(x == 0) {

re.name = \; re.sex = \; } else {

re.name = \王爽\; re.sex = \女\; }

x = (x+1)%2;//x在0和1之间互换，实现交替输出 re.flag = true;

re.notify();//唤醒 }

} } }

class Output implements Runnable//输出方法同上 {

private Resource re; Output(Resource re) {

this.re = re; }

publicvoid run() {

while(true) {

synchronized(re) {

if(!re.flag)//等待

try {re.wait();} catch (InterruptedException e) {e.printStackTrace();} System.out.println(re.name+\+re.sex); re.flag = false;

re.notify();//唤醒 } } } }

publicclass InputOutputDemo {

publicstaticvoid main(String[] args) { // TODO Auto-generated method stub

Resource r = new Resource();//建立对象资源

Input in = new Input(r);//实例化实现了runnable接口的方法， Output out = new Output(r);

Thread t1 = new Thread(in);//建立两个线程 Thread t2 = new Thread(out);

t1.start();//线程开启 t2.start(); } }

以上修改的程序就实现了线程通信的交替执行，通过的等待（wait）唤醒（notify）机制。但是以上代码并不简洁，需要对代码进行优化！ package com.neuedu.shuang.thread; class Resource//定义一个共有资源 {

private String name; private String sex;

privatebooleanflag = false;

publicsynchronizedvoid setResource(String name,String sex) {

if(flag){try{this.wait();}catch(InterruptedException e){}} this.name = name; this.sex = sex; this.flag = true; this.notify(); }

publicsynchronizedvoid show() {

if(!flag){try{this.wait();}catch(InterruptedException e){}} System.out.println(this.name+\+this.sex); this.flag = false; this.notify(); } }

class Input implements Runnable//输入方法实现Runnable接口 {

private Resource re;

public Input(Resource re) {

this.re = re; }

publicvoid run() {

int x = 0;

while(true)//死循环多次输入 {

if(x == 0)

re.setResource(\, \); else

re.setResource(\, \); x = (x+1)%2;//x在0和1之间互换，实现交替输出 } } }

class Output implements Runnable//输出方法同上 {

private Resource re;

public Output(Resource re) {

this.re = re; }

publicvoid run() {

while(true){re.show();} } }

publicclass InputOutputDemo {

publicstaticvoid main(String[] args) { // TODO Auto-generated method stub }

Resource r = new Resource();//建立对象资源 new Thread((new Input(r))).start(); new Thread((new Output(r))).start(); }

集合类

集合框架的概述 为什么会有集合类？

因为面向对象的语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就需要对对象进行存储，集合就是用来存储数据对象的。 集合类与数组的不同？

集合长度可变；数组长度不可变。

集合只能存储对象，数组可以存储基本数据类型。 集合类的特点？

只能存储对象，可以存储不同类型的对象，长度可变。 arraylist List linkedlist vector

Collection hashset （util包） Set treeset 每一个集合的数据结构是不同的

学习面向对象的编程学习方法：要先学习父类，学完父类用子类中的方法 1.集合框架中的共性方法介绍，与代码示例： package collection;

import java.util.ArrayList; publicclass CollectionDemo {

publicstaticvoid main(String[] args) {

//创建一个集合类

ArrayList al = newArrayList(); ArrayList ar = newArrayList(); //添加元素

al.add(\);//add的意思就是往集合里面加入对象的引用（地址值） al.add(\); }

}

al.add(\); al.add(\); //添加元素

ar.add(\); ar.add(\); ar.add(\); //RetainAllDemo(al,ar); RemoveAllDemo(al,ar);

sop(al);//打印集合

sop(\+al.size());//获取集合长度 al.remove(\);//删除集合中的元素 sop(al);//打印集合 al.clear();//清空集合

al.isEmpty();//判断集合是否为空，返回布尔值

al.contains(\);//判断集合中是否含有相应对象。

//显示函数

privatestaticvoid sop(Object obj) { // TODO Auto-generated method stub System.out.println(obj); }

//集合交集运算

publicstaticvoid RetainAllDemo(ArrayList al1,ArrayList al2) {

sop(al1);//交集之前的al全部显示 sop(al2);//交集之前的ar全部显示

sop(al1.retainAll(al2));//交集运算的返回值为boolean性 sop(al1);//al中保存的是交集运算后的结果[java01,java04] }

publicstaticvoid RemoveAllDemo(ArrayList al1,ArrayList al2) { }

sop(al1);//交集之前的al全部显示 sop(al2);//交集之前的ar全部显示

sop(al1.removeAll(al2));//移除部分运算博哦了按性

sop(al1);//al中保存的是移除运算后的结果[java02, java03]

2.迭代器的使用：

iterator接口型的引用只能指向子类对象！！，而这个对象又不能new出来！只能通过集合类的方法获取。

Iteratorit = al.iterator(); while(it.hasNext()) {

it.next();

}

注意：每个容器中的数据结构有所不同，所以对容器内部对象的操作最方便的就是定义一个集合的内部类，这样取出方式那就好可以直接访问容器内部的元素。虽然每一个容器的动作细节不一样，但是他们有一样的判断和取出的功能，因此就把这两部分功能抽象成了集合内部的iterator（）方法。 Iterator（）

判判判

断断断

提提提

取 取 取

迭代器的更高水平的应用：(it变成了局部变量，用完立即释放，不会占用内存空间) for(Iteratorit = al.iterator();it.hasNext(); ) {

al.next(); }

3. List集合的特有的共性方法

|--List：元素是有序的，并且元素可以重复，因为内部有索引。 |--set：元素是无序的，元素是不可以重复的，因为内部没有索引。 List集合的特有方法，特有的就是跟角标相关的方法： 增

Add(index,element);addAll(index,collection) 删

Remove(index); 改

Set(index,elemnt)

查

List中特有方法代码示例：

Get(index);sublist(from , to);listIterator(); package collection; import java.util.*; publicclass listDemo {

publicstaticvoid sop(Object obj) {

System.out.println(obj); }

publicstaticvoid main(String[] args) {

}

// TODO Auto-generated method stub ArrayList al = newArrayList(); al.add(\);//依次添加元素 al.add(\); al.add(\); al.add(\); al.add(\); al.add(\); sop(al);//打印原集合； al.add(2, \); sop(al);//打印插入之后的集合； al.remove(2);//删除指定位置的元素

al.set(2, \);//修改指定位置上的元素 al.get(1);//取出指定位置的集合。 for(int x = 0;x < al.size();x++){ al.get(x);//循环取出。 }

//通过indexOf获取角标

sop(al.indexOf(\));

//subList取出拿头去尾

List sb = al.subList(0, 1); sop(sb); }

4.List集合特有的迭代器ListIteartor列表迭代器

ListIteartor是Iterator的子接口，通过列表迭代器可以实现在集合便利过程中的增删改查！！！ 先用一组代码说明没有列表迭代器的不方便： package collection;

import java.util.ArrayList; import java.util.Iterator;

publicclass ListIteratorDemo {

publicstaticvoid sop(Object obj) {

System.out.println(obj); }

publicstaticvoid main(String[] args) { // TODO Auto-generated method stub ArrayList al = newArrayList();

al.add(\);//依次添加元素 al.add(\); al.add(\); al.add(\); al.add(\);

al.add(\); //在迭代的过程中，添加或是删除元素 Iterator it = al.iterator(); while(it.hasNext()){//迭代器的判断方法 Object obj = it.next(); if(obj.equals(\)){

al.add(\);//集合的添加方法，这个与迭代器的判断方法并发访问集合，报并发异常！

it.remove();//迭代器的删除操作 }

sop(\+obj );//打印引用，全部显示 }

sop(al);//打印集合发现已经删除 } }

然后用列表迭代器实现以下，因为用列表迭代器可以有增删改查更加多样的功能，增删改查都用列表迭代器，这样还可以消除并发访问的异常！！！！ package collection;

import java.util.ArrayList; import java.util.*;

publicclass ListIteratorDemo {

publicstaticvoid sop(Object obj) {

System.out.println(obj); }

publicstaticvoid main(String[] args) { // TODO Auto-generated method stub ArrayList al = newArrayList();

al.add(\);//依次添加元素 al.add(\); al.add(\); al.add(\); al.add(\); al.add(\); //在迭代的过程中，添加或是删除元素

ListIterator li = al.listIterator(); while(li.hasNext()){//列表迭代器的判断方法，

Object obj = li.next();//列表迭代器中的next方法。 if(obj.equals(\)){

li.add(\);//列表迭代器中的添加方法， //li.set(\列表迭代器中的修改功能。 }

sop(\+obj );//打印引用，返现显示原来的集合元素就是，添加仅仅是添加了引用，

}

/*while(li.hasPrevious()){从后往前遍历修改。 Object obj = li.previous(); if(obj.equals(\ li.set(\ } }*/

sop(al);//打印集合发现已经添加 } }

5.List子类的简单介绍

ArrayList:底层数据结构为数组，查询速度快，增删改速度慢，是线程不同步的 LinkedList:底层数据结构W为链表，查询速度慢，增删改速度快。

Vector:底层数据结构为数组，查询速度慢，增删改速度也慢，因为是线程同步的。 6.Vector容器中的枚举

Vector迭代器，遍历循环get方法，按照角标索引，枚举 package collection;

import java.util.Enumeration; import java.util.Vector; publicclass vectorDemo {

publicstaticvoid sop(Object obj){ System.out.println(obj); }

publicstaticvoid main(String[] args) { // TODO Auto-generated method stub }

}

Vector v = newVector();//new一个VECTOR容器 v.add(\);//王容器里面加元素 v.add(\); v.add(\); Enumeration en = v.elements();//容器特有的迭代器---枚举！ while(en.hasMoreElements()){

System.out.println(en.nextElement()); }

6.LinkedList中的方法介绍与代码示例 package collection;

import java.util.LinkedList; publicclass linkedListDemo {

publicstaticvoid main(String[] args) { // TODO Auto-generated method stub LinkedList link = newLinkedList();

link.offerFirst(\);//每次都往头部添加

link.offerFirst(\);//1.6以前用addFirst link.offerFirst(\);

link.offerLast(\);//每次都往尾部添加 link.offerLast(\);//1.6以前用addLast link.offerLast(\); sop(link);

//1.6以前删除元素用removeFirst。区别：poll遇到空容器返回null，而remove则抛出异常。

sop(link.pollFirst());//删除原集合的头部元素，并且获取删除的元素。 sop(link.pollLast());//删除原集合尾部元素，并且获取删除的元素。

//1.6以前用getFirst，区别：peek遇到空容器返回null，而get则抛出异常。 sop(link.peekFirst());//获取头部元素不删除。 sop(link.peekLast());//获取尾部元素不删除。 }

publicstaticvoid sop(Object obj) { System.out.println(obj); } }

7.练习：用LinkedList模拟一个队列，堆栈的数据结构 队列：先进先出Queue 堆栈：先进后出Stack package collection;

import java.util.LinkedList;

class Queue//基于LinkedList类构建一个队列，意思就是要把它封装成一个类，对外暴露方法 {

privateLinkedListlink;

Queue(){//构造方法类加载而自动创建一个链表对象 link = newLinkedList(); }

publicvoid myAdd(Object obj){ link.offerFirst(obj); }

public Object myGet(){ returnlink.peekLast(); }

publicboolean myIsEmpty() {

returnlink.isEmpty(); } }

publicclass queueStack {

publicstaticvoid main(String[] args) {

}

}

// TODO Auto-generated method stub Queue q = new Queue(); q.myAdd(\); q.myAdd(\); q.myAdd(\);

System.out.println(q.myGet());

8.练习：去除ArrayList中的重复元素 package collection; import java.util.*;

class single{//讲方法封装成一个类

publicstaticArrayList getSingleElement(ArrayList al){ ArrayList ar = newArrayList(); for(Iterator it = al.iterator();it.hasNext();){ Object obj = it.next(); if(!ar.contains(obj)){//判断ar里面有没有obj ar.add(obj);//没有就加，有就不加。 } }

return ar; } }

publicclass SingleElement {

publicstaticvoid main(String[] args) { // TODO Auto-generated method stub ArrayList al = newArrayList(); al.add(\); al.add(\); al.add(\); al.add(\); System.out.println(single.getSingleElement(al)); } }

9.练习：将自定义对象存入ArrayList中并去除重复对象

本文来源：https://www.bwwdw.com/article/the7.html