黑马程序员面试宝典4.0：Java、Web与电商项目核心技术

PDF文件

下载需积分: 50 | 6.89MB | 更新于2024-07-17 | 139 浏览量 | 举报 1 收藏

立即下载

"面试宝典-v4.0" 是由黑马程序员编写的全面指南，针对IT求职者提供了丰富的面试准备材料。该文档覆盖了多个核心领域的知识，旨在帮助面试者掌握必要的技能和理解，以便在实际的招聘环节中脱颖而出。首先，文档详细介绍了Java编程语言的基础，如Collection和Map的数据结构，深入解析了Java虚拟机（JVM）的工作原理，包括内存区域划分和类加载过程，以及对象的创建机制。对于Web技术，文档涵盖了Spring、Spring MVC和Mybatis等主流JAVAEE框架，让读者了解这些框架在电商项目中的应用和设计模式。在数据库方面，文档讲解了SQL语法，如连接查询、聚合函数、SQL注入防范和存储过程的概念及其优势，还提供了一个具体的MySQL性能优化实例。此外，还介绍了电商项目的开发，包括整体结构图、技术特点、系统功能模块划分、项目架构、表结构和开发工具的选择。 Nginx作为Web服务器的讨论是文档的重点之一，讲述了其高并发处理的优势、与Apache的比较，以及如何利用Nginx进行反向代理以提升网站性能。Httpclient、Jsonp和Redis（缓存数据库）也是重要的知识点，Httpclient的使用、Jsonp的工作原理以及Redis的数据类型、命令和集群架构都得到了详细介绍。文档还针对电商项目中的常见问题，列出了可能被问到的问题类型和解答思路，包括前端的登录、搜索、商品管理、购物车和订单系统，以及后端的Nginx配置、Tomcat对比和Redis的使用技巧。无论是初学者还是经验丰富的开发者，都能从中找到有针对性的准备内容。 "面试宝典-v4.0"是一份全面且实用的面试资源，适合求职者在准备技术面试时深入学习和实践，有助于提升技术能力并增加面试成功的机会。

不论哪种语言的内存分配方式，都需要返回所分配内存的真实地址，也就是返回一个指针到内存块的首地址。

Java 中对象是采用 new 或者反射的方法创建的，这些对象的创建都是在堆（Heap）中分配的，所有对象的回

收都是由 Java 虚拟机通过垃圾回收机制完成的。GC 为了能够正确释放对象，会监控每个对象的运行状况，对

他们的申请、引用、被引用、赋值等状况进行监控，Java 会使用有向图的方法进行管理内存，实时监控对象

是否可以达到，如果不可到达，则就将其回收，这样也可以消除引用循环的问题。在 Java 语言中，判断一个

内存空间是否符合垃圾收集标准有两个：一个是给对象赋予了空值 null，以下再没有调用过，另一个是给对

象赋予了新值，这样重新分配了内存空间。

二、Java 内存泄露引起原因

首先，什么是内存泄露？内存泄露是指无用对象（不再使用的对象）持续占有内存或无用对象的内存得不到及

时释放，从而造成的内存空间的浪费称为内存泄露。内存泄露有时不严重且不易察觉，这样开发者就不知道存

在内存泄露，但有时也会很严重，会提示你 Out of memory。

那么，Java 内存泄露根本原因是什么呢？长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄

露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是

java 中内存泄露的发生场景。具体主要有如下几大类：

1、静态集合类引起内存泄露：

像 HashMap、Vector 等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，他们所引用的

所有的对象 Object 也不能被释放，因为他们也将一直被 Vector 等引用着。

例:

Static Vector v = new Vector(10);

for (int i = 1; i<100; i++)

{

Object o = new Object();

v.add(o);

o = null;

}//

在这个例子中，循环申请 Object 对象，并将所申请的对象放入一个 Vector 中，如果仅仅释放引用本身

（o=null），那么 Vector 仍然引用该对象，所以这个对象对 GC 来说是不可回收的。因此，如果对象加入到

Vector 后，还必须从 Vector 中删除，最简单的方法就是将 Vector 对象设置为 null。

2、当集合里面的对象属性被修改后，再调用 remove（）方法时不起作用。

例：

public static void main(String[] args)

