Java学习记录——错题总结（二十四）

第一套

1.ResultSet中记录行的第一列索引为？
正确答案: C 你的答案: B (错误)
-1
0
1
以上都不是

答案：C
ResultSet跟普通的数组不同，索引从1开始而不是从0开始

2.下面叙述那个是正确的？（）
正确答案: B 你的答案: B (正确)
java中的集合类（如Vector）可以用来存储任何类型的对象，且大小可以自动调整。但需要事先知道所存储对象的类型，才能正常使用。
在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销。
java接口包含函数声明和变量声明。
java中，子类不可以访问父类的私有成员和受保护的成员。

我就说下B选项和C选项。
B选项说的情况就是我们自定义异常的情况，请仔细读：我们可以用违例（Exception）来抛出一些并非错误的消息，可以，并非错误的消息。比如我自定义一个异常，若一个变量大于10就抛出一个异常，这样就对应了B选项说的情况，我用抛出异常说明这个变量大于10，而不是用一个函数体（函数体内判断是否大于10，然后返回true或false）判断，因为函数调用是入栈出栈，栈是在寄存器之下的速度最快，且占的空间少，而自定义异常是存在堆中，肯定异常的内存开销大！所以B对。
C选项说的是接口包含方法声明和变量声明。因为接口中方法默认是 abstract public,所以在接口只写函数声明是符合语法规则。但是变量默认是用public final static 修饰的，意思它是静态常量，常量不管在接口中还是类中必须在声明时初始化！所以C的后半句是错的，必须在声明时并给出初始化！、

第二套

1.下面这段java代码，当 T 分别是引用类型和值类型的时候，分别产生了多少个 T对象和T类型的值（）
T t = new T();(值类型时:T t;)
Func(t);
Func 定义如下：
public void Func(T t) { }

正确答案: D 你的答案: B (错误)
1 1
2 1
2 2
1 2

D。引用类型作为函数的参数时，复制的是引用的地址，不会产生一个新的T；而如果T是值类型，其作为函数实参时会复制其值，也就是产生了一个新的T。所以D选项正确

值类型的对象我觉得并没有创建对象 而且值类型能叫对象吗？

答案在A和D之间 这个毫无悬念

主要就在值类型能否创建对象 能创建对象则又能创建几个对象
值类型即八大基础类型，基础类型在使用时是从常量池中获取，更严谨的而言其实是在-128~127之间 使用时是从常量池中获取，那么在使用的时候将常量池中的地址重复利用
但是在限制范围之外，得到的地址就会发生变化 代码为证

2.以下哪个命令用于查看tar（backup.tar）文件的内容而不提取它?（）

正确答案: B 你的答案: C (错误)
tar -xvf backup.tar
tar -tvf backup.tar
tar -svf backup.tar
none of these

把常用的tar解压命令总结下，当作备忘：
tar
-c: 建立压缩档案
-x：解压
-t：查看内容
-r：向压缩归档文件末尾追加文件
-u：更新原压缩包中的文件

这五个是独立的命令，压缩解压都要用到其中一个，可以和别的命令连用但只能用其中一个。下面的参数是根据需要在压缩或解压档案时可选的。

-z：有gzip属性的
-j：有bz2属性的
-Z：有compress属性的
-v：显示所有过程
-O：将文件解开到标准输出

下面的参数-f是必须的

-f: 使用档案名字，切记，这个参数是最后一个参数，后面只能接档案名。

# tar -cf all.tar *.jpg 
这条命令是将所有.jpg的文件打成一个名为all.tar的包。-c是表示产生新的包，-f指定包的文件名。

# tar -rf all.tar *.gif 
这条命令是将所有.gif的文件增加到all.tar的包里面去。-r是表示增加文件的意思。

# tar -uf all.tar logo.gif 
这条命令是更新原来tar包all.tar中logo.gif文件，-u是表示更新文件的意思。

# tar -tf all.tar 
这条命令是列出all.tar包中所有文件，-t是列出文件的意思

# tar -xf all.tar 
这条命令是解出all.tar包中所有文件，-x是解开的意思


压缩

