云漾科技面试题

1、String是否可以被继承，为什么？

String类不能被继承，因为它是被final修饰的

String的完整签名是：
public final class String

2、HashMap、HashTable、concurrentHashMap、LinkHashMap的区别.

HashMap和HashTable区别：

1.HashMap是非synchronized,hashTable 是synchronized;

2.HashMap可以接受为Null的Key和value，而hashtable不能接受；(在hashtable中会提示空指针异常NullPointerException)

concurrentHashMap 和 HashTable 区别

Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。因为ConcurrentHashMap引入了分割(segmentation)，不论它变得多么大，仅仅需要锁定map的某个部分，而其它的线程不需要等到迭代完成才能访问map。简而言之，在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，而Hashtable则会锁定整个map

LinkedHashMap 是HashMap的一个子类，如果需要输出的顺序和输入的相同,那么用LinkedHashMap可以实现,它还可以按读取顺序来排列，像连接池中可以应用。

3、HashMap、concurrentHashMap底层的实现原理.

详情请参考：https://blog.csdn.net/qq_27093465/article/details/52279473

4、java.util.concurrent中有哪些类?

Condition、CountDownLatch、Semaphore、ReentrantLock、ReentrantReadWriteLock、Callable。详情请见这一篇：

5、volatile是关键字吗，可以用其替代锁吗？

详情请参考：http://ifeve.com/volatile/

6、redis是什么，用在什么场景

1、为什么使用

解决应用服务器的cpu和内存压力
减少io的读操作，减轻io的压力
关系型数据库的扩展性不强，难以改变表结构

2、优点：

nosql数据库没有关联关系，数据结构简单，拓展表比较容易
nosql读取速度快，对较大数据处理快

3、适用场景：

数据高并发的读写
海量数据的读写
对扩展性要求高的数据

4、不适场景：

需要事务支持（非关系型数据库）
基于sql结构化查询储存，关系复杂

10、请写出一种单例模式、并说出其优缺点

饿汉式

public class Student{
    private Student(){}

    private static Student s = new Student();

    public static Student getStudent(){
        return s;
    }
}

懒汉式

public class Teacher{

    private Student(){}

    private static Teacher t = null;

    public static Teacher getTeacher(){
        if(t == null){
            t = new Teacher();
        }
    return t;
    }
}

饿汉式和懒汉式的区别？

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了。
懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

另外从以下两点再区分以下这两种方式：

1、线程安全：
饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，
懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能：
饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，
懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

11、请设计出一种生产者、消费者模式
设计模式-生产者消费者模式
常见情景：
某个模块负责产生数据，这些数据由另一个模块来负责处理。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。

该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据

缓冲区作用

1、解耦，生产者和消费者只依赖缓冲区，而不互相依赖

2、支持并发和异步

方式一：同步队列

/**
 * 生产者、消费者缓冲区
 */
public class Storage implements IStorage {

private final int maxSize = 10;
private Queue<Object> queue = new LinkedList<Object>();

@Override
public void put(Object obj) {
    synchronized (queue) {
        while (queue.size() > maxSize) {
            System.out.println("缓冲区已满，不能进入");
            try {
                queue.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        queue.add(obj);
        System.out.println("进入缓冲区");
        queue.notifyAll();
    }
}

@Override
public Object get() {
    Object obj = null;
    synchronized (queue) {
        while (queue.size() <= 0) {
            System.out.println("缓冲区为空, 进入等待");
            try {
                queue.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        obj = queue.poll();
        System.out.println("离开缓冲区");
        queue.notifyAll();
    }

    return obj;
}
}

方法二：可重入锁

public class Storage implements IStorage {

private final int maxSize = 20;
private LinkedList<Object> list = new LinkedList<Object>();
private final Lock lock = new ReentrantLock();

// 仓库满的条件变量
private final Condition full = lock.newCondition();

// 仓库空的条件变量
private final Condition empty = lock.newCondition();

@Override
public void put(Object obj) {
    lock.lock();

    while (list.size() >= maxSize) {
        try {
            System.out.println("缓冲区已满，不能进入");
            // 生产阻塞
            full.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    list.add(obj);
    System.out.println("进入缓冲区");
    empty.signalAll();

    lock.unlock();
}

@Override
public Object get() {
    lock.lock();

    while (list.size() <= 0) {
        try {
            System.out.println("缓冲区为空, 进入等待");
            // 消费阻塞
            empty.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    Object obj = list.remove();
    System.out.println("离开缓冲区");
    full.signalAll();

    lock.unlock();

    return obj;
}
}

方法三：阻塞队列

  public class Storage implements IStorage {

private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(10);

@Override
public void put(Object obj) {
    try {
        list.put(obj);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("进入缓冲区");
}

@Override
public Object get() {
    Object obj = null;
    try {
        obj = list.take();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("离开缓冲区");
    return obj;
}
}

转载自：https://www.cnblogs.com/alex09/p/6675664.html****

12、请根据下面的表格，写出其要求的sql

ID	NAME
1	a
2	b
3	b
4	a
5	c
6	c

请写一条删除语句，判断id值，id值较大的删除掉，留下较小的，如下表格展示

ID	NAME
1	a
2	b
5	c

sql语句如下：

delete from user where id not in ( select id from (select id from user group by name) a)

13、请根据下面的表格，写出其要求的sql

name sex count

中国 1 100

中国 2 120

日本 1 80

日本 2 130

美国 1 150

美国 2 100

如果sex =1代表男，sex=2代表女，则将上面的表格变为下面的格式

name	男	女
中国	100	120
日本	80	130
美国	150	100

请写出对应的sql
sql语句如下：

select c.name,c.count 男,a.count 女 from cc c LEFT JOIN (select name,sex,count from cc) a on a.name = c.name where c.sex =1 and a.sex=2 group by c.name

1、String是否可以被继承，为什么？

2、HashMap、HashTable、concurrentHashMap、LinkHashMap的区别.

3、HashMap、concurrentHashMap底层的实现原理.

4、java.util.concurrent中有哪些类?

5、volatile是关键字吗，可以用其替代锁吗？

6、redis是什么，用在什么场景

7、消息队列的使用场景

8、请描述jvm的内存结构

9、说出java内存中是类加载器

10、请写出一种单例模式、并说出其优缺点

11、请设计出一种生产者、消费者模式

设计模式-生产者消费者模式

12、请根据下面的表格，写出其要求的sql

13、请根据下面的表格，写出其要求的sql