考点1:

关于下面代码 int[] x=new int[25]; 描述正确的是()

  • A x[25]存放了数据“\0”。
  • B x[24] 存放了数据“\0”。
  • C 若访问x[25],程序将抛出异常。
  • D x[1]访问此数组的第一个元素。
显示答案/隐藏答案正确答案: C

A:不存在x[25] 索引从0开始到length-1
B:x[24]
存的是默认值0(java中没有’\0’这一说)
C:超出内存 正确
D:第二元素

考点2:

下列哪个语句语法正确?( )

  • A byte y = 11; byte x = y +y;
  • B String x = new Object();
  • C Object x = new String(“Hellow”);
  • D int a [11] = new int [11];
显示答案/隐藏答案正确答案: C

正确答案是C

对于A,前一半语句赋值是没有问题的,问题是后半句,在对byte型的变量进行相加时,会先自动转换为int型进行计算,所以计算结果也是int型的,int型赋值给byte需要强制转换,所以A会出错

对于B,因为object是String的父类,所以不能这样使用,不能把父类对象赋值给子类,只能是Object x = new String();

对于C,因为String是Object的子类,所以可以将子类赋值给父类。

对于D,因为在声明变量时不需要指定容量,例如int a[] = new int[11];这样是正确的,但是像D选项这样是错误的

选C。该题考查的是数据类型转换以及转换原则和取值范围
A选项属于赋值和算术运算的转换:byte取值范围-128~127,所以byte y = 11正确;byte x = y +y基本就是先转换为高位数据类型,再参加运算,结果也是最高位的数据类型, byte short char运算会转换为int,所以错误。
B选项是多态的条件应用:1.要有继承;2.要有重写;3.父类引用指向子类对象。Object是一切类的基类,正确的写法应该是:Object x=new String()。所以B选项错误。
D选项
声明数组变量
的错误,正确的应该是int a []或者int[] a。所以D错误。

考点3:

This调用语句必须是构造函数中的第一个可执行语句。

  • A 正确
  • B 错误
显示答案/隐藏答案正确答案: B

this()才必须是构造函数中的第一个可执行语句,用this调用语句并不需要。

考点4:

下列哪些语句关于内存回收的说明是正确的? ( )

  • A 程序员必须创建一个线程来释放内存
  • B 内存回收程序负责释放无用内存
  • C 内存回收程序允许程序员直接释放内存
  • D 内存回收程序可以在指定的时间释放内存对象
显示答案/隐藏答案正确答案: B

A : JVM会自己创建垃圾回收线程;
B :内存回收线程的作用,正确;
C :程序员无法释放内存,程序员最多是使用System.gc()和Runtime.getRuntime().gc()通知系统释放内存;
D:系统释放内存时间是不确定的,会根据当前程序的内存使用情况而定。

img

考点5:

下列语句中,正确的是

  • A float x=0.0
  • B boolean b=3>5
  • C char c=”A”
  • D double =3.14
显示答案/隐藏答案正确答案: B
在java里面 float类型数据类型初始化时必须使用后缀f 因为java默认浮点型是double 用后缀f表示为float类型; A应为:float x = 0.0f; 布尔值可以是一个表达式的值,但必须是一个true或者false值 B正确 char只能是一个字符 而不是一个字符串 C应为:char c='A'; D没变量名...没变量名...没变量名...重要的事情说三遍

考点6:

1
2
3
4
5
6
7
8
9
10
public class CharToString {
public static void main(String[] args)
{
char myChar = 'g';
String myStr = Character.toString(myChar);
System.out.println("String is: "+myStr);
myStr = String.valueOf(myChar);
System.out.println("String is: "+myStr);
}
}

此代码片段输出正确的值是()

  • A
    1
    2
    String is: g
    String is: g
  • B
    1
    2
    String is: 103
    String is: g
  • C
    1
    2
    String is: g
    String is: 103
  • D
    1
    2
    String is: 103
    String is: 103
显示答案/隐藏答案正确答案: A
1
2
3
4
5
6
7
8
public static String toString(char c) {
return String.valueOf(c);
}

public static String valueOf(char c) {
char data[] = {c};
return new String(data, true);
}

返回的都是字符串,只有char变成 int 的时候才会变为对应的assic码

考点7:

已知x >= y and y >= z 为真,那么x > z or y = z 值为

  • A 真
  • B 假
  • C 无法确定
  • D x y z同为正数时为真
显示答案/隐藏答案正确答案: C

答案应该是C
条件可以简单分析为数学不等式 x>=y>=z,那么x>z不一定为true
当x>z为true,后面的条件忽略,结果为真;
当x==z,x>z为fslae,继续判断后一个条件

  • 如果z==0,则y=z为false,结果为假;
  • 如果z!=0,则y=z为true,结果为真;
    所以,最后的结果是不确定的。

考点8:

以下哪些表达式返回为真()

1
2
3
4
String a="My field1";
String b="My field1";
String c=new String("My field1");
String d=new String("My field1");
  • A a==b
  • B a==c
  • C c=d
  • D a.equals(b)
  • E a.equals(c)
显示答案/隐藏答案正确答案: ADE

考点9:

下列正确的有()

  • A call by value不会改变实际参数的数值
  • B call by reference能改变实际参数的参考地址
  • C call by reference不能改变实际参数的参考地址
  • D call by reference能改变实际参数的内容
显示答案/隐藏答案正确答案: ACD

选ACD。该题考察的是值传递和引用传递参数的调用。

  • 值传递是将变量的一个副本传递到方法中,方法中如何操作该变量副本,都不会改变原变量的值。
  • 引用传递是将变量的内存地址传递给方法,方法操作变量时会找到保存在该地址的变量,对其进行操作。会对原变量造成影响。

考点10:

以下说法哪个是正确的()

  • A IOException在编译时会被发现
  • B NullPointerEception在编译时不被发现
  • C SQLException在编译时会被发现
  • D FileNotFoundException在编译时会被发现
显示答案/隐藏答案正确答案: ABCD

Java的异常分为两种,一种是运行时异常(RuntimeException),一种是非运行异常也叫检查式异常(CheckedException)。
1、运行时异常不需要程序员去处理,当异常出现时,JVM会帮助处理。常见的运行时异常有:

  • ClassCastException(类转换异常)
  • ClassNotFoundException
  • IndexOutOfBoundsException(数组越界异常)
  • NullPointerException(空指针异常)
  • ArrayStoreException(数组存储异常,即数组存储类型不一致)
  • 还有IO操作的BufferOverflowException异常

2、非运行异常需要程序员手动去捕获或者抛出异常进行显示的处理,因为Java认为Checked异常都是可以被修复的异常。常见的异常有:

  • IOException
  • SqlException

考点1:

对象间存在一对多关系,当一个对象被修改时,则会自动通知它的依赖对象,采用以下哪种设计模式最好?

  • A 建造者模式
  • B 观察者模式
  • C 策略模式
  • D 代理模式
显示答案/隐藏答案正确答案: B

考点2:

如果需要一个语言解释执行,并且可以将语言中的句子表示为一个抽象语法树的时候,对效率要求不高的情况下,应该选择何种设计模式?

  • A 解释器模式
  • B 动态代理模式
  • C 装饰模式
  • D 访问者模式
显示答案/隐藏答案正确答案: A

考点3:

如果强调一系列相关产品的接口,以便联合使用它们的时候,应该选择何种设计模式:

  • A 模板方法模式
  • B 备忘录模式
  • C 抽象工厂模式
  • D 组合模式
显示答案/隐藏答案正确答案: C

考点4:

如果让你来实现前端的MVVM框架,View层需要支持不同终端的不同交互,下面哪些设计模式不太适合用来实现这个需求()

  • A 单例模式
  • B 观察者模式
  • C 适配器模式
  • D 代理模式
显示答案/隐藏答案正确答案: A

考点5:

下图的UML类结构图表示的是哪种设计模式?

img

  • A 解释器模式
  • B 装饰模式
  • C 桥接模式
  • D 责任链模式
显示答案/隐藏答案正确答案: D

考点6:

下面的选项中哪些属于工厂模式()

  • A 静态工厂模式
  • B 工厂方法模式
  • C 抽象工厂模式
  • D 简单工厂模式
显示答案/隐藏答案正确答案: BCD

考点7:

下列描述中,哪些是外观模式的特点( )

  • A 对客户端屏蔽了子系统组件
  • B 实现了子系统与客户端之间的紧耦合关系
  • C 单个子系统的修改不影响其他子系统
  • D 子系统类变化时,只需要修改外观类即可
显示答案/隐藏答案正确答案: ACD

考点8:

以下设计模式的应用场景中,属于代理模式的选项有()

  • A 树形结构的遍历
  • B 产品簇创建场景
  • C 防火墙
  • D CopyOnWriteList
显示答案/隐藏答案正确答案: CD

考点1:this调用语句

This调用语句必须是构造函数中的第一个可执行语句。

  • A 正确
  • B 错误
显示答案/隐藏答案正确答案: B

this()才必须是构造函数中的第一个可执行语句,用this调用语句并不需要。

考点2:成员内部类

内部类(也叫成员内部类)可以有4种访问权限。( )

  • A 正确
  • B 错误
显示答案/隐藏答案正确答案: A

你就把内部类理解成类的成员,成员有4种访问权限吧,内部类也是!分别为private、protected、public以及默认的访问权限

考点3:CallableStatement PreparedStatement Statement

以下描述正确的是

  • A CallableStatement是PreparedStatement的父接口
  • B PreparedStatement是CallableStatement的父接口
  • C CallableStatement是Statement的父接口
  • D PreparedStatement是Statement的父接口
显示答案/隐藏答案正确答案: B

Statement 每次执行sql语句,数据库都要执行sql语句的编译 ,最好用于仅执行一次查询并返回结果的情形,效率高于PreparedStatement.

PreparedStatement是预编译的,使用PreparedStatement有几个好处
a. 在执行可变参数的一条SQL时,PreparedStatement比Statement的效率高,因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率要高。
b. 安全性好,有效防止Sql注入等问题。
c. 对于多次重复执行的语句,使用PreparedStament效率会更高一点,并且在这种情况下也比较适合使用batch;
d. 代码的可读性和可维护性。

CallableStatement接口扩展PreparedStatement,用来调用存储过程,它提供了对输出和输入/输出参数的支持。CallableStatement
接口还具有对 PreparedStatement 接口提供的输入参数的支持。

1
2
public interface CallableStatement
extends PreparedStatement
1
2
public interface PreparedStatement
extends Statement
1
2
public interface Statement
extends Wrapper, AutoCloseable

考点4:多态方法调用

Test.main()函数执行后的输出是( )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Test {
public static void main(String[] args) {
System.out.println(new B().getValue());
}
static class A {
protected int value;
public A (int v) {
setValue(v);
}
public void setValue(int value) {
this.value= value;
}
public int getValue() {
try {
value ++;
return value;
} finally {
this.setValue(value);
System.out.println(value);
}
}
}
static class B extends A {
public B () {
super(5);
setValue(getValue()- 3);
}
public void setValue(int value) {
super.setValue(2 * value);
}
}
}
  • A 6 7 7
  • B 22 34 17
  • C 22 74 74
  • D 11 17 34
显示答案/隐藏答案正确答案: B

始终优先调用子类重写的方法