tar –cvf jpg.tar *.jpg  将目录里所有jpg文件打包成tar.jpg
tar –czf jpg.tar.gz *.jpg   将目录里所有jpg文件打包成jpg.tar后，并且将其用gzip压缩，生成一个gzip压缩过的包，命名为jpg.tar.gz
tar –cjf jpg.tar.bz2 *.jpg 将目录里所有jpg文件打包成jpg.tar后，并且将其用bzip2压缩，生成一个bzip2压缩过的包，命名为jpg.tar.bz2
tar –cZf jpg.tar.Z *.jpg   将目录里所有jpg文件打包成jpg.tar后，并且将其用compress压缩，生成一个umcompress压缩过的包，命名为jpg.tar.Z
rar a jpg.rar *.jpg rar格式的压缩，需要先下载rar for linux
zip jpg.zip *.jpg   zip格式的压缩，需要先下载zip for linux 
解压

tar –xvf file.tar  解压 tar包
tar -xzvf file.tar.gz 解压tar.gz
tar -xjvf file.tar.bz2   解压 tar.bz2
tar –xZvf file.tar.Z   解压tar.Z
unrar e file.rar 解压rar
unzip file.zip 解压zip

总结

*.tar 用 tar –xvf 解压
*.gz 用 gzip -d或者gunzip 解压
*.tar.gz和*.tgz 用 tar –xzf 解压
*.bz2 用 bzip2 -d或者用bunzip2 解压
*.tar.bz2用tar –xjf 解压
*.Z 用 uncompress 解压
*.tar.Z 用tar –xZf 解压
*.rar 用 unrar e解压
*.zip 用 unzip 解压
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

-s 还原文件的顺序和备份文件内的存放顺序相同。
-t 列出备份文件的内容。
-v 显示指令执行过程。
-f 指定压缩文件
-x 从备份文件中还原文件。

3.单例模式中，两个基本要点是
正确答案: A D 你的答案: A B (错误)
构造函数私有
静态工厂方法
以上都不对
唯一实例

设计模式-单例模式
知识点
什么是单例模式？
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式有分为饿汉式和懒汉式

特点：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
应用实例：

1、一个班级只有一个班主任。
2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
实例
单例模式-饿汉式
//单例模式-饿汉式

public class SingletonDemo {
    public static void main(String[] args) {
        //编译错误：无法实例化
        // Singleton singleton = new Singleton();
 
        //正确获取对象的方法
        Singleton singleton = Singleton.getINSTANCE();
        singleton.hello();
    }
}
 
class Singleton{
    //创建一个本身对象
    private static final Singleton INSTANCE = new Singleton();
 
    //让构造方法为private，这样该类就不会被实例化
    private Singleton(){}
 
    //创建一个获取对象的方法
    public static Singleton getINSTANCE() {
        return INSTANCE;
    }
 
    public void hello(){
        System.out.println("Hello World! ——单例模式-饿汉式");
    }
}
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

结果

Hello World! ——单例模式-饿汉式
1

单例模式-懒汉式（线程不安全版）
这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

//单例模式-懒汉式

public class SingletonDemo2 {
    public static void main(String[] args) {
        Singleton2 singleton = Singleton2.getInstance();
        singleton.hello();
 
    }
 
}
 
class Singleton2{
    private static Singleton2 instance;
    private Singleton2(){}
 
    public static Singleton2 getInstance() {
        if (instance == null){
            instance = new Singleton2();
        }
        return instance;
    }
 
