Java最全面试宝典

优点:易维护,复用,扩展,面向对象由封装,继承,多态的特性,可以设计出低耦合的系统,使系统更加灵活,更加易于维护

优点:性能高,调用类的时候需要实例化,开销较大,消耗资源

缺点:不易维护,复用和扩展

将数据或者操作数据的方法绑定起来,对数据的访问只能通过已定义的接口,封账就是隐藏一切可隐藏的东西,对外只需提供最简单的编程接口

类可以分为子类和父类,子类继承父类的所有方法和属性

简单说就是用同样的对象引用调用同样的方法但是做了不同的事情.主要体现在方法重载和方法重写

将一些类的共同特征总结出来构造一个类

基本数据类型

引用类型

实现

构造函数

main方法

实现数量

访问修饰符

final

finally

finalize

不能
final修饰后不能被继承

计算机中保存的小数其实是10进制的小数的近似值,并不是很准,建议使用BigDecimal或者Long来表示

Integer是int的封装类

int默认值是0,而Integer的默认是null

可以
java使用的编码是Unicode编码,Unicode编码中包含了汉字,可以存储

&运算符有俩种用法

&&

一个方法,一个运算符

==比较原生类型,equals比较方法俩个对象的内容是否相等

== 如果比较的是基本数据类型,则比较数值是否相等,如果比较引用类型则比较对象的地址值是否相等

equal方法不能用于基本数据类型,如果没有重写,默认比较的是对象的地址

1.提高效率

2.保证同一个对象

重写后俩个方法的关系

2

四舍五入的原理是在参数上加上0.5然后向下取整

-1

四舍五入的原理是在参数上加上0.5然后向下取整

重载

重写

不可以重写,但是可以重载

静态变量

实例变量

隐式转换

显示转换

拆箱

装箱

都是用来控制循环语句的,break用于结束一个循环,跳出循环执行后边的语句,continue是跳过本次循环执行下次循环

都是finall类,不允许被继承

String长度是不可变的

stringBuffer是线程安全的,StringBuilder是不安全的,他俩的所有方法都是相同的,StringBuffer在方法上加了Synchronized,保证线程安全

StringBuilder比StringBuffer拥有更好的性能

如果一个String类型的字符串,在编译时就可以确定是一个字符串常量,编译成功之后自动拼接成一个常量,这时的String速度比StringBuffer和StringBuilder的性能更好