本题中,始终需要遵循一个原则,即: 调用的方法都是实例化的子类中的重写方法,只有明确调用了super.xxx关键词或者是子类中没有该方法时,才会去调用父类相同的同名方法

这道题的知识点:子类中的方法覆盖父类的方法以后,由于向上转型,父类调用方法的时候是调用子类的,除非用super。
还有一个点就是在Try catch finally 体系当中,在return之前始终会执行finally里面的代码,如果finally里面有return,则数据跟随finally改变。如果没有return,则原数据不跟随finally里改变的数据改变!

main方法中只有一条System.out.println(new B().getValue());语句

先执行new B()

new B()

B类
1
2
3
4
public B () {
super(5);//<--执行这句
setValue(getValue()- 3);
}

super(5);

A类
1
2
3
public A (int v) { //v=5
setValue(v);//v=5
}

因为new的对象是B,执行的是子类重写的setValue():

B类
1
2
3
public void setValue(int value) {//v=5
super.setValue(2 * value);//2*value=2*5=10
}

这里明确使用了super关键字,所以调用父类的setValue方法:

A类
1
2
3
public void setValue(int value) {//value=10
this.value= value;//value=10,this.value=10
}

到这里super(5);算是执行完毕了,继续执行下一句:

B类
1
2
3
4
public B () {
super(5);//<--执行完毕
setValue(getValue()- 3);//<--执行
}

执行 setValue(getValue()- 3);

先执行getValue()方法,B类中并没有有定义getValue()方法,所以调用的是父类的getValue方法:

先执行getValue的try语句块

public int getValue() {
    try {
        value ++;//1. value=10,value++之后value=11
        return value;//2 return 11; 
    } finally {
        this.setValue(value); //3. 当前对象是B类的对象,调用B类的setValue方法,value=11
        System.out.println(value);
    }
}

try块中有return语句,getValue的返回值为11

然后执行finally语句块。

先执行this.setValue(value);

public void setValue(int value) {// value=11
    super.setValue(2 * value);//2 * value=2 *11=22,接着调用父类的setValue方法
}

调用父类的setValue方法

public void setValue(int value) {// value=22
    this.value= value;//this.value=22
}

然后执行System.out.println(value);输出22

getValue()执行完毕,返回值11

1
2
3
4
public B () {
super(5);
setValue(getValue()- 3);//getValue=11,getValue()- 3=11-3=8
}

执行setValue(8),当前对象有setValue方法,调用B类定义的setValue方法:

1
2
3
public void setValue(int value) {//value=8
super.setValue(2 * value);//2 * value=2*8=16
}

执行父类的setValue方法:

public void setValue(int value) {//value=16
    this.value= value;//this.value=16
}

到这里,new B()执行完毕。this.value=16

然后执行new B().getValue()

然后执行new B().getValue()
子类B中没有这个方法,调用父类继承来的getValue方法

先执行try块:

1
2
3
4
5
6
7
8
9
public int getValue() {
try {
value ++;//this.value=16 value++之后 this.value=17
return value;//getValue()返回值是17
} finally {
this.setValue(value);
System.out.println(value);
}
}

然后执行finally块:

1
2
3
4
5
6
7
8
9
public int getValue() {
try {
value ++;//this.value=17
return value;//getValue()返回值是17
} finally {
this.setValue(value);//value=17
System.out.println(value);
}
}

先调用当前类的setValue方法:

1
2
3
public void setValue(int value) {//value=17
super.setValue(2 * value);//2 * value=2 * 14=34
}

调用父类的setValue方法:

public void setValue(int value) {//value=24
    this.value= value;//this.value=34
}

然后执行 System.out.println(value);语句,输出34

到这里new B().**getValue()**已经执行完毕,getValue()返回17.

最后执行最外层的数据语句

1
2
3
public static void main(String[] args) {
System.out.println(new B().getValue());//17
}

输出17

考点5:JRE判断程序执行结束的标准 前台线程 后台线程

jre 判断程序是否执行结束的标准是()

  • A 所有的前台线程执行完毕
  • B 所有的后台线程执行完毕
  • C 所有的线程执行完毕
  • D 和以上都无关
显示答案/隐藏答案正确答案: A

前台线程 后台线程 用户线程 守护线程

其实这个题,就是在说守护线程和非守护(用户)线程的问题。后台线程就是守护线程,前台线程就是用户线程。
守护线程:是指在程序运行时在后台提供一种通用服务的线程,这种线程并不是必须的。同时守护线程的线程优先级都很低的。JVM中的GC线程就是一个守护线程,只要JVM启动,GC线程就启动了。

用户线程和守护线程几乎没有什么区别,唯一的区别就在于,如果用户线程都已经退出了,只剩下了守护线程,那么JVM直接就退出了

下面举个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class ThreadDemo extends Thread {
public void run() {
System.out.println(Thread.currentThread().getName() + " : begin");
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " : end");
}
}

public class Test {
public static void main(String[] args) {
System.out.println("test : begin");
Thread t = new ThreadDemo();
t.setDaemon(true);
t.start();
System.out.println("test : end");
}
}

程序输出:

1
2
test : begin
test : end

运行结果中不会有Thread-0 : end,是因为,守护线程开启之后,中间睡了2s,这个时候又没有锁,主线程直接就执行完了,
一旦主线程结束,那么JVM中就只剩守护线程了,JVM直接就退出了,不管你守护线程有没有执行完。

jre判断程序是否执行结束的标准是:所有的前台线程执行完毕。

考点6:自增运算符

以下代码执行的结果显示是多少()?

1
2
3
4
5
6
7
8
9
10
11
public class Demoe {
public static void main(String[] args) {
int count = 0;
int num = 0;
for (int i = 0; i <= 100; i++) {
num = num + i;
count = count++;
}
System.out.println("num * count=" + (num * count));
}
}
  • A num * count = 505000
  • B num * count = 0
  • C 运行时错误
  • D num * count = 5050
显示答案/隐藏答案正确答案: B

count = count++;这个先将count这个值0暂存起来,然后count自加1变成1,最后将暂存的值赋值给count,count最终的值为0

考点7:类的加载顺序:先静态后非静态 先父类后子类

关于下列代码的执行顺序,下面描述正确的有哪些选项()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class HelloA {
public HelloA() {
System.out.println("A的构造函数");
}
{
System.out.println("A的构造代码块");
}
static {
System.out.println("A的静态代码块");
}
public static void main(String[] args) {
HelloA a = new HelloA();
}
}
  • A 打印顺序A的静态代码块> A的构造函数
  • B 打印顺序A的静态代码块> A的构造代码块
  • C 打印顺序A的构造代码块> A的构造函数
  • D 打印顺序A的构造函数> A的构造代码块
显示答案/隐藏答案正确答案: ABC

类的加载顺序

1.父类静态代码块
2.子类静态代码块
3.父类构造代码块
4.父类构造函数
5.子类构造代码块
6.子类构造方法

总结:先静态后非静态,先父类后子类

考点8:字符集编码 国际化

在Java语言中,下列关于字符集编码(Character set encoding)和国际化(i18n)的问题,哪些是正确的?

  • A 每个中文字符占用2个字节,每个英文字符占用1个字节
  • B 假设数据库中的字符是以GBK编码的,那么显示数据库数据的网页也必须是GBK编码的。
  • C Java的char类型,通常以UTF-16 Big Endian的方式保存一个字符。
  • D 实现国际化应用常用的手段是利用ResourceBundle类
显示答案/隐藏答案正确答案: CD

解析

A 显然是错误的,Java一律采用Unicode编码方式,每个字符无论中文还是英文字符都占用2个字节
B 也是不正确的,不同的编码之间是可以转换的,通常流程如下:
将字符串S以其自身编码方式分解为字节数组,再将字节数组以你想要输出的编码方式重新编码为字符串
例:

GBK字符串转UTF-8字符串

1
String newUTF8Str = new String(oldGBKStr.getBytes("GBK"), "UTF8");

C 是正确的。Java虚拟机中通常使用UTF-16的方式保存一个字符
D 也是正确的。ResourceBundle能够依据Local的不同,选择性的读取与Local对应后缀的properties文件,以达到国际化的目的。
综上所述,答案是 C 和 D。

考点9:字符流 字节流

character流和byte流的区别不包括()

  • A 每次读入的字节数不同
  • B 前者带有缓冲,后者没有。
  • C 前者是字符读入,后者是字节读入。
  • D 二者没有区别,可以互换。
显示答案/隐藏答案正确答案: ABD

字符流和字节流每次读入的字节数是不确定的,可能相同也可能不相同;
字符流和字节流都有缓冲流

考点1:数据操纵语言 SQL语言分类

SQL语言共分为三大类(亦有说法分为四大类),那么不属于数据操纵语言的有()

  • A update
  • B grant
  • C delete
  • D insert
显示答案/隐藏答案正确答案: B

数据操纵语言

  • 数据查询语言(DQL):是由SELECT子句,FROM子句,WHERE子句组成的查询块
  • 数据操纵语言(DML):SELECT(查询)INSERT(插入)UPDATE(更新)DELETE(删除)
  • 数据定义语言(DDL):CREATE(创建数据库或表或索引)ALTER(修改表或者数据库)DROP(删除表或索引)
  • 数据控制语言(DCL):GRANT(赋予用户权限)REVOKE(收回权限)DENY(禁止权限)
  • 事务控制语言(TCL):SAVEPOINT (设置保存点)ROLLBACK (回滚)COMMIT(提交)

考点2:多表联查

设有图书管理数据库:
图书(总编号C(6),分类号C(8),书名C(16),作者C(6),出版单位C(20),单价N(6,2))
读者(借书证号C(4),单位C(8),姓名C(6),性别C(2),职称C(6),地址C(20))
借阅(借书证号C(4),总编号C(6),借书日期D(8))
对于图书管理数据库,查询0001号借书证的读者姓名和所借图书的书名。

SQL语句正确的是______。
SELECT 姓名,书名 FROM 借阅,图书,读者 WHERE;
借阅.借书证号=”0001” AND;



  • A
    1
    2
    图书.分类号=借阅.分类号 AND;
    读者.借书证号=借阅.借书证号;
  • B
    1
    2
    图书.总编号=借阅.总编号 AND;
    读者.借书证号=借阅.借书证号;
  • C
    1
    2
    读者.总编号=借阅.总编号 AND;
    读者.借书证号=借阅.借书证号;
  • D
    1
    2
    图书.总编号=借阅.总编号 AND;
    读者.书名=借阅.书名;
显示答案/隐藏答案正确答案: B

考点3:单表连接查询 双重否定

一张学生成绩表score,部分内容如下:

1
2
3
4
name       course     grade
张三 操作系统 67
张三 数据结构 86
李四 软件工程 89;

用一条SQL 语句查询出每门课都大于80 分的学生姓名,SQL语句实现正确的是:( )

  • A Select distinct name from score where name not in(Select name from score where grade <= 80);
  • B Select distinct name from score where name in(Select name from score where grade <= 80);
  • C Select name from score where name not in(Select name from score where grade <= 80);
  • D Select name from score where name in(Select name from score where grade <= 80);
显示答案/隐藏答案正确答案: A

不存在 小于八十分的课=所有的 课大于八十分
遇到所有,需要留意,看看能不能转换为双重否定。