{

Set<Person> set = new HashSet<Person>();

Person p1 = new Person("唐僧","pwd1",25);

Person p2 = new Person("孙悟空","pwd2",26);

Person p3 = new Person("猪八戒","pwd3",27);

set.add(p1);

set.add(p2);

set.add(p3);

System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:3 个元素!

p3.setAge(2); //修改 p3 的年龄,此时 p3 元素对应的 hashcode 值发生改变

set.remove(p3); //此时 remove 不掉，造成内存泄漏

set.add(p3); //重新添加，居然添加成功

System.out.println("总共有:"+set.size()+" 个元素!"); //结果：总共有:4 个元素!

for (Person person : set)

{

System.out.println(person);

}

3、监听器

在 java 编程中，我们都需要和监听器打交道，通常一个应用当中会用到很多监听器，我们会调用一个控件的

诸如 addXXXListener()等方法来增加监听器，但往往在释放对象的时候却没有记住去删除这些监听器，从而

增加了内存泄漏的机会。

4、各种连接

比如数据库连接（dataSourse.getConnection()），网络连接(socket)和 io 连接，除非其显式的调用了其 close

（）方法将其连接关闭，否则是不会自动被 GC 回收的。对于 Resultset 和 Statement 对象可以不进行显式

回收，但 Connection 一定要显式回收，因为 Connection 在任何时候都无法自动回收，而 Connection 一旦回

收，Resultset 和 Statement 对象就会立即为 NULL。但是如果使用连接池，情况就不一样了，除了要显式地

关闭连接，还必须显式地关闭 Resultset Statement 对象（关闭其中一个，另外一个也会关闭），否则就会

造成大量的 Statement 对象无法释放，从而引起内存泄漏。这种情况下一般都会在 try 里面去的连接，在

finally 里面释放连接。

5、内部类和外部模块等的引用

内部类的引用是比较容易遗忘的一种，而且一旦没释放可能导致一系列的后继类对象没有释放。此外程序员还

要小心外部模块不经意的引用，例如程序员 A 负责 A 模块，调用了 B 模块的一个方法如：

public void registerMsg(Object b);

这种调用就要非常小心了，传入了一个对象，很可能模块 B 就保持了对该对象的引用，这时候就需要注意模块

B 是否提供相应的操作去除引用。

6、单例模式

不正确使用单例模式是引起内存泄露的一个常见问题，单例对象在被初始化后将在 JVM 的整个生命周期中存在

（以静态变量的方式），如果单例对象持有外部对象的引用，那么这个外部对象将不能被 jvm 正常回收，导致

内存泄露，考虑下面的例子：

class A{

public A(){

B.getInstance().setA(this);

}

....

}

//B 类采用单例模式

class B{

private A a;

private static B instance=new B();

public B(){}

public static B getInstance(){

return instance;

}

public void setA(A a){

this.a=a;

}

//getter...

}

显然 B 采用 singleton 模式，它持有一个 A 对象的引用，而这个 A 类的对象将不能被回收。想象下如果 A 是个

比较复杂的对象或者集合类型会发生什么情况

Java 中堆和栈的区别

stack 空间小，速度比较快，用来放对象的引用

heep 大，一般所有创建的对象都放在这里。

栈(stack):是一个先进后出的数据结构,通常用于保存方法(函数)中的参数,局部变量.

在 java 中,所有基本类型和引用类型都在栈中存储.栈中数据的生存空间一般在当前 scopes 内(就是由{...}

括起来的区域).

堆(heap):是一个可动态申请的内存空间(其记录空闲内存空间的链表由操作系统维护),C 中的 malloc 语句所

产生的内存空间就在堆中.

在 java 中,所有使用 new xxx()构造出来的对象都在堆中存储,当垃圾回收器检测到某对象未被引用,则自动销

毁该对象.所以,理论上说 java 中对象的生存空间是没有限制的,只要有引用类型指向它,则它就可以在任意地

方被使用.

1. 栈(stack)与堆(heap)都是 Java 用来在 Ram 中存放数据的地方。与 C++不同，Java 自动管理栈和堆，程序

员不能直接地设置栈或堆。

2. 栈的优势是，存取速度比堆要快，仅次于直接位于 CPU 中的寄存器。但缺点是，存在栈中的数据大小与生

存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第 3 点。堆的优势是可以动态地分配内存大小，

生存期也不必事先告诉编译器，Java 的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运

行时动态分配内存，存取速度较慢。

3. Java 中的数据类型有两种。

一种是基本类型(primitive types), 共有 8 种，即 int, short, long, byte, float, double, boolean, char(注

意，并没有 string 的基本类型)。这种类型的定义是通过诸如 int a = 3; long b = 255L;的形式来定义的，

称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存

在。如 int a = 3; 这里的 a 是一个指向 int 类型的引用，指向 3 这个字面值。这些字面值的数据，由于大小

可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度

的原因，就存在于栈中。

另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：

int a = 3;

int b = 3；

编译器先处理 int a = 3；首先它会在栈中创建一个变量为 a 的引用，然后查找有没有字面值为 3 的地址，没

找到，就开辟一个存放 3 这个字面值的地址，然后将 a 指向 3 的地址。接着处理 int b = 3；在创建完 b 的引

用变量后，由于在栈中已经有 3 这个字面值，便将 b 直接指向 3 的地址。

这样，就出现了 a 与 b 同时均指向 3 的情况。特别注意的是，这种字面值的引用与类对象的引用不同。

假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对

象引用变量也即刻反映出这个变化。

相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例，

我们定义完 a 与 b 的值后，再令 a=4；那么，b 不会等于 4，还是等于 3。在编译器内部，遇到 a=4；时，它就

会重新搜索栈中是否有 4 的字面值，如果没有，重新开辟地址存放 4 的值；如果已经有了，则直接将 a 指向这

个地址。因此 a 值的改变不会影响到 b 的值。

基本方法 Stirng

1、获取字符串的长度：length()

2、判断字符串的前缀或后缀与已知字符串是否相同

前缀 startsWith(String s)、后缀 endsWith(String s)

3、比较两个字符串：equals(String s)

4、把字符串转化为相应的数值

int 型 Integer.parseInt(字符串)、long 型 Long.parseLong(字符串)

float 型 Folat.valueOf(字符串).floatValue()

double 型 Double.valueOf(字符串).doubleValue()

5、将数值转化为字符串：valueOf(数值)

6、字符串检索

indexOf(Srting s) 从头开始检索

indexOf(String s ,int startpoint) 从 startpoint 处开始检索

7、得到字符串的子字符串

substring(int startpoint) 从 startpoint 处开始获取

substring(int start,int end) 从 start 到 end 中间的字符

8、替换字符串中的字符,去掉字符串前后空格

replace(char old,char new) 用 new 替换 old

FileInputStream: 接收一个 File 作为流源,用于文件的读取

PipedInputStream: 接收一个 PipedOutputStream,与 PipedOutputStream 配合作为管道使用

StringBufferInputStream: 接收一个 String 作为流的源(已弃用)

3. 链接流处理器

链接流处理器可以接收另一个流处理器(InputStream,包括链接流处理器和原始流处理器)作为源,并对其功能

进行扩展,所以说他们是装饰器.

4) FilterInputStream 继承自 InputStream,是所有装饰器的父类,FilterInputStream 内部也包含一个