    public void hello(){
        System.out.println("Hello World! ——单例模式-懒汉式");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

结果

Hello World! ——单例模式-懒汉式
1

单例模式-懒汉式（线程安全版）
描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。
//单例模式-懒汉式

public class SingletonDemo3 {
    public static void main(String[] args) {
        Singleton3 singleton = Singleton3.getInstance();
        singleton.hello();
 
    }
 
}
 
class Singleton3{
    private static Singleton3 instance;
    private Singleton3(){}
 
    public synchronized static Singleton3 getInstance() {
        if (instance == null){
            instance = new Singleton3();
        }
        return instance;
    }
 
    public void hello(){
        System.out.println("Hello World! ——单例模式-懒汉式");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

结果

Hello World! ——单例模式-懒汉式
1

饿汉式和懒汉式的区别

1.懒汉模式：顾名思义，他是一个懒汉，他不愿意动弹。什么时候需要吃饭了，他就什么时候开始想办法搞点食物。

即懒汉式一开始不会实例化，什么时候用就什么时候new，才进行实例化。

2.饿汉模式：顾名思义，他是一个饿汉，他很勤快就怕自己饿着。他总是先把食物准备好，什么时候需要吃了，他随时拿来吃，不需要临时去搞食物。

即饿汉式在一开始类加载的时候就已经实例化，并且创建单例对象，以后只管用即可。

懒汉式和饿汉式的安全和性能区别：

（1） 线程安全：饿汉式在线程还没出现之前就已经实例化了，所以饿汉式一定是线程安全的。懒汉式加载是在使用时才会去new 实例的，那么你去new的时候是一个动态的过程，是放到方法中实现的，比如：

public static synchronized Singleton getInstance(){
       　　 if(instance == null){
　　　　　//什么时候用就什么时候new
            　　instance = new Singleton();
       　　 }
1
2
3
4
5

如果这个时候有多个线程访问这个实例，这个时候实例还不存在，还在new，就会进入到方法中，有多少线程就会new出多少个实例。一个方法只能return一个实例，那最终return出哪个呢？是不是会覆盖很多new的实例？这种情况当然也可以解决，那就是加同步锁，避免这种情况发生 。

（2）执行效率：饿汉式没有加任何的锁，因此执行效率比较高。懒汉式一般使用都会加同步锁，效率比饿汉式差。
（3）内存使用：饿汉式在一开始类加载的时候就实例化，无论使用与否，都会实例化，所以会占据空间，浪费内存。懒汉式什么时候用就什么时候实例化，不浪费内存。

第三套

1.执行完以下代码 int [ ] x = new int[10] ；后，以下哪项说明是正确的（ ）

正确答案: A 你的答案: B (错误)
x[9]为0
x[9]未定义
x[10]为0
x[0]为空

数组引用类型的变量的默认值为 null。当数组变量的实例后，如果没有没有显示的为每个元素赋值，Java 就会把该数组的所有元素初始化为其相应类型的默认值。
int型的默认值为0

2.Consider the following code:

Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);
Which test would return true?
1
2
3
4

正确答案: C D E 你的答案: B C E (错误)

(s==u)
(s==t)
(s.equals(t))
(s.equals(9))
(s.equals(new Integer(9))
1
2
3
4
5

int和int之间，用==比较，肯定为true。基本数据类型没有equals方法
int和Integer比较，Integer会自动拆箱，== 和 equals都肯定为true
int和new Integer比较，Integer会自动拆箱，调用intValue方法, 所以 == 和 equals都肯定为true
Integer和Integer比较的时候，由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候，由于值缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是直接从缓存中获取已经创建好的Integer对象。而当大于这个区间的时候，会直接new Integer。
当Integer和Integer进行==比较的时候，在[-128,127]区间的时候，为true。不在这个区间，则为false
当Integer和Integer进行equals比较的时候，由于Integer的equals方法进行了重写，比较的是内容，所以为true

Integer和new Integer ： new Integer会创建对象，存储在堆中。而Integer在[-128,127]中，从缓存中取，否则会new Integer.
所以 Integer和new Integer 进行==比较的话，肯定为false ; Integer和new Integer 进行equals比较的话，肯定为true

new Integer和new Integer进行==比较的时候，肯定为false ; 进行equals比较的时候，肯定为true
原因是new的时候，会在堆中创建对象，分配的地址不同，==比较的是内存地址，所以肯定不同

装箱过程是通过调用包装器的valueOf方法实现的
拆箱过程是通过调用包装器的xxxValue方法实现的（xxx表示对应的基本数据类型）

总结：Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内，==比较的时候，值总是相等的（指向的是同一对象），在这个区间外是不等的。
而Float和Double则不相等， Boolean的值总是相等的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18