每门课都大于80=不存在一门课 小于等于80

考点4:group by-having子句

SQL语句中与Having子句同时使用的语句是?()

  • A Group By
  • B 联盟链
  • C left Join
  • D Where
显示答案/隐藏答案正确答案: A

HAVING语句通常与GROUP BY语句联合使用,用来过滤由GROUP BY语句返回的记录集。

考点5:select into语句

某打车公司将驾驶里程(drivedistanced)超过5000里的司机信息转移到一张称为seniordrivers 的表中,他们的详细情况被记录在表drivers 中,正确的sql为()

  • A
    1
    2
    insert into seniordrivers
    drivedistanced>=5000 from drivers where;
  • B
    1
    insert seniordrivers (drivedistanced) values from drivers where drivedistanced>=5000;
  • C
    1
    2
    insert into seniordrivers
    (drivedistanced)values>=5000 from drivers where;
  • D
    1
    select * into seniordrivers from drivers where drivedistanced >=5000;
显示答案/隐藏答案正确答案: D

insert into 要求目标表必须存在,select into 如果不存最目标表的话会自动创建

SQL INSERT INTO SELECT 语句

https://www.runoob.com/sql/sql-insert-into-select.html

通过SQL,您可以从一个表复制信息到另一个表。

INSERT INTO SELECT语句从一个表复制数据,然后把数据插入到一个已存在的表中。

SQL INSERT INTO SELECT语句
INSERT INTO SELECT语句从一个表复制数据,然后把数据插入到一个已存在的表中。目标表中任何已存在的行都不会受影响。

SQL INSERT INTO SELECT语法

我们可以从一个表中复制所有的列插入到另一个已存在的表中:

1
2
INSERT INTO table2
SELECT * FROM table1;

或者我们可以只复制希望的列插入到另一个已存在的表中:

1
2
3
4
INSERT INTO table2
(column_name(s))
SELECT column_name(s)
FROM table1;

演示数据库
在本教程中,我们将使用 RUNOOB 样本数据库。

下面是选自 “Websites” 表的数据:

1
2
3
4
5
6
7
8
9
10
+----+--------------+---------------------------+-------+---------+
| id | name | url | alexa | country |
+----+--------------+---------------------------+-------+---------+
| 1 | Google | https://www.google.cm/ | 1 | USA |
| 2 | 淘宝 | https://www.taobao.com/ | 13 | CN |
| 3 | 菜鸟教程 | http://www.runoob.com/ | 4689 | CN |
| 4 | 微博 | http://weibo.com/ | 20 | CN |
| 5 | Facebook | https://www.facebook.com/ | 3 | USA |
| 7 | stackoverflow | http://stackoverflow.com/ | 0 | IND |
+----+---------------+---------------------------+-------+---------+

下面是 “apps” APP 的数据:

1
2
3
4
5
6
7
8
9
mysql> SELECT * FROM apps;
+----+------------+-------------------------+---------+
| id | app_name | url | country |
+----+------------+-------------------------+---------+
| 1 | QQ APP | http://im.qq.com/ | CN |
| 2 | 微博 APP | http://weibo.com/ | CN |
| 3 | 淘宝 APP | https://www.taobao.com/ | CN |
+----+------------+-------------------------+---------+
3 rows in set (0.00 sec)

SQL INSERT INTO SELECT 实例

复制 “apps” 中的数据插入到 “Websites” 中:

实例

1
2
INSERT INTO Websites (name, country)
SELECT app_name, country FROM apps;

只复 QQ 的 APP 到 “Websites” 中:

实例

1
2
3
INSERT INTO Websites (name, country)
SELECT app_name, country FROM apps
WHERE id=1;

SQL SELECT INTO 语句

https://www.runoob.com/sql/sql-select-into.html
通过SQL,您可以从一个表复制信息到另一个表。

SELECT INTO语句从一个表复制数据,然后把数据插入到另一个新表中。

注意:
MySQL 数据库不支持 SELECT … INTO 语句,但支持 INSERT INTO … SELECT 。
当然你可以使用以下语句来拷贝表结构及数据:

1
2
3
CREATE TABLE 新表
AS
SELECT * FROM 旧表 ;

SQL SELECT INTO 语法

我们可以复制所有的列插入到新表中:

1
2
3
SELECT *
INTO newtable [IN externaldb]
FROM table1;

或者只复制希望的列插入到新表中:

1
2
3
SELECT column_name(s)
INTO newtable [IN externaldb]
FROM table1;

提示:新表将会使用 SELECT 语句中定义的列名称和类型进行创建。您可以使用 AS 子句来应用新名称。

SQL SELECT INTO 实例

创建 Websites 的备份复件:

1
2
3
SELECT *
INTO WebsitesBackup2016
FROM Websites;

只复制一些列插入到新表中:

1
2
3
SELECT name, url
INTO WebsitesBackup2016
FROM Websites;

只复制中国的网站插入到新表中:

1
2
3
4
SELECT *
INTO WebsitesBackup2016
FROM Websites
WHERE country='CN';

复制多个表中的数据插入到新表中:

1
2
3
4
5
SELECT Websites.name, access_log.count, access_log.date
INTO WebsitesBackup2016
FROM Websites
LEFT JOIN access_log
ON Websites.id=access_log.site_id;

提示:SELECT INTO 语句可用于通过另一种模式创建一个新的空表。只需要添加促使查询没有数据返回的 WHERE 子句即可:

1
2
3
4
SELECT *
INTO newtable
FROM table1
WHERE 1=0;

区别

select into from 和 insert into select 都是用来复制表
两者的主要区别为:

  • select into from要求目标表不存在,因为在插入时会自动创建;
  • insert into select from要求目标表存在。
  • select into from :将查询出来的数据整理到一张新表中保存,表结构与查询结构一致。
    1
    select *(查询出来的结果) into newtable(新的表名)from where (后续条件);
    即,查询出来结果—>复制一张同结构的空表—>将数据拷贝进去。
  • insert into select :为已经存在的表批量添加新数据。
    1
    insert into  (准备好的表) select *(或者取用自己想要的结构)from 表名 where 各种条件;
    即,指定一张想要插入数据的表格—>对数据进行加工筛选—>填入一张准备好的表格。

create table复制表结构或数据

1. 复制表结构及其数据:

1
create table table_name_new as select * from table_name_old;

2. 只复制表结构:

1
create table table_name_new as select * from table_name_old where 1=2;

或者:

1
create table table_name_new like table_name_old;

insert into 复制表数据:

如果两个表结构一样:

1
insert into table_name_new select * from table_name_old;

如果两个表结构不一样:

1
insert into table_name_new(column1,column2...) select column1,column2... from table_name_old;

考点6:多表联查 连接查询 量词

运动会比赛信息的数据库,有如下三个表:
运动员ATHLETE(运动员编号 Ano,姓名Aname,性别Asex,所属系名 Adep), 项目 ITEM (项目编号Ino,名称Iname,比赛地点Ilocation), 成绩SCORE (运动员编号Ano,项目编号Ino,积分Score)。
写出目前总积分最高的系名及其积分,SQL语句实现正确的是:( )

  • A
    1
    2
    3
    SELECT Adep,SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep HAVING SUM(Score)
    >=ANY
    (SELECT SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep)
  • B
    1
    2
    3
    SELECT Adep,SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep HAVING SUM(Score)
    >=SOME
    (SELECT SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep)
  • C
    1
    2
    3
    SELECT Adep,SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep HAVING SUM(Score) 
    IN
    (SELECT SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep)
  • D
    1
    2
    3
    SELECT Adep,SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep HAVING SUM(Score)
    >=ALL
    (SELECT SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep)
显示答案/隐藏答案正确答案: D

All:对所有数据都满足条件,整个条件才成立;
Any:只要有一条数据满足条件,整个条件成立;
Some的作用和Any一样 .

1
2
3
运动员ATHLETE(运动员编号 Ano,姓名Aname,性别Asex,所属系名 Adep), 
项目ITEM (项目编号Ino,名称Iname,比赛地点Ilocation),
成绩SCORE (运动员编号Ano,项目编号Ino,积分Score)
1
2
3
ATHLETE(Ano,Aname,Asex,Adep), 
ITEM(Ino,Iname,Ilocation),
SCORE(Ano,Ino,Score)

写出目前总积分最高的系名及其积分,SQL语句实现正确的是

考点7:select into from和insert into select

某打车公司将驾驶里程(drivedistanced)超过5000里的司机信息转移到一张称为seniordrivers 的表中,他们的详细情况被记录在表drivers 中,正确的sql为()

  • A
    1
    insert into seniordrivers drivedistanced>=5000 from drivers where;
  • B
    1
    insert seniordrivers (drivedistanced) values from drivers where drivedistanced>=5000;
  • C
    1
    insert into seniordrivers (drivedistanced)values>=5000 from drivers where
  • D
    1
    select * into seniordrivers from drivers where drivedistanced >=5000;
显示答案/隐藏答案正确答案: D

考点8:as取别名

在MySql中进行数据查询时,如果要对查询结果的列名重新命名,将sno列重新命名为学号,则下列语句正确的是( )

  • A select sno as 学号 from T
  • B select 学号= sno from T
  • C select sno 学号 from T
  • D select sno=学号 from T
显示答案/隐藏答案正确答案: AC

as只用于mysql语言中,as可以为列或者表起别名,as可以省略,但是要用空格代替

考点9:select语句

SQL语句中,可以查看到学生信息表中,学生姓名的SQL语句为?()

  • A select 学生信息 from 学生信息
  • B select 学生信息 from 学生姓名
  • C select * from 学生信息
  • D select 学生姓名 from 学生信息
显示答案/隐藏答案正确答案: CD

SQL SELECT 语法

1
2
SELECT column_name,column_name
FROM table_name;

考点10:聚合函数不统计null值 count(*)和count(1)都是统计行数

表结构如下:

1
2
3
4
5
6
7
CREATE TABLE `score` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`sno` int(11) NOT NULL,
`cno` tinyint(4) NOT NULL,
`score` tinyint(4) DEFAULT NULL,
PRIMARY KEY (`id`)
) ;

以下查询语句结果一定相等的是()

1
2
3
4
5
6
A.SELECT sum(score) / count(*) FROM score WHERE cno = 2;
B.SELECT sum(score) / count(id) FROM score WHERE cno = 2;
C.SELECT sum(score) / count(sno) FROM score WHERE cno = 2;
D.SELECT sum(score) / count(score) FROM score WHERE cno = 2;
E.SELECT sum(score) / count(1) FROM score WHERE cno = 2;
F.SELECT avg(score) FROM score WHERE cno = 2;
  • A A,E,F
  • B A,D,F
  • C A,B,C,D
  • D D,F
  • E A,B,E,F
  • F A,B,C,E
显示答案/隐藏答案正确答案: DF

聚合函数(字段名)会忽略null值

count(字段名):会忽略该列中所有的null值
avg(字段名)函数会忽略null值

count(*)和count(1)都是统计行数

count(*):不会忽略null值,本质计算的是行数
count(1):不会忽略null值,本质计算的是行数

由于id、sno都not null,因此count(*)count(1)count(id)count(sno)本质都是计算行数,ABCE的分子一样,分母也相等,所以结果相等。