不一样
Sring str = "aaa"创建了1个对象常量,jvm分配在了常量池中
String str = new String("aaa) 创建了2个对象,一个在常量池中,一个在堆内存中

2个引用3个对象
aa和bb都是常量,当执行字符串拼接的时候,创建了一个新的常量aabb

没有
1个引用2个常量对象,原来的hello还存在内存中,只是指针已经指向了新的常量hello world地址

泛型是JDK5引用的一个特性,允许在定义类和接口的时候使用类型参数,泛型最主要应用在集合类框架中,可以提高代码的复用性

E-Element 在集合中使用

T - Type Java类

K - Key  键

V - Value 值

N - Number 数值类型

? - 表示不确定的java类型 无限制通配符类型

Object  所有类的根类 使用的时候需要类型强制转换

系统错误,编译时出现的错误,

程序可以处理的异常,可以捕获且可能回复

空指针

找不到指定的类

字符串转换数字异常

数组下标越界

数据类型转化异常

在方法体内,表示抛出异常,由方法体内的语句处理

抛出的是一个实例

用在方法声明后面,抛出异常,由调用者处理

表示出现异常的一种可能性,并一定发生

List

Set

HashMap

ConcurrentHashMap

TreeMap

HashTable

接口,是各种集合的父接口

工具类,提供一系列的静态方法对各种集合的搜索,排序,线程安全化等操作

二叉树实现的,数据是自动排序好的,不允许放入null值

底层是TreeMap的keySet()在插入的时候调用compareTo()来判断元素是否重用

哈希表实现的,无序的,可以放入null值,但是只能有一个

基本的操作都是由HashMap底层实现的,想HashSet添加元素的时候,先计算元素的hashcode,算出这个元素的存储位置,如果空,添加,不为空的话equals方法比较,相等不添加,不相等找个空位添加

一个具有独立功能的程序

一个进程包含多个线程，是CPU调度和分派的基本单位

等待，不释放锁

调用后，线程等待线程会立即释放掉锁

核心线程池大小

最大线程池大小

线程最大空闲时间

时间单位

等待队列

线程创建工厂

拒绝策略

当线程对象创建后，进入了新建状态

当线程调用start方法进入就绪状态，等待cpu调度，不会立马执行

当cpu调度后进入运行状态，这时候线程才开始运行

线程由于某种原因，暂时放弃cpu使用权，停止执行，这是进入了阻塞状态，知道其状态重新进入了就绪状态，才有机会等待cpu调用重新进入运行状态

阻塞原因有3种

线程执行完或者异常退出run方法，线程死亡

死锁是指因资源被多个线程竞争而导致相互等待，若无外力作用，这些线程无法推行

互斥条件

不剥夺条件

请求保和条件

循环等待条件

线程按照一定的顺序枷锁

线程尝试获取锁的时候加上时限，如果超过规定的时限放弃请求，同时释放自己已占有的锁

jdk1.5之前都是靠synchronized关键字保证同步的，使用synchronized可以确保无论哪个线程持有锁，都采用独有的方式占有资源，独占锁就是悲观锁，所以synchronized就是悲观锁

乐观锁就是假设数据一般情况下不会造成冲突，在数据提交更新的时候，才会对数据的冲突进行检测，如果发生冲突，则返回错误信息让用户自己决定如果处理

乐观锁只能保证一个变量的原子性

长时间自旋导致开销变大

ABA问题：假如某内存值为A,通过某一线程改为了B,最后又改成了A,则CAS认为值没有改变，实际上是有改变的

如果正在运行的线程小于corePoolSize，则立马创建线程执行任务

如果正在运行的线程大于或者等于corePoolSize，线程池会将任务放入队列

如果这个时候队列满了，而且正在运行的数量小于maximumPoolSize，那么还是要创建线程运行这个任务

如果队列满了，而且正在运行的数量大于或者等于maximumPoolSize，那么线程池会抛出异常

使一个线程处于等待状态，并且释放持有的锁

是一个正在运行的线程处于休眠状态

唤醒一个处于等待状态的线程，有CPU去决定唤醒哪个

唤醒所有等待的线程，该方法不是将对象的锁给所有线程，而是让他们竞争

它是一种数据的流从源头流到目的地.比如拷贝文件,输入流和输出流都包括了.输入流从文件中读取数据存储到进程中,输出流从进程中读取数据然后写入到目标文件

按照方向

实现功能

按照处理数据的单位

字节流在JDK1.0中就被引进了，用于操作包含ASCII字符的文件。JAVA也支持其他的字符如Unicode，为了读取包含Unicode字符的文件，JAVA语言设计者在JDK1.1中引入了字符流。ASCII作为Unicode的子集，对于英语字符的文件，可以可以使用字节流也可以使用字符流。

字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

这是在拷贝文件操作的时候，经常用到的两个类。在处理小文件的时候，它们性能表现还不错，在大文件的时候，最好使用BufferedInputStream (或 BufferedReader) 和 BufferedOutputStream (或 BufferedWriter)

Files. size()：查看文件个数。

Files. read()：读取文件。

Files. write()：写入文件。

Files. exists()：检测文件路径是否存在。

Files. createFile()：创建文件。

Files. createDirectory()：创建文件夹。

Files. delete()：删除一个文件或目录。

Files. copy()：复制文件。

Files. move()：移动文件。

序列化：

序列化的实现：

在 java 中能够被序列化的类必须先实现Serializable接口，该接口没有任何抽象方法只是起到一个标记作用。

实现 Cloneable 接口并重写 Object 类中的 clone()方法；

实现 Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用 Object 类的 clone
方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时

同步阻塞式IO，服务端创建一个ServerSocket，然后客户端用一个Socket去连接那个ServerSocket，然后ServerSocket接收到一个Socket的连接请求就创建一个Socket和一个线程去跟那个Socket进行通信。

public class BioServer {  
    public static void main(String[] args) {
        // 服务端开启一个端口进行监听
        int port = 8080;
        ServerSocket serverSocket = null;   //服务端
        Socket socket;  //客户端
        InputStream in = null;
        OutputStream out = null;
        try {

            serverSocket = new ServerSocket(port);  //通过构造函数创建ServerSocket，指定监听端口，如果端口合法且空闲，服务器就会监听成功
            // 通过无限循环监听客户端连接，如果没有客户端接入，则会阻塞在accept操作
            while (true) {
                System.out.println("Waiting for a new Socket to establish" + " ," + new Date().toString());
                socket = serverSocket.accept();//阻塞  三次握手
                in = socket.getInputStream();
                byte[] buffer = new byte[1024];
                int length = 0;
                while ((length = in.read(buffer)) > 0) {//阻塞
                    System.out.println("input is:" + new String(buffer, 0, length) + " ," + new Date().toString());
                    out = socket.getOutputStream();
                    out.write("success".getBytes());
                    System.out.println("Server end" + " ," + new Date().toString());
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 必要的清理活动
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

同步非阻塞  
包括Selector，这是多路复用器，selector会不断轮询注册的channel，如果某个channel上发生了读写事件，selector就会将这些channel获取出来，我们通过SelectionKey获取有读写事件的channel，就可以进行IO操作。一个Selector就通过一个线程，就可以轮询成千上万的channel，这就意味着你的服务端可以接入成千上万的客户端。

public class NioDemo implements Runnable {
    public int id = 100001;
    public int bufferSize = 2048;

    @Override
    public void run() {
        init();
    }

    public void init() {
        try {
            // 创建通道和选择器
            ServerSocketChannel socketChannel = ServerSocketChannel.open();
            Selector selector = Selector.open();
            InetSocketAddress inetSocketAddress = new InetSocketAddress(
                    InetAddress.getLocalHost(), 4700);
            socketChannel.socket().bind(inetSocketAddress);
            // 设置通道非阻塞 绑定选择器
            socketChannel.configureBlocking(false);
            socketChannel.register(selector, SelectionKey.OP_ACCEPT).attach(
                    id++);
            System.out.println("Server started .... port:4700");
            listener(selector);

        } catch (Exception e) {

        }
    }

    public void listener(Selector in_selector) {
        try {
            while (true) {
                Thread.sleep(1 * 1000);
                in_selector.select(); // 阻塞 直到有就绪事件为止
                Set<SelectionKey> readySelectionKey = in_selector
                        .selectedKeys();
                Iterator<SelectionKey> it = readySelectionKey.iterator();
                while (it.hasNext()) {
                    SelectionKey selectionKey = it.next();
                    // 判断是哪个事件
                    if (selectionKey.isAcceptable()) {// 客户请求连接
                        System.out.println(selectionKey.attachment()
                                + " - 接受请求事件");
                        // 获取通道 接受连接,
                        // 设置非阻塞模式（必须），同时需要注册 读写数据的事件，这样有消息触发时才能捕获
                        ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectionKey
                                .channel();
                        serverSocketChannel
                                .accept()
                                .configureBlocking(false)
                                .register(
                                        in_selector,
                                        SelectionKey.OP_READ
                                                | SelectionKey.OP_WRITE).attach(id++);
                        System.out
                                .println(selectionKey.attachment() + " - 已连接");

                        // 下面这种写法是有问题的 不应该在serverSocketChannel上面注册
                        /*
                         * serverSocketChannel.configureBlocking(false);
                         * serverSocketChannel.register(in_selector,
                         * SelectionKey.OP_READ);
                         * serverSocketChannel.register(in_selector,
                         * SelectionKey.OP_WRITE);
                         */
                    }
                    if (selectionKey.isReadable()) {// 读数据
                        System.out.println(selectionKey.attachment()
                                + " - 读数据事件");
                        SocketChannel clientChannel = (SocketChannel) selectionKey.channel();
                        ByteBuffer receiveBuf = ByteBuffer.allocate(bufferSize);
                        clientChannel.read(receiveBuf);
                        System.out.println(selectionKey.attachment()
                                + " - 读取数据：" + getString(receiveBuf));
                    }
                    if (selectionKey.isWritable()) {// 写数据
                        System.out.println(selectionKey.attachment()
                                + " - 写数据事件");
                        SocketChannel clientChannel = (SocketChannel) selectionKey.channel();
                        ByteBuffer sendBuf = ByteBuffer.allocate(bufferSize);
                        String sendText = "hello\n";
                        sendBuf.put(sendText.getBytes());
                        sendBuf.flip();        //写完数据后调用此方法
                        clientChannel.write(sendBuf);
                    }
                    if (selectionKey.isConnectable()) {
                        System.out.println(selectionKey.attachment()
                                + " - 连接事件");
                    }
                    // 必须removed 否则会继续存在，下一次循环还会进来,
                    // 注意removed 的位置，针对一个.next() remove一次
                    it.remove();
                }
            }
        } catch (Exception e) {
            System.out.println("Error - " + e.getMessage());
            e.printStackTrace();
        }

    }

    /**
     * ByteBuffer 转换 String
     *
     * @param buffer
     * @return
     */
    public static String getString(ByteBuffer buffer) {
        String string = "";
        try {
            for (int i = 0; i < buffer.position(); i++) {
                string += (char) buffer.get(i);
            }
            return string;
        } catch (Exception ex) {
            ex.printStackTrace();
            return "";
        }
    }
}

异步非阻塞  

每个连接发送过来的请求，都会绑定一个buffer，然后通知操作系统去异步完成读，此时你的程序是会去干别的事儿的，等操作系统完成数据读取之后，就会回调你的接口，给你操作系统异步读完的数据。

public class AIOServer {

    public final static int PORT = 9888;
    private AsynchronousServerSocketChannel server;

    public AIOServer() throws IOException {
        server = AsynchronousServerSocketChannel.open().bind(
                new InetSocketAddress(PORT));
    }

    public void startWithFuture() throws InterruptedException,
            ExecutionException, TimeoutException {
        while (true) {// 循环接收客户端请求
            Future<AsynchronousSocketChannel> future = server.accept();
            AsynchronousSocketChannel socket = future.get();// get() 是为了确保 accept 到一个连接
            handleWithFuture(socket);
        }
    }

    public void handleWithFuture(AsynchronousSocketChannel channel) throws InterruptedException, ExecutionException, TimeoutException {
        ByteBuffer readBuf = ByteBuffer.allocate(2);
        readBuf.clear();

        while (true) {// 一次可能读不完
            //get 是为了确保 read 完成，超时时间可以有效避免DOS攻击，如果客户端一直不发送数据，则进行超时处理
            Integer integer = channel.read(readBuf).get(10, TimeUnit.SECONDS);
            System.out.println("read: " + integer);
            if (integer == -1) {
                break;
            }
            readBuf.flip();
            System.out.println("received: " + Charset.forName("UTF-8").decode(readBuf));
            readBuf.clear();
        }
    }

    public void startWithCompletionHandler() throws InterruptedException,
            ExecutionException, TimeoutException {
        server.accept(null,
                new CompletionHandler<AsynchronousSocketChannel, Object>() {
                    public void completed(AsynchronousSocketChannel result, Object attachment) {
                        server.accept(null, this);// 再此接收客户端连接
                        handleWithCompletionHandler(result);
                    }

                    @Override
                    public void failed(Throwable exc, Object attachment) {
                        exc.printStackTrace();
                    }
                });
    }

    public void handleWithCompletionHandler(final AsynchronousSocketChannel channel) {
        try {
            final ByteBuffer buffer = ByteBuffer.allocate(4);
            final long timeout = 10L;
            channel.read(buffer, timeout, TimeUnit.SECONDS, null, new CompletionHandler<Integer, Object>() {
                @Override
                public void completed(Integer result, Object attachment) {
                    System.out.println("read:" + result);
                    if (result == -1) {
                        try {
                            channel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        return;
                    }
                    buffer.flip();
                    System.out.println("received message:" + Charset.forName("UTF-8").decode(buffer));
                    buffer.clear();
                    channel.read(buffer, timeout, TimeUnit.SECONDS, null, this);
                }

                @Override
                public void failed(Throwable exc, Object attachment) {
                    exc.printStackTrace();
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String args[]) throws Exception {
//        new AIOServer().startWithFuture();
        new AIOServer().startWithCompletionHandler();
        Thread.sleep(100000);
    }

}

把一个磁盘文件映射到内存里来，然后把映射到内存里来的数据通过socket发送出去 。

有一种mmap技术，也就是内存映射，直接将磁盘文件数据映射到内核缓冲区，这个映射的过程是基于DMA引擎拷贝的，同时用户缓冲区是跟内核缓冲区共享一块映射数据的，建立共享映射之后，就不需要从内核缓冲区拷贝到用户缓冲区了。

光是这一点，就可以避免一次拷贝，但是这个过程中还是会用户态切换到内核态去进行映射拷贝，接着再次从内核态切换到用户态， 建立用户缓冲区和内核缓冲区的映射 ，

接着把数据通过Socket发送出去，还是要再次切换到内核态 ，

接着直接把内核缓冲区里的数据拷贝到Socket缓冲区里去，然后再拷贝到网络协议引擎里，发送出去就可以了，最后切换回用户态 。

减少一次拷贝，但是并不减少切换次数，一共是4次切换，3次拷贝

inux提供了sendfile，也就是零拷贝技术

这个零拷贝技术，就是先从用户态切换到内核态，在内核态的状态下，把磁盘上的数据拷贝到内核缓冲区，同时从内核缓冲区拷贝一些 offset和length到Socket缓冲区；接着从内核态切换到用户态，从内核缓冲区直接把数据拷贝到网络协议引擎里去 

同时从Socket缓冲区里拷贝一些offset和length到网络协议引擎里去，但是这个offset和length的量很少，几乎可以忽略 

只要2次切换，2次拷贝

select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。
epoll也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。

select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列）。这也能节省不少的开销。

JVM中类的装载是由类加载器（ClassLoader）和它的子类来实现的，Java中的类加载器是一个重要的Java运行时系统组件，它负责在运行时查找和装入类文件中的类。

由于Java的跨平台性，经过编译的Java源程序并不是一个可执行程序，而是一个或多个类文件。当Java程序需要使用某个类时，JVM会确保这个类已经被加载、连接（验证、准备和解析）和初始化。

类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的Class对象。加载完成后，Class对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备（为静态变量分配内存并设置默认的初始值）和解析（将符号引用替换为直接引用）三个步骤。最后JVM对类进行初始化，包括：
①如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；
②如果类中存在初始化语句，就依次执行这些初始化语句。类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader的子类）。从Java 2（JDK 1.2）开始，类加载过程采取了父亲委托机制（PDM）。PDM更好的保证了Java平台的安全性，在该机制中，JVM自带的Bootstrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。

Perm Space中保存的是加载class文件。

会引起OutOfMemory，出现异常可以设置 -XX:PermSize 的大小。

JDK 1.8后，字符串常量不存放在永久代，而是在堆内存中，JDK1.8以后没有永久代概念，而是用元空间替代，元空间不存在虚拟机中，二是使用本地内存。

大对象直接进入老年态

经过一次Minor GC，年龄+1，若年龄超过一定限制（15），则被晋升到老年态。即长期存活的对象进入老年态

如果没有Survivor，Eden区每进行一次Minor GC，存活的对象就会被送到老年代。老年代很快被填满，触发Major GC.老年代的内存空间远大于新生代，进行一次Full GC消耗的时间比Minor GC长得多,所以需要分为Eden和Survivor。 
Survivor的存在意义，就是减少被送到老年代的对象，进而减少Full GC的发生，Survivor的预筛选保证，只有经历16次Minor GC还能在新生代中存活的对象，才会被送到老年代。 
设置两个Survivor区最大的好处就是解决了碎片化，刚刚新建的对象在Eden中，经历一次Minor GC，Eden中的存活对象就会被移动到第一块survivor space S0，Eden被清空；等Eden区再满了，就再触发一次Minor GC，Eden和S0中的存活对象又会被复制送入第二块survivor space S1（这个过程非常重要，因为这种复制算法保证了S1中来自S0和Eden两部分的存活对象占用连续的内存空间，避免了碎片化的发生）

寄存器：无法控制。

静态域：static定义的静态成员。

常量池：编译时被确定并保存在. class文件中的final常量值和一些文本修饰的符号引用(类和接口的全限定名,字段的名称和描述符,方法和名称和描述符)。

非RAM存储:硬盘等永久存储空间。

堆内存:new创建的对象和数组,由Java虚拟机自动垃圾回收器管理,存取速度慢。

栈内存:基本类型的变量和对象的引用变量(堆内存空间的访问地址),速度快,可以共享,但是大小与生存期必须确定,缺乏灵活性。

方法区：主要是存储类信息，常量池(static量和 static变量)，编译后的代码(字节码)等数据

初始化的对象，成员变量(那种非 static的变量)，所有的对象实例和数组都要在堆上分配

栈：栈的结构是栈帧组成的，调用一个方法就压入一帧，帧上面存储局部变量表，操作数栈，方法出口等信息，局部变量表存放的是8大基础类型加上一个引用类型，所以还是一个指向地址的指针

本地方法栈：主要为 Native方法服务

程序计数器：记录当前线程执行的行号

总结：初始化的对象放在堆里面，引用放在栈里面，class类信息常量池(static常量和 static变量)等放在方法区

JVM内存区域主要分为：

Java 提供的GC 功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，
Java 语言没有提供释放已分配内存的显式操作方法。

在堆中，找到已经无用的对象，并把这些对象占用的空间收回使其可以重新利用。
要请求垃圾收集，可以调用下面的方法之一：

算法思路：把所有的对象组成一个集合，或者可以理解为树状结构，从树根开始找，只要可以找到的都是活动对象，如果找不到就应该被回收了。

内存运行时 JVM 会有一个运行时数据区来管理内存。它主要包括 5 大部分：

而其中程序计数器、虚拟机栈、本地方法栈是每个线程私有的内存空间，随线程而生，随线程而亡。例如栈中每一个栈帧中分配多少内存基本上在类结构确定是哪个时就已知了，因此这 3 个区域的内存分配和回收都是确定的，无需考虑内存回收的问题。
但方法区和堆就不同了，一个接口的多个实现类需要的内存可能不一样，我们只有在程序运行期间才会知道会创建哪些对象，这部分内存的分配和回收都是动态的，GC 主要关注的是这部分内存。

总结：GC 主要进行回收的内存是 JVM 中的方法区和堆

Serial收集器：单线程的收集器，收集垃圾时，必须stop the world，使用复制算法。

ParNew收集器：Serial收集器的多线程版本，也需要stop the world，复制算法。

Parallel Scavenge收集器：新生代收集器，复制算法的收集器，并发的多线程收集器，目标是达到一个可控的吞吐量。如果虚拟机总共运行100分钟，其中垃圾花掉1分钟，吞吐量就是99%。

Serial Old收集器：是Serial收集器的老年代版本，单线程收集器，使用标记整理算法。

Parallel Old收集器：是Parallel Scavenge收集器的老年代版本，使用多线程，标记-整理算法。

CMS(Concurrent Mark Sweep) 收集器：是一种以获得最短回收停顿时间为目标的收集器，标记清除算法，运作过程：初始标记，并发标记，重新标记，并发清除，收集结束会产生大量空间碎片。

G1收集器：标记整理算法实现，运作流程主要包括以下：初始标记，并发标记，最终标记，筛选标记。不会产生空间碎片，可以精确地控制停顿。

CMS收集器是老年代的收集器，可以配合新生代的Serial和ParNew收集器一起使用 ，G1收集器收集范围是老年代和新生代，不需要结合其他收集器使用。

CMS收集器以最小的停顿时间为目标的收集器 ，G1收集器可预测垃圾回收的停顿时间。

CMS收集器是使用“标记-清除”算法进行的垃圾回收，容易产生内存碎片，G1收集器使用的是“标记-整理”算法，进行了空间整合，降低了内存空间碎片。

标记-清除算法

复制算法

标记-整理法

对于堆中的对象，用可达性分析判断一个对象是否还存在引用，如果该对象没有任何引用就应该被回收。根据实际对引用的不同需求，分成了 4 种引用，每种引用的回收机制也是不同的。
对于方法区中的常量和类，当一个常量没有任何对象引用它，它就可以被回收了。
对于类，如果可以判定它为无用类，就可以被回收了。

1. 引用计数法

可达性算法(引用链法)

①代码的可读性和可维护性.Statement 需要不断地拼接，而 PreparedStatement 不会。
②PreparedStatement 尽最大可能提高性能.DB 有缓存机制，相同的预编译语句再次被调用不会再次需要
编译。
③最重要的一点是极大地提高了安全性.Statement 容易被 SQL 注入，而PreparedStatementc 传入的内容不会和 sql 语句发生任何匹配关系。

ResultSet.TYPE_FORWARD_ONLY：这是默认的类型，它的游标只能往下移。

ResultSet.TYPE_SCROLL_INSENSITIVE：游标可以上下移动，一旦它创建后，数据库里的数据再发生修改，对它来说是透明的。

ResultSet.TYPE_SCROLL_SENSITIVE：游标可以上下移动，如果生成后数据库还发生了修改操作，它是能够感知到的。

ResultSet.CONCUR_READ_ONLY：ResultSet是只读的，这是默认类型。

ResultSet.CONCUR_UPDATABLE：我们可以使用的ResultSet的更新方法来更新里面的数据。

缓存PreparedStatement以便更快的执行

可以设置连接超时时间

提供日志记录的功能

ResultSet大小的最大阈值设置

通过JNDI的支持，可以为servlet容器提供连接池的功能

get重点是从服务器上获取资源

get传输数据是通过URL请求，以field（字段） = value的形式，置于URL后，并用“？”连接，多个请求数据间用“&”连接

get传输数据量小，因为受URL长度限制，但是效率高

get是不安全的，因为URL是可见的，可能会泄漏私密信息

get方式只能支持ASCII字符，向服务器传的中文字符可能会乱码

post重点是向服务器发送数据。

post传输数据是通过HTTP的post机制。将字段和对应值封存在请求实体中发送给服务器。这个过程用户是不可见的

post可以传输大量数据，所以上传文件时只能用post

post支持标准字符集，可以正确传递中文字符

post 较get安全性高

200：请求被正常处理

204：请求被受理但没有资源可以返回

206：客户端只是请求资源的一部分，服务器只对请求的部分资源执行GET方法，相应报文中通过Content-Range指定范围的资源。

301：永久性重定向

302：临时重定向

303：与302状态码有相似功能，只是它希望客户端在请求一个URI的时候，能通过GET方法重定向到另一个URI上

304：发送附带条件的请求时，条件不满足时返回，与重定向无关

307：临时重定向，与302类似，只是强制要求使用POST方法

400：请求报文语法有误，服务器无法识别

401：请求需要认证

403：请求的对应资源禁止被访问

404：服务器无法找到对应资源

500：服务器内部错误

503：服务器正忙

转发是服务器行为

重定向是客户端行为

两次请求，浏览器地址发生变化，可以访问自己 web 之外的资源，传输的数据会丢失。

一次强求，浏览器地址不变，访问的是自己本身的 web 资源，传输的数据不会丢失。

a、请求行：包含请求方法、URI、HTTP版本信息
b、请求首部字段
c、请求内容实体

a、状态行：包含HTTP版本、状态码、状态码的原因短语
b、响应首部字段
c、响应内容实体

Date：创建报文时间
Connection：连接的管理
Cache-Control：缓存的控制
Transfer-Encoding：报文主体的传输编码方式

Host：请求资源所在服务器
Accept：可处理的媒体类型
Accept-Charset：可接收的字符集
Accept-Encoding：可接受的内容编码
Accept-Language：可接受的自然语言

Accept-Ranges：可接受的字节范围
Location：令客户端重新定向到的URI
Server：HTTP服务器的安装信息

Allow：资源可支持的HTTP方法
Content-Type：实体主类的类型
Content-Encoding：实体主体适用的编码方式
Content-Language：实体主体的自然语言
Content-Length：实体主体的的字节数
Content-Range：实体主体的位置范围，一般用于发出部分请求时使用

为了准确无误地把数据送达目标处，TCP协议采用了三次握手策略。
用TCP协议把数据包送出去后，TCP不会对传送后的情况置之不理，它一定会向对方确认是否成功送达。握手过程中使用了TCP的标志：SYN和ACK

发送端首先发送一个带SYN标志的数据包给对方。

接收端收到后，回传一个带有SYN/ACK标志的数据包以示传达确认信息。

最后，发送端再回传一个带ACK标志的数据包，代表“握手”结束。

注意：若在握手过程中某个阶段莫名中断，TCP协议会再次以相同的顺序发送相同的数据包

断开一个TCP连接则需要四次挥手

第一次挥手：主动关闭方发送一个FIN，用来关闭主动方到被动关闭方的数据传送，也就是主动关闭方告诉被动关闭方：我已经不会再给你发数据了(当然，在fin包之前发送出去的数据，如果没有收到对应的ack确认报文，主动关闭方依然会重发这些数据)，但是，此时主动关闭方还可以接受数据

第二次挥手：被动关闭方收到FIN包后，发送一个ACK给对方，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号）

第三次挥手：被动关闭方发送一个FIN，用来关闭被动关闭方到主动关闭方的数据传送，也就是告诉主动关闭方，我的数据也发送完了，不会再给你发数据了

第四次挥手：主动关闭方收到FIN后，发送一个ACK给被动关闭方，确认序号为收到序号+1，至此，完成四次挥手

①存在的位置

cookie 存在于客户端，临时文件夹中； 

session存在于服务器的内存中，一个session域对象为一个用户浏览器服务

②安全性

cookie是以明文的方式存放在客户端的，安全性低，可以通过一个加密算法进行加密后存放； 

session存放于服务器的内存中，所以安全性好

③网络传输量

cookie会传递消息给服务器； 

session本身存放于服务器，不会有传送流量

④生命周期(以30分钟为例)

cookie的生命周期是累计的，从创建时，就开始计时，30分钟后，cookie生命周期结束；

session的生命周期是间隔的，从创建时，开始计时如在30分钟，没有访问session，那么session生命周期被销毁。但是，如果在30分钟内（如在第29分钟时）访问过session，那么，将重新计算session的生命周期。关机会造成session生命周期的结束，但是对cookie没有影响。

⑤访问范围

cookie为多个用户浏览器共享； 

session为一个用户浏览器独享

程序调用HttpSession.invalidate()

距离上一次收到客户端发送的session id时间间隔超过了session的最大有效时间

服务器进程被停止

Jsp 本质上就是一个 Servlet，它是 Servlet 的一种特殊形式（由 SUN 公司推出），每个 jsp 页面都是一个 servlet实例。
Servlet 是由 Java 提供用于开发 web 服务器应用程序的一个组件，运行在服务端，由 servlet 容器管理，用来生成动态内容。
一个 servlet 实例是实现了特殊接口 Servlet 的 Java 类，所有自定义的 servlet 均必须实现 Servlet 接口。

jsp 是 html 页面中内嵌的 Java 代码，侧重页面显示；

Servlet 是 html 代码和 Java 代码分离，侧重逻辑控制，mvc 设计思想中 jsp 位于视图层，servlet 位于控制层

JVM 只能识别 Java 类，并不能识别 jsp 代码；
web 容器收到以.jsp 为扩展名的 url 请求时，会将访问请求交给tomcat 中 jsp 引擎处理，每个 jsp 页面第一次被访问时，jsp 引擎将 jsp 代码解释为一个 servlet 源程序，接着编译servlet 源程序生成.class 文件，再由web 容器 servlet 引擎去装载执行 servlet 程序，实现页面交互。

forward是把另一个页面加载到本页面，不改变浏览器的路径 redirect是跳转到另一个页面，会改变浏览器的路径

重定向: response.sendRedirect("重定向的路径")

转发: request.getRequestDispatcher("转发路径").forward(request， response);

依赖于servlet容器；
在实现上基于函数回调，可以对几乎所有请求进行过滤；
缺点是一个过滤器实例只能在容器初始化时调用一次；

用来做一些过滤操作，获取我们想要获取的数据；
在过滤器中修改字符编码；
在过滤器中修改HttpServletRequest的一些参数，包括：过滤低俗文字、危险字符等。

实现了javax.servlet.ServletContextListener 接口的服务器端程序； 随web应用的启动而启动；只初始化一次； 随web应用的停止而销毁；

做一些初始化的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等等。如SpringMVC的监听器org.springframework.web.context.ContextLoaderListener，实现了SpringMVC容器的加载、Bean对象创建、DispatchServlet初始化等。

管理方便，逻辑明确，符合一般人思维习惯。 易于管理，集中式服务器更能保证安全性。 代码一致性非常高。 适合开发人数不多的项目开发。

服务器压力太大，数据库容量暴增。 如果不能连接到服务器上，就不能提交，还原，对比等等。 不适合开源开发。但是一般集中式管理的有非常明确的权限管理机制（例如分支访问限制），可以实现分层管理，从而很好的解决开发人数众多的问题。

适合分布式开发，强调个体。 公共服务器压力和数据量都不会太大。 速度快、灵活。 任意两个开发者之间可以很容易的解决冲突。 离线工作。

代码保密性差，一旦开发者把整个库克隆下来就可以完全公开所有代码和版本信息。

这种合并方式是将两个分支的历史合并到一起，现在的分支不会被更改，它会比对双方不同的文件缓存下来，生成一个commit，去push。

这种合并方法通常被称为“衍合”。他是提交修改历史，比对双方的commit，然后找出不同的去缓存，然后去push，修改commit历史。