InputStream,这个 InputStream 就是被装饰类--一个原始流处理器,它包括如下几个子类:

BufferedInputStream: 用来将数据读入内存缓冲区,并从此缓冲区提供数据

DataInputStream: 提供基于多字节的读取方法,可以读取原始数据类型(Byte, Int, Long, Double 等等)

LineNumberInputStream: 提供具有行计数功能的流处理器

PushbackInputStream: 提供已读取字节"推回"输入流的功能

2) ObjectInputStream: 可以将使用 ObjectOutputStream 写入的基本数据和对象进行反串行化

3) SequenceInputStream: 可以合并多个 InputStream 原始流,依次读取这些合并的原始流

对于 OutputStream, Reader, Writer 的体系结构也跟 InputStream 的结构类似

IO 流中的设计模式

1.IO 中用到的适配器模式

在 IO 中，如将字符串数据转变成字节数据保存到文件中，将字节数据转变成流数据等都用到了适配器模式，

下面以 InputStreamReader 和 OutputStreamWriter 类为例介绍适配器模式。

InputStreamReader 和 OutputStreamWriter 类分别继承了 Reader 和 Writer 接口，但要创建它们必须在构造

函数中传入一个 InputStream 和 OutputStream 的实例，InputStreamReader 和 OutputStreamWriter 的作用也

就是将 InputStream 和 OutputStream 适配到 Reader 和 Writer。

InputStreamReader 实现了 Reader 接口，并且持有了 InputStream 的引用，这是通过 StreamDecoder 类间接持

有的，因为 byte 到 char 要经过编码。

这里，适配器就是 InputStreamReader 类，而源角色就是 InputStream 代表的实例对象，目标接口就是

Reader 类，OutputStreamWriter 类也是类似的方式。

在 IO 中类似的还有，如 StringReader 将一个 String 类适配到 Reader 接口，ByteArrayInputStream 适

配器将 byte 数组适配到 InputStream 流处理接口。

2.IO 中用到的装饰模式

装饰模式就是对一个类进行装饰，增强其方法行为，在装饰模式中，作为原来的这个类使用者还不应该

感受到装饰前与装饰后有什么不同，否则就破坏了原有类的结构了，所以装饰器模式要做到对被装饰类的使用

者透明，这是对装饰器模式的一个要求。总之装饰器设计模式就是对于原有功能的扩展

在 IO 中有许多不同的功能组合情况，这些不同的功能组合都是使用装饰器模式实现的，下面以

FilterInputStream 为例介绍装饰器模式的使用。

InputStream 类就是以抽象组件存在的，而 FileInputStream 就是具体组件，它实现了抽象组件的所有接口，

FilterInputStream 类就是装饰角色，它实现了 InputStream 类的所有接口，并持有 InputStream 的对象实例

的引用，BufferedInputStream 是具体的装饰器实现者，这个装饰器类的作用就是使得 InputStream 读取的数

据保存在内存中，而提高读取的性能。类似的还有 LineNumberInputStream 类，它的作用是提高按行读取数据

的功能。

总结

剩余180页未读，继续阅读

Askrc

粉丝: 2

黑马程序员面试宝典4.0：Java、Web与电商项目核心技术

大数据面试复习总结

黑马JavaEE大数据整套课程（最新）

黑马内部复习面试资料

Java面试宝典：v4.0夜间模式全解析

前端面试宝典V4.0--2022.1.pdf

前端面试宝典V4.0.pdf

v4.0-JavaGuide面试突击版.pdf

上海前端与移动开发面试宝典4.0版1

程序员面试宝典V4.0详解：Java基础与多线程、集合知识点

JavaGuide面试突击版v4.0：职场发展必备宝典

最新资源