score字段default null,avg(score)计算时,忽略null值,sum(score)和count(score)也同样忽略null值。
所以计算得到的avg(score)和sum(score)/count(score)的值也是相等的。即DF结果一样。

Score是默认约束为null,
count(score)统计忽略空值行(对象),
avg(score)也会忽略空值行(对象)

所以都是求平均成绩:D和F都会忽略 空值,所以DF一样结果

id,sno是not null约束的,不会有空值,所以 count(id)和count(sno)都是统计行数,count(*)和count(1)也是统计行数,所以

ABCE都是计算的全部,所以是一样的结果

主要考察:
avg(column_name)时忽略空值,
count(column_name)时忽略空值

Count(1)count(*)效果一样,统计全部个数(count(1)count(*)高效)

默认约束 default 的默认值设置了null

1、count(*), count(1)是记录表格出现的行数,count(sno), count(id)因为都是非空元素,计数也等于表格总行数
2、count(score)是记录score非空的行数,ave()函数也只对非空元素作用

考点1:数据库分类

MySQL是一种( )数据库管理系统。

  • A 层次型
  • B 联盟链
  • C 关系型
  • D 对象型
显示答案/隐藏答案正确答案: C

层次型数据库管理系统是紧随网状数据库而出现的。现实世界中很多事物是按层次组织起来的。层次数据模型的提出,首先是为了模拟这种按层次组织起来的事物。
最著名最典型的层次数据库系统是IBM公司的IMS(Information Management System)

MySQL就是一种普通的关系型数据库,关系数据库将数据保存在不同的表中,而不是将所有数据放在一个大仓库中。

比较流行的数据库模型有三种,分别为层次式数据库、网状数据库和关系型数据库。而在当今的互联网中,最常见的数据库模型主要是两种,即SQL关系型数据库和NoSQL非关系型数据库。关系型数据库的代表包括Oracle, Sql Server, Mysql。

考点2:分组查询语句

SQL中属于分组查询的语句是?()

  • A Where
  • B 联盟链
  • C Group By
  • D Having
显示答案/隐藏答案正确答案: C

区块链分类

区块链大致可以分为公有链(Public Blockchain)、私有链(Private Blockchain)以及联盟链(Consortium Blockchain)三大类。
因此,联盟链属于区块链的一种。

SQL各语句的作用

  • where筛选、
  • group by分组、
  • having与group by连用,用于筛选。

考点3:group by having

若要“查询选修了3门以上课程的学生的学号”,则正确的SQL语句是( )

  • A SELECT S# FROM SC GROUP BY S# WHERE COUNT(*)> 3
  • B SELECT S# FROM SC GROUP BY S# HAVING COUNT(*)> 3
  • C SELECT S# FROM SC ORDER BY S# WHERE COUNT(*)> 3
  • D SELECT S# FROM SC ORDER BY S# HAVING COUNT(*)> 3
显示答案/隐藏答案正确答案: B

count(*)计算了有多少行,由于group by学号,则count(*)计算了每个学号有多少行

order by排序

1.order by 从英文里理解就是行的排序方式,默认的为升序。 order by 后面必须列出排序的字段名,可以是多个字段名。

group by必须搭配聚合函数使用

2.group by 从英文里理解就是分组。必须有“聚合函数”来配合才能使用,使用时至少需要一个分组标志字段。
注意:聚合函数是—sum()、count()、avg()等都是“聚合函数”

having子句

在 SQL 中增加 HAVING 子句原因是,WHERE 关键字无法与聚合函数一起使用
HAVING 子句可以让我们筛选分组后的各组数据
SQL HAVING语法如下:

1
2
3
4
5
SELECT column_name, aggregate_function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name
HAVING aggregate_function(column_name) operator value;

执行顺序 where->group by->聚合->having,
where无论如何不能拿到聚合

where 聚合函数 having的执行顺序

where、聚合函数、having 在from后面的执行顺序:

1
where>聚合函数(sum,min,max,avg,count)>having

若须引入聚合函数来对group by结果进行过滤 则只能用having。

HAVING语句通常与GROUP BY语句联合使用,用来过滤由GROUP BY语句返回的记录集。

HAVING语句的存在弥补了WHERE关键字不能与聚合函数联合使用的不足。

1、where 后不能跟聚合函数,因为where执行顺序先于聚合函数。
2、where 子句的作用是在对查询结果进行分组前,将不符合where条件的行去掉,即在分组之前过滤数据,条件中不能包含聚组函数,使用where条件显示特定的行。
3、having 子句的作用是筛选满足条件的组,即在分组之后过滤数据,条件中经常包含聚组函数,使用having 条件显示特定的组,也可以使用多个分组标准进行分组。
https://blog.csdn.net/qq_35269216/article/details/90812872

SQL HAVING 子句

https://www.w3cschool.cn/sql/bxfh1oza.html

HAVING​ 子句使你能够指定过滤条件,从而控制查询结果中哪些组可以出现在最终结果里面。

WHERE​子句对被选择的列施加条件,而 ​HAVING​子句则对 ​GROUP BY​ 子句所产生的组施加条件。

语法

下面可以看到 ​HAVING​ 子句在 ​SEL ECT ​查询中的位置:

1
2
3
4
5
6
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY;

SELECT​查询中,​HAVING​子句必须紧随GROUP BY​子句,并出现在ORDER BY​子句(如果有的话)之前。

带有 ​HAVING​ 子句的 ​SELECT​ 语句的语法如下所示:

1
2
3
4
5
6
SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2;

示例

考虑 ​CUSTOMERS​ 表,表中的记录如下所示:

1
2
3
4
5
6
7
8
9
10
11
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

下面是一个有关 ​HAVING​ 子句使用的实例,该实例将会筛选出出现次数大于或等于 2 的所有记录。

1
2
3
4
SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

其执行结果如下所示:

1
2
3
4
5
6
+----+----------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+-----+---------+---------+;

考点4:多对多

某学院包含多个专业如计算机科学、信息管理、软件工程、网络工程。每个专业每年都招收一个班级的学生。在招生过程中就已明确规定,一个学生只能就读于该学院的一个班级,但是一个班级可以招收不超过60个学生。那么,学生和班级之间是________的关系。

  • A 一对多
  • B 多对多
  • C 一对一
  • D 多对一
显示答案/隐藏答案正确答案: D
  • 多个学生在一个班级,限定条件:一个学生只能在一个班级,所以多对一
  • 如果限定条件改变:一个学生可以读不同的班级,那么就是多对多

考点5:SQL Server datediff函数 getdate函数

请取出 BORROW表中日期(RDATE字段)为当天的所有记录?(RDATE字段为datetime型,包含日期与时间)。SQL语句实现正确的是:( )

  • A select * from BORROW where datediff(dd,RDATE,getdate())=0
  • B select * from BORROW where RDATE=getdate()
  • C select * from BORROW where RDATE-getdate()=0
  • D select * from BORROW where RDATE>getdate()
显示答案/隐藏答案正确答案: A

SQL Server DATEDIFF() 函数

https://www.w3cschool.cn/mysql/func-datediff.html

MySQL DATEDIFF() 函数

https://www.w3cschool.cn/mysql/func-datediff-mysql.html

定义和用法

DATEDIFF() 函数返回两个日期之间的天数。

语法

1
DATEDIFF(date1,date2);

date1 和 date2 参数是合法的日期或日期/时间表达式。

注释:只有值的日期部分参与计算。

实例

下面是 SELECT 语句:

1
SELECT DATEDIFF('2008-11-30','2008-11-29') AS DiffDate;

结果如下所示:

1
2
3
4
5
6
7
8
9
mysql> SELECT DATEDIFF('2008-11-30','2008-11-29') AS DiffDate;
+----------+
| DiffDate |
+----------+
| 1 |
+----------+
1 row in set (0.16 sec)

mysql>

SQL Server getdate函数

https://www.w3cschool.cn/mysql/func-getdate.html

getdate()得出的是当前日期+时间(精确到毫秒) RDATE也是datetime型,与getdate无法准确比较 故用datediff(dd, date1, date2)=0,datepart以日为单位,比较rdate和当前的日期,使之相隔0天即为当天。

SQL Server 和 MySQL 中的 Date 函数

https://www.w3cschool.cn/sql/zh6t9fpu.html

考点6:select case条件语句

积分result表中有A B C D四列,要求:
1)当A列值大于等于B列时,选择A列否则选择B列
2)当C列值大于等于D列时,选择C列否则选择D列
用SQL语句实现正确的是:( )

  • A select ( when A>=B then A else B ) MAX_AB, ( when C>=D then C else D ) MAX_CD from result
  • B select (case when A>=B then A else B ) MAX_AB, (case when C>=D then C else D ) MAX_CD from result
  • C select (case when A>=B then A else B end) MAX_AB, (case when C>=D then C else D end) MAX_CD from result
  • D select case when A>=B then A else B end MAX_AB, case when C>=D then C else D end MAX_CD from result
显示答案/隐藏答案正确答案: C

SQL 查询:SELECT CASE 条件赋值

https://www.cnblogs.com/richardzhu/p/3571670.html
https://zhuanlan.zhihu.com/p/63333847
https://segmentfault.com/a/1190000020877471
https://www.gairuo.com/p/sql-select-case-when-then

1
2
3
4
5
6
7
8
select c_1,
CASE
WHEN condition1 THEN result1
WHEN condition2 THEN result2
WHEN conditionN THEN resultN
ELSE result_else
END as c_name
from tab_name;

MySQL CASE语句

https://www.yiibai.com/mysql/case-statement.html
https://www.yiibai.com/mysql/case-function.html
https://www.yiibai.com/plsql/plsql_searched_case.html

这里有一张图片

考点7:多变联查

运动会比赛信息的数据库,有如下三个表:
运动员ATHLETE(运动员编号 Ano,姓名Aname,性别Asex,所属系名 Adep), 项目 ITEM (项目编号Ino,名称Iname,比赛地点Ilocation), 成绩SCORE (运动员编号Ano,项目编号Ino,积分Score)。
写出目前总积分最高的系名及其积分,SQL语句实现正确的是:( )

  • A

    1
    2
    3
    4
    5
    SELECT Adep,SUM(Score) 
    FROM ATHLETE,SCORE
    WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep HAVING SUM(Score)>=ANY
    (SELECT SUM(Score) FROM ATHLETE,SCORE
    WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep);
  • B

    1
    2
    3
    SELECT Adep,SUM(Score) FROM ATHLETE,SCORE
    WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep HAVING SUM(Score)>=SOME
    (SELECT SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep);
  • C

    1
    2
    SELECT Adep,SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep HAVING SUM(Score) IN
    (SELECT SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep);
  • D

    1
    2
    SELECT Adep,SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep HAVING SUM(Score)>=ALL
    (SELECT SUM(Score) FROM ATHLETE,SCORE WHERE ATHLETE.Ano=SCORE.Ano GROUP BY Adep);
显示答案/隐藏答案正确答案: D

考点8:最可能导致sql注入的字符

下面哪些字符最可能会导致sql注入?

  • A '(单引号)
  • B /
  • C "(双引号)
  • D $
显示答案/隐藏答案正确答案: A

防止SQL注入,需要注意以下几个要点:

  • 永远不要信任用户的输入。对用户的输入进行校验,可以通过正则表达式,或限制长度;对单引号和**双”-“**进行转换等。
  • 永远不要使用动态拼装sql,可以使用参数化的sql或者直接使用存储过程进行数据查询存取。
  • 永远不要使用管理员权限的数据库连接,为每个应用使用单独的权限有限的数据库连接。
  • 不要把机密信息直接存放,加密或者hash掉密码和敏感的信息。
  • 应用的异常信息应该给出尽可能少的提示,最好使用自定义的错误信息对原始错误信息进行包装
  • sql注入的检测方法一般采取辅助软件或网站平台来检测,软件一般采用sql注入检测工具jsky,网站平台就有亿思网站安全平台检测工具。MDCSOFT SCAN等。采用MDCSOFT-IPS可以有效的防御SQL注入,XSS攻击等。

考点9:多表联查

雇员表EMP 结构如下

1
2
3
4
(  雇员编号 EMPNO ,   姓名 ENAME ,
工作岗位 JOB , 管理员编号 MGR ,
受雇时间 HIREDATE , 工资 SAL ,
奖金 COMM , 部门编号 DEPTNO );

下列操作语句正确的是:( )

  • A 显示在10和30部门工作并且工资大于5500元的雇员的姓名和工资,列标题显示为Employee和Monthly Salary 语句:SELECT ENAME EMPLOYEE ,SAL “MONTHLY SALARY” FROM EMP WHERE DEPTNO IN(10,30)AND SAL>5500;
  • B 显示受雇时间在2010年1月1日和2012年12月31日之间的雇员的姓名、工资、及受雇时间,并以受雇时间升序排列。 语句:SELECT ENAME,SAL,HIREDATE FROM EMP WHERE HIREDATE BETWEEN ‘2010-01-01’ AND ‘2012-12-31’ ORDER BY HIREDATE;
  • C 显示奖金比工资多10%以上的雇员的姓名、工资及奖金。 语句:SELECT ENAME,SAL ,COMM FROM EMP WHERE COMM>SAL*1.1;
  • D 查询没有奖金且工资低于6500并工作岗位是经理、普通员工、销售员的所有员工信息。 语句:SELECT * FROM EMP WHERE SAL<6500 AND COMM IS NULL AND JOB IN (‘经理’,‘普通员工’,‘销售员’);
显示答案/隐藏答案正确答案: A

C选项 where子句中不能使用*

考点10:delete和truncate的区别

下面有关sql 语句中 delete truncate的说法正确的是?()

  • A 论清理表数据的速度,truncate一般比delete更快
  • B truncate命令可以用来删除部分数据。
  • C truncate只删除表的数据不删除表的结构
  • D delete能够回收高水位
显示答案/隐藏答案正确答案: AC

1、处理效率:drop>trustcate>delete
2、drop删除整个表;trustcate删除全部记录,但不删除表;delete删除部分记录
3、delete不影响所用extent,高水线保持原位置不动;trustcate会将高水线复位。

truncate之所以快是因为,truncate不删除数据,只是将当前表重新映射一段存储空间,并把旧空间标记为可用,并未覆盖数据。

oracle数据库中高水位的概念,通俗的讲就是将存储空间想象成水库,插入数据水位线就会上升,但是删除操作并不会造成最高水位线下降。

执行truncate语句需要拥有表的drop权限,从逻辑上讲,truncate table类似于delete删除所有行的语句或drop table然后再create table语句的组合。为了实现高性能,它绕过了删除数据的DML方法,因此,它不能回滚。尽管truncate table与delete相似,但它被分类为DDL语句而不是DML语句

MySQL truncate table语句

https://www.yiibai.com/mysql/truncate-table.html

SQL Truncate Table

https://www.yiibai.com/sql/sql-truncate-table.html

  1. SQL TRUNCATE TABLE与DELETE逻辑上,TRUNCATE TABLE语句和不带WHERE子句的DELETE语句提供了从表中删除所有数据的相同效果。 但是,它们确实存在一些差别:

使用DELETE语句时,数据库系统会记录操作。 通过一些努力,可以回滚已删除的数据。 但是,当使用TRUNCATE TABLE语句时,除非在尚未提交的事务中使用它,否则无法回滚。
要从外键约束引用的表中删除数据,不能使用TRUNCATE TABLE语句。 在这种情况下,必须使用DELETE语句。
如果表具有与之关联的触发器,则TRUNCATE TABLE语句不会触发delete触发器。
执行TRUNCATE TABLE语句后,某些数据库系统会将自动增量列(或标识,序列等)的值重置为其起始值。 DELETE语句不是这种情况。带有WHERE子句的DELETE语句从表中删除部分数据,而TRUNCATE TABLE语句始终从表中删除所有数据。//原文出自【易百教程】,商业转载请联系作者获得授权,非商业请保留原文链接:https://www.yiibai.com/sql/sql-truncate-table.html

2. SQL TRUNCATE TABLE与DELETE

逻辑上,TRUNCATE TABLE语句和不带WHERE子句的DELETE语句提供了从表中删除所有数据的相同效果。 但是,它们确实存在一些差别:

  • 使用DELETE语句时,数据库系统会记录操作。 通过一些努力,可以回滚已删除的数据。 但是,当使用TRUNCATE TABLE语句时,除非在尚未提交的事务中使用它,否则无法回滚。
  • 要从外键约束引用的表中删除数据,不能使用TRUNCATE TABLE语句。 在这种情况下,必须使用DELETE语句。
  • 如果表具有与之关联的触发器,则TRUNCATE TABLE语句不会触发delete触发器。
  • 执行TRUNCATE TABLE语句后,某些数据库系统会将自动增量列(或标识,序列等)的值重置为其起始值。 DELETE语句不是这种情况。
  • 带有WHERE子句的DELETE语句从表中删除部分数据,而TRUNCATE TABLE语句始终从表中删除所有数据。

MYSQL中TRUNCATE和DELETE的区别

https://www.jianshu.com/p/ddc5b65e63af

考点1:

以下哪个不能用来处理线程安全

  • A synchronized关键字
  • B volatile关键字
  • C Lock类
  • D transient关键字
显示答案/隐藏答案正确答案: D
  • synchrozied关键字称作同步,主要用来给方法、代码块加锁,被加锁的代码段,同一时间内多线程同时访问同一对象的加锁方法/代码块时,只能有一个线程执行能执行方法/代码块中的代码,其余线程必须等待当前线程执行完以后才执行该方法/代码块。
  • volatile关键字
    • 1.保证了不同线程对该变量操作的内存可见性.(当一个线程修改了变量,其他使用次变量的线程可以立即知道这一修改)。
    • 2.禁止了指令重排序.
  • Lock接口提供了与synchronized关键字类似的同步功能,但需要在使用时手动获取锁和释放锁。
  • transient关键字 简单地说,就是让某些被修饰的成员属性变量不被序列化。

transient,变量修饰符,如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。当一个变量不希望被持久化的时候,比如说一些账号密码,就可以用transient关键字来表示该变量不参与序列化过程。
volatile关键字只能保证可见性,不能保证原子性

考点2:

下列代码编译和运行的结果是:()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Threads4{
public static void main(String[] args){
new Threads4().go();
}
public void go(){
Runnable r=new Runnable(){
public void run(){
System.out.print("foo");
}
};
Thread t=new Thread(r);
t.start();
}
}
  • A 编译错误
  • B 抛出运行时异常
  • C 输出:foo
  • D 代码正常运行,但是无输出
显示答案/隐藏答案正确答案: C

考点3:

下列说法正确的是()?

  • A 我们直接调用Thread对象的run方法会报异常,所以我们应该使用start方法来开启一个线程
  • B 一个进程是一个独立的运行环境,可以被看做一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中,并且可以共享进程中的资源
  • C synchronized可以解决可见性问题,volatile可以解决原子性问题
  • D ThreadLocal用于创建线程的本地变量,该变量是线程之间不共享的
显示答案/隐藏答案正确答案: BD

https://lanlan2017.github.io/JavaReadingNotes/a8a61bd3/

考点4:

ArrayLists和LinkedList的区别,下述说法正确的有?

  • A ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
  • B 对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要迭代器。
  • C 对于新增和删除操作add和remove,LinkedList比较占优势,因为ArrayList要移动数据。
  • D ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间,而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。
显示答案/隐藏答案正确答案: ABCD

考点5:

下列哪些操作会使线程释放锁资源?

  • A sleep()
  • B wait()
  • C join()
  • D yield()
显示答案/隐藏答案正确答案: BC

所谓的释放锁资源实际是通知对象内置的monitor对象进行释放,而只有所有对象都有内置的monitor对象才能实现任何对象的锁资源都可以释放。又因为所有类都继承自Object,所以wait()就成了Object方法,也就是通过wait()来通知对象内置的monitor对象释放,而且事实上因为这涉及对硬件底层的操作,所以wait()方法是native方法,底层是用C写的。
其他三个方法都是Thread所有,所以其他3个是没有资格释放资源的
join()有资格释放资源其实是通过调用wait()来实现的

代码如下:
wait()方法

1
2
public final native void wait(long timeoutMillis) 
throws InterruptedException;

join()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis &lt; 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay &lt;= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}

1.sleep()方法
在指定时间内让当前正在执行的线程暂停执行,但不会释放“锁标志”。不推荐使用。
sleep()使当前线程进入阻塞状态,在指定时间内不会执行。
2.wait()方法
在其他线程调用对象的notify或notifyAll方法前,导致当前线程等待。线程会释放掉它所占有的“锁标志”,从而使别的线程有机会抢占该锁。
当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者,会抛出IllegalMonitorStateException异常。

唤醒当前对象锁的等待线程使用notify或notifyAll方法,也必须拥有相同的对象锁,否则也会抛出IllegalMonitorStateException异常。
waite()和notify()必须在synchronized函数或synchronized block中进行调用。
如果在non-synchronized函数或non-synchronized block中进行调用,虽然能编译通过,但在运行时会发生IllegalMonitorStateException的异常。
3.yield方法
暂停当前正在执行的线程对象。
yield()只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
yield()只能使同优先级或更高优先级的线程有执行的机会。
4.join方法
join()等待该线程终止。
等待调用join方法的线程结束,再继续执行。如:

1
t.join();//主要用于等待t线程运行结束,若无此句,main则会执行完毕,导致结果不可预测

yield()不会释放锁,只是通知调度器自己可以让出cpu时间片,但只是建议,调度器也不一定采纳

其实没有必要把简单的题目解析的太复杂。基本是只要wait()方法才会释放锁,而join( )方法底层调用的就是wait( )方法,所以选bc

sleep只能让正在执行的线程暂停执行,但不会释放锁
wait方法在其他线程调用对象的notify或notifyAll方法前会导致当前线程等待。线程会释放占有的锁。
yield只能使当前线程重新回到可执行状态,不会释放锁

wait会释放锁,join底层采用的也是wait所以也会释放锁

yield()实际上是不释放锁,但是放弃了CPU时间片,让可运行状态变成了就绪状态。
join()是在该线程中插入一个已声明的线程,等待该线程执行完毕再执行该线程,再进行抢占锁资源 sleep()让当前正在执行的线程暂停执行,但不会释放“锁标志”。不推荐使用。 wait()线程会释放掉它所占有的“锁标志”,从而使别的线程有机会抢占该锁。

考点6:类型转换

Java类Demo中存在方法func1、func2、func3和func4,请问该方法中,哪些是不合法的定义?( )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Demo{
  float func1()
  {
    int i=1;
    return;
  }
  float func2()
  {
    short i=2;
    return i;
  }
  float func3()
  {
    long i=3;
    return i;
  }
  float func4()
  {
    double i=4;
    return i;
  }
}
  • A func1
  • B func2
  • C func3
  • D func4
显示答案/隐藏答案正确答案: AD

这道题考的是数据类型转换问题。由大到小需要强制转换,由小到大不需要。
A:return; 没有返回值,错误
B:short → float 无须强制转换,正确
C:long → float 无须强制转换(这个最选项容易出错),正确。
float占4个字节为什么比long占8个字节大呢,因为底层的实现方式不同。
浮点数的32位并不是简单直接表示大小,而是按照一定标准分配的
第1位,符号位,即S
接下来8位,指数域,即E。
剩下23位,小数域,即M,取值范围为[1 ,2 ) 或[0 , 1)
然后按照公式:V=(-1)^s * M * 2^E
也就是说浮点数在内存中的32位不是简单地转换为十进制,而是通过公式来计算而来,通过这个公式虽然,只有4个字节,但浮点数最大值要比长整型的范围要大
D:double → float 没有强制转换,错误

转换原则 : byte ->short(char)->int->long->float->double

考点7:重写 接口方法默认修饰符

根据以下接口和类的定义,要使代码没有语法错误,则类Hero中应该定义方法( )。

1
2
3
4
interface Action{  
void fly();
}
class Hero implements Action{ //…… }
  • A private void fly(){}
  • B void fly(){}
  • C protected void fly(){}
  • D public void fly(){}
显示答案/隐藏答案正确答案: D

接口方法默认是public abstract的,且实现该接口的类中对应的方法的可见性不能小于接口方法的可见性,因此也实现类的方法只能是public的。

方法重写要求

  • 方法名相同、
  • 形参列表相同:
  • 返回值类型更小或相等
  • 抛出的异常类更小或相等
  • 访问权限更大或相等

考点8:

J2EE中,当把来自客户机的HTTP请求委托给servlet时,会调用HttpServlet的( )方法

  • A service
  • B doget
  • C dopost
  • D init
显示答案/隐藏答案正确答案: A

A
HttpServlet容器响应Web客户请求流程如下: 1)Web客户向Servlet容器发出Http请求;
2)Servlet容器解析Web客户的Http请求;
3)Servlet容器创建一个HttpRequest对象,在这个对象中封装Http请求信息;
4)Servlet容器创建一个HttpResponse对象;
5)Servlet容器调用HttpServlet的service方法,这个方法中会根据request的Method来判断具体是执行doGet还是doPost,把HttpRequest和HttpResponse对象作为service方法的参数传给HttpServlet对象;
6)HttpServlet调用HttpRequest的有关方法,获取HTTP请求信息;
7)HttpServlet调用HttpResponse的有关方法,生成响应数据;
8)Servlet容器把HttpServlet的响应结果传给Web客户。
doGet()

doPost()
是创建HttpServlet时需要覆盖的方法.

考点9:

下面有关java基本类型的默认值和取值范围,说法错误的是?

  • A 字节型的类型默认值是0,取值范围是-2^7—2^7-1
  • B boolean类型默认值是false,取值范围是true\false
  • C 字符型类型默认是0,取值范围是-2^15 —2^15-1
  • D long类型默认是0,取值范围是-2^63—2^63-1
显示答案/隐藏答案正确答案: C

char占16位,而且没有负值。所以最小值是0。最大值是1111111111111111 = 2^16 - 1

默认值 存储需求(字节) 取值范围 示例
byte 0 1 -2^7—2^7-1 byteb=10;
char ‘\u0000’ 2 0—2^16-1 char c=’c’;
short 0 2 -2^15—2^15-1 short s=10;
int 0 4 -2^31—2^31-1 int i=10;
long 0 8 -2^63—2^63-1 long o=10L;
float 0.0f 4 -2^31—2^31-1 float f=10.0F
double 0.0d 8 -2^63—2^63-1 double d=10.0;
boolean false 1 true\false boolean flag=true;

考点10:

关于Java以下描述正确的有( )

  • A Class类是Object类的超类
  • B Object类是一个final类
  • C String类是一个final类
  • D Class类可以装载其它类
显示答案/隐藏答案正确答案: CD
1
2
3
public final class Class<T>
extends Object
implements Serializable, GenericDeclaration, Type, AnnotatedElement
1
public class Object
1
2
3
public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence

装载应该就是加载,应该是Class.forName()这个方法

考点11:

Java中的集合类包括ArrayList、LinkedList、HashMap等类,下列关于集合类描述正确的是()

  • A ArrayList和LinkedList均实现了List接口
  • B ArrayList的访问速度比LinkedList快
  • C 添加和删除元素时,ArrayList的表现更佳
  • D HashMap实现Map接口,它允许任何类型的键和值对象,并允许将null用作键或值
显示答案/隐藏答案正确答案: ABD

B选项
ArrayList底层是一个数组结构,而LinkedList底层是一个链表

链表
特点:查询慢,增删快
原因:链表中地址不是连续的,每次查询必须从头开始

数组
特点:查询快,增删慢
原因:查询快:数组地址是连续的,我们通过数组首地址就可以找到数组,通过数组的索引可以快速查找下一个元素;数组长度固定,每次增/删元素都必须创建一个新数组。

考点12:

final、finally和finalize的区别中,下述说法正确的有?

  • A final用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。
  • B finally是异常处理语句结构的一部分,表示总是执行。
  • C finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源的回收,例如关闭文件等。
  • D 引用变量被final修饰之后,不能再指向其他对象,它指向的对象的内容也是不可变的。
显示答案/隐藏答案正确答案: AB

选AB
A,D考的一个知识点,final修饰变量,变量的引用(也就是指向的地址)不可变,但是引用的内容可以变(地址中的内容可变)。
B,finally表示总是执行。但是其实finally也有不执行的时候,但是这个题不要扣字眼。

  1. 在try中调用System.exit(0),强制退出了程序,finally块不执行。
  2. 在进入try块前,出现了异常,finally块不执行。

C,finalize方法,这个选项错就错在,这个方法一个对象只能执行一次,只能在第一次进入被回收的队列,而且对象所属于的类重写了finalize方法才会被执行。第二次进入回收队列的时候,不会再执行其finalize方法,而是直接被二次标记,在下一次GC的时候被GC。
放一张图吧

finalize只清理内存中的垃圾

finalize 并不是用来关闭文件的,关闭文件的操作由 一些 native 本地方法处理,finalize只负责内存中垃圾对象的回收

深入理解java虚拟机中说到:
当对象不可达后,仍需要两次标记才会被回收,首先垃圾收集器会先执行对象的finalize方法,但不保证会执行完毕(死循环或执行很缓慢的情况会被强行终止),此为第一次标记。第二次检查时,如果对象仍然不可达,才会执行回收。

一般不要使用finalize,最主要的用途是回收特殊渠道申请的内存。Java程序有垃圾回收器,所以一般情况下内存问题不用程序员操心。但有一种JNI(Java Native Interface)调用non-Java程序(C或C++),finalize()的工作就是回收这部分的内存。

考点1:自增运算符 先加加 后加加

以下程序

1
2
3
4
5
6
main()
{
int m=12,n=34;
printf("%d%d",m++,++n);
printf("%d%d\n",n++,++m);
}

程序运行后的输出结果是()

  • A 12353514
  • B 12353513
  • C 12343514
  • D 12343513
显示答案/隐藏答案正确答案: A

考点2:io sql awt rmi包

进行Java基本的GUI设计需要用到的包是()

  • A java.io
  • B java.sql
  • C java.awt
  • D java.rmi
显示答案/隐藏答案正确答案: C

图形用户界面(Graphical User Interface)GUI 是指采用图形方式显示的计算机操作用户界面
1.java.io提供了全面的IO接口。包含:文件读写,标准设备输出等
2.java.sql提供了Java编程语言访问并且存储数据的API,API包含一个框架
3.java.awt是一个软件包,包含用于用户界面和绘制图像的所有分类;
4.java.rmi提供RMI包,远程调用包(Remote Method Invocation)

图形用户界面(Graphical User Interface,简称 GUI)是指采用图形方式显示的计算机操作用户界面。
java.io提供了全面的IO接口。包括:文件读写、标准设备输出等。
java.sql提供使用 Java 编程语言访问并处理存储在数据源中的数据的 API。此 API包括一个框架,凭借此框架可以动态地安装不同驱动程序来访问不同数据源。
java.awt是一个软件包,包含用于创建用户界面和绘制图形图像的所有分类。功能:包含用于创建用户界面和绘制图形图像的所有类。
java.rmi提供 RMI 包。RMI 指的是远程方法调用 (Remote Method Invocation)。它是一种机制,能够让在某个Java虚拟机上的对象调用另一个 Java 虚拟机中的对象上的方法。

考点3:String类方法

以下代码的输出的正确结果是

1
2
3
4
5
6
public class Test {
public static void main(String args[]) {
String s = "祝你考出好成绩!";
System.out.println(s.length());
}
}
  • A 24
  • B 16
  • C 15
  • D 8
显示答案/隐藏答案正确答案: D

这题就是问这个字符串的长度,没有问占多少个字节啊,不用想的太复杂,就是8.
length() 方法返回的就是字符串的长度,一个 char 可以存下汉字,剩下的数数就完事了。
如果想获得占用字节数的话,可以用 s.getBytes(“GBK”).length,结果就是16了。

考点4:String创建对象 常量池

String s = new String(“xyz”);创建了几个StringObject?

  • A 两个或一个都有可能
  • B 两个
  • C 一个
  • D 三个
显示答案/隐藏答案正确答案: A

如果在常量池中已经存在“xyz”,那么不会继续创建,只创建一个new String(“xyz”)的对象。如果常量池中没有,则会创建两个对象,一个是对象的值“xyz”,一个是new String(“xyz”)的对象。

考点5:lambda表达式

下面哪些写法能在 java8 中编译执行()

  • A dir.listFiles((File f)->f.getName().endsWith(“.Java”));
  • B dir.listFiles((File f)=>f.getName().endsWith(“.Java”));
  • C dir.listFiles((_.getName().endsWith(“.Java”)));
  • D dir.listFiles(f->f.getName().endsWith(“.Java”));
显示答案/隐藏答案正确答案: AD

Lambda表达式的主要作用就是代替匿名内部类的繁琐语法, 它由三部分组成:
(1) 形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数,甚至连形参列表的圆括号也可以省略。
(2) 箭头(→)。必须通过英文中画线和大于符号组成。
(3)代码块。如果代码块只包含一条语句,Lambda表达式允许省略代码块的花括号,那么那条语句就不要用花括号表示语句结束。Lambda代码块只有一条return语句,甚至可以省略return关键字。Lambda表达式需要返回值,而它的代码块中仅有一套省略了return的语句。Lambda表达式会自动返回这条语句的值。
由此可见,应该是A和D正确。

考点6:静态代码块

有关静态初始化块说法正确的是?

  • A 无法直接调用静态初始化块
  • B 在创建第一个实例前或引用任何静态成员之前,将自动调用静态初始化块来初始化
  • C 静态初始化块既没有访问修饰符,也没有参数
  • D 在程序中,用户可以控制何时执行静态初始化块
显示答案/隐藏答案正确答案: ABC

考点7:io流

与InputStream流相对应的Java系统的“标准输入对象”是()

  • A System.in
  • B System.out
  • C System.err
  • D System.exit()
显示答案/隐藏答案正确答案: A

考点8:循环

以下代码的循环次数是

1
2
3
4
5
6
7
8
9
10
public class Test {
public static void main(String args[]) {
int i = 7;
do {
System.out.println(--i);
--i;
} while (i != 0);
System.out.println(i);
}
}
  • A 0
  • B 1
  • C 7
  • D 无限次
显示答案/隐藏答案正确答案: D

从7开始,每次 -2,i 永远不可能==0

考点9:while语句 bealean表达式

关于下面程序,哪些描述是正确的: ( )

1
2
3
4
5
6
7
8
9
 public class While {
public void loop() {
int x= 10;
while ( x ) {
System.out.print("x minus one is " + (x - 1));
x -= 1;
}
}
}
  • A 行1有语法错误
  • B 行4有语法错误
  • C 行5有语法错误
  • D 行6有语法错误
  • E 行2有语法错误,loop是关键字
  • F 程序能够正常编译和运行
显示答案/隐藏答案正确答案: B

while()括号里参数必须是布尔类型,要么true要么false。
x是int类型,是int表达式,int表达式不能作为while的条件。

考点10:关系模型和对象模型的相互转换

一般情况下,以下哪个选项不是关系数据模型与对象模型之间匹配关系?

  • A 表对应类
  • B 记录对应对象
  • C 表的字段对应类的属性
  • D 表之间的参考关系对应类之间的依赖关系
显示答案/隐藏答案正确答案: D

目前ORMapping只是规定了数据结构和数据集的映射关系,还没到规定赖关系的阶段
一般关系数据模型和对象数据模型之间有以下对应关系:表对应类,记录对应对象,表的字段对应类的属性。

考点11:自增运算符

下面的程序将来打印什么?()

1
2
3
4
5
6
7
public class TestIncr {
public static void main(String args[]) {
int i = 0;
i = i++ + i;
System.out.println("I =" +i);
}
}
  • A I = 1
  • B I = 2
  • C I = 3
  • D 编译出错
显示答案/隐藏答案正确答案: A

考点12:super关键字

关键字super的作用是?

  • A 用来访问父类被隐藏的非私有成员变量
  • B 用来调用父类中被重写的方法
  • C 用来调用父类的构造函数
  • D 以上都是
显示答案/隐藏答案正确答案: D

考点13:线程输出

执行以下程序,最终输出可能是:
这里有一张图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Thread[] ths = new Thread[3];
for (int i = 0; i < 3; i++) {
ths[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j <5; j++) {
System.out.println(j);
}
System.out.println(" ");
}
});
}
for (Thread th:ths){
th.start();
}

*代表空格

  • A 010 2123012 3434
  • B 01201 340124 2334
  • C 0012314 01223344**
  • D 12345 12345 12345
显示答案/隐藏答案正确答案: C

线程间是异步的,也就是随机调用的;而线程内部是同步的,也就是顺序执行的。
有4才会有空格 空格之前没4 的全错
三个线程,三个空格,只有C输出了三个空格,其他都是俩哈哈哈

考点14:Java体系结构

Java的体系结构包含( )。

  • A Java编程语言
  • B Java类文件格式
  • C Java API
  • D JVM
显示答案/隐藏答案正确答案: ABCD

Java体系结构包括四个独立但相关的技术:

  • Java程序设计语言
  • Java.class文件格式
  • Java应用编程接口(API)
  • Java虚拟机 我们再在看一下它们四者的关系:

当我们编写并运行一个Java程序时,就同时运用了这四种技术,用Java程序设计语言编写源代码,把它编译成Java.class文件格式,然后再在Java虚拟机中运行class文件。当程序运行的时候,它通过调用class文件实现了Java API的方法来满足程序的Java API调用

考点15:设计模式 管理模式两个基本要点

单例模式中,两个基本要点是

  • A 构造函数私有
  • B 静态工厂方法
  • C 以上都不对
  • D 唯一实例
显示答案/隐藏答案正确答案: AD

考点16:包装类 包装类默认缓存 包装类和基本类型可以比较值

以下语句返回值为 true 的是()

1
2
3
4
5
6
Integer a1=17,a2=17;
Integer b1=2017,b2=2017;
Integer c1=new Integer(2017);
Integer c2=new Integer(2017);
Integer d1=new Interger(2017);
int d2=2017;
  • A a1==a2
  • B d1==d2
  • C b1==b2
  • D c1==c2
显示答案/隐藏答案正确答案: AB
1
2
3
4
5
6
7
8
9
10
11
Integer a1=17,a2=17;
Integer b1=2017,b2=2017;
Integer c1=new Integer(2017);
Integer c2=new Integer(2017);
Integer d1=new Integer(2017);
int d2=2017;

System.out.println(a1 == a2);
System.out.println(d1 == d2);
System.out.println(b1 == b2);
System.out.println(c1 == c2);

运行结果:

1
2
3
4
true
true
false
false

考点1:catch先捕获子类异常再捕获父类异常

在异常处理中,若try中的代码可能产生多种异常则可以对应多个catch语句,若catch中的参数类型有父类子类关系,此时应该将父类放在后面,子类放在前面。

  • A 正确
  • B 错误
显示答案/隐藏答案正确答案: A

如果将父类放在前面的话,异常将被父类完全捕获,子类永远不能捕获异常

考点2:自动拆箱

有如下4条语句:()

1
2
3
4
Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);

以下输出结果为false的是:

  • A System.out.println(i01==i02);
  • B System.out.println(i01==i03);
  • C System.out.println(i03==i04);
  • D System.out.println(i02==i04);
显示答案/隐藏答案正确答案: C

int和Integer比较时 Integer会自动拆箱取出值来和int进行比较

A选项,i01==i02,i02是int类型的,i01是Integer类型的,int类型的i02和Integer类型i01比较时,会给i02自动拆箱,取出里面的值59和i01的值59进行比较,59==59为true
D选项,A选项一样,i02是int类型,i04是Integer类型的,比较值,59==59,得到true
Integer有默认缓存[-128,+127]

Integer i01=59;会自动装箱,实际上调用:

1
Integer i01=Integer.valueOf(59);

1
Integer i03=Integer.valueOf(59);

59在区间[-128,+127]内,所以是同一个对象。

B选项,i01==i03,i01是Integer的引用变量名,i02是Integer引用变量,两个引用变量使用==比较时比较的是地址。
因为i01和i03引用的都是区间[-128,+127]内事先创建好的59,所以是同一个对象。所以得到true

C选项,i03==i04,i03引用的是缓存内的59,i04引用的是新创建的59对象。这两个对象不是同一个对象,所以得到false。

考点3:JVM参数 不懂 待学

假如某个JAVA进程的JVM参数配置如下:
-Xms1G -Xmx2G -Xmn500M -XX:MaxPermSize=64M -XX:+UseConcMarkSweepGC -XX:SurvivorRatio=3,
请问eden区最终分配的大小是多少?

  • A 64M
  • B 500M
  • C 300M
  • D 100M
显示答案/隐藏答案正确答案: C

这是网易2016年在线笔试题中的一道选择题。
先分析一下里面各个参数的含义:
-Xms:1G , 就是说初始堆大小为1G
-Xmx:2G , 就是说最大堆大小为2G
-Xmn:500M ,就是说年轻代大小是500M(包括一个Eden和两个Survivor)
-XX:MaxPermSize:64M , 就是说设置持久代最大值为64M
-XX:+UseConcMarkSweepGC , 就是说使用使用CMS内存收集算法
-XX:SurvivorRatio=3 , 就是说Eden区与Survivor区的大小比值为3:1:1
题目中所问的Eden区的大小是指年轻代的大小,直接根据-Xmn:500M和-XX:SurvivorRatio=3可以直接计算得出
500M*(3/(3+1+1))
=500M(3/5)
=500M
0.6
=300M
所以Eden区域的大小为300M。

参数解释:
-Xms1G :初始堆空间为1G
-Xmx2G :指定最大堆空间为2G
-Xmn500M :指定堆空间的年轻代大小为500M(年轻代=Eden+Survivor)
-XX:MaxPermSize=64M:指定最大永久代为64M
-XX:+UseConcMarkSweepGC 使用CMS垃圾收集器
-XX:SurvivorRatio=3 指定堆的年轻代中Eden和Survivor区的比例,也就是Eden:Survivor(from):Survivor(to)=3:1:1
由-Xmn500M可知:eden=3/5*500M=300M
答案为C,
堆内存示意图:

考点4:

下列关于Java并发的说法中正确的是()

  • A CopyOnWriteArrayList适用于写多读少的并发场景
  • B ReadWriteLock适用于读多写少的并发场景
  • C ConcurrentHashMap的写操作不需要加锁,读操作需要加锁
  • D 只要在定义int类型的成员变量i的时候加上volatile关键字,那么多线程并发执行i++这样的操作的时候就是线程安全的了
显示答案/隐藏答案正确答案: B

答案:B
A,CopyOnWriteArrayList适用于写少读多的并发场景
B,ReadWriteLock即为读写锁,他要求写与写之间互斥,读与写之间互斥,读与读之间可以并发执行。在读多写少的情况下可以提高效率
C,ConcurrentHashMap是同步的HashMap,读写都加锁
D,volatile只保证多线程操作的可见性,不保证原子性

对于D选项,volatite只保证线程在“加载数据阶段”加载的数据是最新的,并不能保证线程安全。

volatite

对于D选项,volatite只保证线程在“加载数据阶段”加载的数据是最新的,并不能保证线程安全。
一个线程执行的过程有三个阶段:
加载(复制)主存数据到操作栈 –> 对操作栈数据进行修改 –> 将操作栈数据写回主存。

volatite关键字,让编译器不去优化代码使用缓存等,以保证线程在“加载数据阶段”加载的数据都是最新的
比如:
某一时刻i=6是最新的值,volatile保证线程A,B都同时加载了这个最新的值,
然后A执行i(A)+1=7,然后将7写回主存,
B也执行i(B)+1=7,然后也将7写回内存,
这样,执行两次加法,i却只增加了1。

对于volatile修饰的变量,jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的,同时线程工作内存中的操作并不是原子性的。所以在一个线程对该变量进行操作的同时,其他的线程有可能也在对该变量进行操作。

A:CopyOnWrite并发容器用于读多写少的并发场景,Copy-On-Write简称COW,是一种用于程序设计中的优化策略。其基本思路是,从一开始大家都在共享同一个内容,当某个人想要修改这个内容的时候,才会真正把内容Copy出去形成一个新的内容然后再改,这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet。
C:在JDK1.7之前,ConcurrentHashMap是通过分段锁机制来实现的,所以其最大并发度受Segment的个数限制。因此,在JDK1.8中,ConcurrentHashMap的实现原理摒弃了这种设计,而是选择了与HashMap类似的数组+链表+红黑树的方式实现,而加锁则采用CAS和synchronized实现。读写都加锁
D:volatile保证内存可见性和有序性(内存屏障实现),不能保证原子性。

考点5:

如果希望监听TCP端口9000,服务器端应该怎样创建socket?

  • A new Socket(“localhost”,9000);
  • B new ServerSocket(9000);
  • C new Socket(9000);
  • D new ServerSocket(“localhost”,9000);
显示答案/隐藏答案正确答案: B

答案选B。
ServerSocket(int port)是服务端绑定port端口,调accept()监听等待客户端连接,它返回一个连接队列中的一个socket。
Socket(InetAddress address ,int port)是创建客户端连接主机的socket流,其中InetAddress是用来记录主机的类,port指定端口。
socket和servletSocket的交互如下图所示:

详细了解,大家可以看此博客:http://www.cnblogs.com/rond/p/3565113.html

  • 服务端:ServerSocket(port),因为服务器知道自己的IP,所以不需要输入IP
  • 客户端:Socket(host,port),因为客户端不知道连接那个服务端,所以需要输入服务器的IP

首先,服务器监听端口的必定用 ServerSocket;其次,根据对 Server 和 Client 的了解,
Server 只需要监听请求即可,
Client 则必须指明向谁请求和向服务器的哪个端口请求。

ServerSocket(int port)创建一个serversocket绑定在服务器的特定的端口
Socket(InetAddress address, int port)创建一个socket流,连接到指定服务器(address)的指定端口(port)

考点6:

下列描述正确的是( )?

  • A 类不可以多继承而接口可以多实现
  • B 抽象类自身可以定义成员而接口不可以
  • C 抽象类和接口都不能被实例化
  • D 一个类可以有多个基类和多个基接口
显示答案/隐藏答案正确答案: AC

1.java支持单继承,却可以实现多个接口。a对d错
2.接口没有构造方法,所以不能实例化,抽象类有构造方法,但是不是用来实例化的,是用来初始化的。c对
3.抽象类可以定义普通成员变量,静态成员变量。接口只能定义静态成员常量,也就是接口成员变量要使用 public static final来修饰。b错

接口只能定义静态成员常量

考点7:

下面的Java赋值语句哪些是有错误的 ()

  • A int i =1000;
  • B float f = 45.0;
  • C char s = '\u0639'
  • D Object o = 'f';
  • E String s = "hello,world\0";
  • F Double d = 100;
显示答案/隐藏答案正确答案: BCF

B选项45.0默认是double类型的。
C选项少了分号
F选项是自动装箱, 装箱过程中调用的是Double类的valueOf(double d)方法, 而这里是100为int型, 所以编译会“cannot convert from int to Double”。

考点1:依赖注入

下面关于依赖注入(DI)的说法不正确的是()

  • A 只有通过Spring才能实现依赖注入(DI)
  • B 依赖注入的主要目的是解耦合
  • C 常见的依赖注入方式有Setter和构造方法
显示答案/隐藏答案正确答案: A

Spring依赖注入(DI)的三种方式,分别为:
1.接口注入
2.Setter方法注入
3.构造方法注入

属性注入:
创建对象时候,向类里面属性里面设置值
注入的三种方式(java),在Spring框架中只支持前面两种方式

第一种:使用set方法注入

1
2
3
4
5
6
7
8
public class User{
private String name;
public void setName(String name){
this.name=name;
}
}
User user=new User();
user.setName("abcd");

第二种:有参数构造注入

1
2
3
4
5
6
7
public class User{
private String name;
public User(String name){
this.name=name;
}
}
User user=new User("lucy");

第三种:使用接口注入

1
2
3
4
5
6
7
8
9
public interface Dao{
public void delete(String name);
}
public class DaoImplements Dao{
private String name;
public void delete(String name){
this.name=name;
}
}

sping使用 有参数构造注入属性

1
2
3
<bean id="demo" class="cn.itcast.property.propertyDemo1">
<constructor-arg name="username" value="小王小马"></constructor>
</bean>
1
2
3
4
5
6
7
8
9
public class TestIOC{
public void testUser(){
// 1.加载Spring配置文件,根据创建对象
APPlicationContext context=new ClassPathXmlApplicationContext("bean1.xml")
// 2.得到配置创建的对象
PropertyDemo1 demo1=(PropertyDemo1)context.getBean("demo");
demo1.test1();
}
}

spring使用set方法注入属性(使用的更多)

1
2
3
4
5
<!-- 代表对象已经创建 -->
<bean id="book" class="cn.itcast.property.Book">
<!-- name属性值:类里面定义的属性名称 value属性:设置具体的值 -->
<property name="bookname" vlaue="易筋经"></property>
</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Book{
private String bookname;
public void setName(String bookname){
this.bookname=bookname;
}
public void demobook(){
system.out.println("book........"+bookname);
}
}
public class TestIOC{
public void testUser(){
// 1.加载Spring配置文件,根据创建对象
APPlicationContext context=new ClassPathXmlApplicationContext("bean1.xml")
// 2.得到配置创建的对象
Book book=(Book)context.getBean("book");
book.demobook();
}
}

这篇博文讲到依赖注入。除了spring,还有.net平台一些框架也用到了依赖注入。
http://www.cnblogs.com/yangecnu/p/Introduce-Dependency-Injection.html

考点2:for循环执行流程

下列循环语句序列执行完成后,i的值是()

1
2
3
4
int i;
for(i=2;i<=10;i++){
System.out.println(i);
}
  • A 2
  • B 10
  • C 11
  • D 不确定
显示答案/隐藏答案正确答案: C

for循环的执行顺序

1
2
3
4
for(表达式1;表达式2;表达式3
{
//循环体
}
  1. 表达式1执行一次,判断表达式2是否成立,如果成立执行循环体;
  2. 循环体结束,表达式3执行一次,判断表达式2是否成立,如果成立执行循环体;
  3. 依次进行2的操作。直到表达式2不成立,退出循环。

这个循环最后一次进入循环体时;i=10了,然后执行表达式3,i=11,最后执行表达式2,判断11大于10,退出循环。

考点3:Servlet

从以下哪一个选项中可以获得Servlet的初始化参数?

  • A Servlet
  • B ServletContext
  • C ServletConfig
  • D GenericServlet
显示答案/隐藏答案正确答案: C

通过ServletConfig接口的getInitParameter(java.lang.String name)方法。

1)ServletConfig:Servlet的配置对象,容器在初始化Servlet时通过它传递信息给Servlet。
2)ServletContext:上下文对象,提供了一系列方法供Servlet与Web容器交互。

  • ServletConfig对象:servlet配置对象,主要把servlet的初始化参数封装到这个对象中。一个网站中可能会存在多个servletConfig对象,一个servletConfig对象就封装了一个servlet的配置信息。可以在web.xml中通过<init-param></init-param>标签配置初始化参数,通过getInitParameter(String name)或getInitParameterNames()方法来获取初始化参数。注:初始化参数必须在当前的servlet程序中使用。
  • ServletContext对象:servlet上下文对象。一个网站只会创建一个servletContext对象,代表的是整个网站的环境信息。可以在web.xml中通过<context-param></context-param>标签配置全局参数,是通过servletConfig对象来获取servletContext对象的,调用的是getServletContext()方法。注:如果某个参数整个网站的程序都要使用,那么可将该参数设置为全局参数,因为可通过servletContext域对象去获取。在servle中有三个域对象,分别为:ServletContext、HttpServletRequest和HttpSession。

考点4:基本数据类型

在 Java 中,属于整数类型变量的是()

  • A single
  • B double
  • C byte
  • D char
显示答案/隐藏答案正确答案: C

Java八种基本数据类型

Java中的四类八种基本数据类型
第一类:整数类型 byte short int long
第二类:浮点型 float double
第三类:逻辑型 boolean(它只有两个值可取true false)
第四类:字符型 char

考点5:Byte表示范文 Byte越界 自动拆箱装箱 引用传参

如下代码,执行test()函数后,屏幕打印结果为()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test2
{
public void add(Byte b)
{
b = b++;
}
public void test()
{
Byte a = 127;
Byte b = 127;
add(++a);
System.out.print(a + " ");
add(b);
System.out.print(b + "");
}
}
  • A 127 127
  • B 128 127
  • C 129 128
  • D 以上都不对
显示答案/隐藏答案正确答案: D

Byte类型值大小为-128~127之间。并且Byte类型的值首尾相连,越界不会抛出异常
add(++a);这里++a会越界,a的值变为-128
add(b); 前面说了,add不起任何作用,b还是127

add()方法里面的修改值并不会起作用,而add(++a)会使a数值越界成-128,所以输出为-128 127

考点6:main方式是静态方法不能访问非静态成员变量

1
2
3
4
5
6
7
8
public class Test
{
public int x;
public static void main(String []args)
{
System. out. println("Value is" + x);
}
}

对于上面这段代码,以下说法正确的是:

  • A 程序会打出 “Value is 0”
  • B 程序会抛出 NullPointerException
  • C 非静态变量不能够被静态方法引用
  • D 编译器会抛出 “possible reference before assignment”的错误
显示答案/隐藏答案正确答案: C

非静态成员只能被类的实例化对象引用,因此这里在静态方法中访问x会造成编译出错

当类加载时,static静态方法随着类加载而初始化,此时实例对象还未被创建,但是非静态成员变量需要等到实例对象创建才会被初始化,故无法被引用。

考点7:Java表示符规则

下列不正确的 Java 语言标识符是( )

  • A Sky
  • B $Computer
  • C for
  • D NULL
显示答案/隐藏答案正确答案: C

Java标识符命名规范是:
1)只能包含字母a-zA-Z,数字0-9,下划线_和美元符号$;
2)首字母不能为数字;
3)关键字和保留字不能作为标识符。

中文可以作为变量名

中文可以作为变量名,中文的货币符号也是中文字符,也是可以作为变量名的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package base;

public class BiaoShiFu {
public static void main(String[] args) {
String ¥str = "123";
String 你好 = "helloWorld";
System.out.println(¥str);
System.out.println(你好);
真的吗();
}

public static void 真的吗() {
System.out.println("真的吗?我不信!");
}
}

运行结果:

1
2
3
123
helloWorld
真的吗?我不信!

考点8:基础知识

以下说法中正确的有?

  • A StringBuilder是 线程不安全的
  • B Java类可以同时用 abstract和final声明
  • C HashMap中,使用 get(key)==null可以 判断这个Hasmap是否包含这个key
  • D volatile关键字不保证对变量操作的原子性
显示答案/隐藏答案正确答案: AD

考点9:并发

JDK提供的用于并发编程的同步器有哪些?

  • A Semaphore
  • B CyclicBarrier
  • C CountDownLatch
  • D Counter
显示答案/隐藏答案正确答案: ABC

答案:ABC
A,Java 并发库 的Semaphore 可以很轻松完成信号量控制,Semaphore可以控制某个资源可被同时访问的个数,通过
acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可。
B,CyclicBarrier 主要的方法就是一个:await()。await()
方法没被调用一次,计数便会减少1,并阻塞住当前线程。当计数减至0时,阻塞解除,所有在此 CyclicBarrier 上面阻塞的线程开始运行。
C,直译过来就是倒计数(CountDown)门闩(Latch)。倒计数不用说,门闩的意思顾名思义就是阻止前进。在这里就是指
CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程。
D,Counter不是并发编程的同步器