办公模板库素材蛙

JAVA面试汇总第二章类和数据结构

克隆和序列化应用 + 面试题

克隆

在开始学习克隆之前，我们先来看看下面的代码，普通的对象复制，存在什么问题？

class CloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
// 等号赋值（基本类型）
int number = 6;
int number2 = number;
// 修改 number2 的值
number2 = 9;
System.out.println(“number：” + number);
System.out.println(“number2：” + number2);
// 等号赋值（对象）
Dog dog = new Dog();
dog.name = “旺财”;
dog.age = 5;
Dog dog2 = dog;
// 修改 dog2 的值
dog2.name = “大黄”;
dog2.age = 3;
System.out.println(dog.name + “，” + dog.age + “岁”);
System.out.println(dog2.name + “，” + dog2.age + “岁”);
}
}

程序执行结果：

number：6
number2：9
大黄，3岁
大黄，3岁

可以看出，如果使用等号复制时，对于值类型来说，彼此之间的修改操作是相对独立的，而对于引用类型来说，因为复制的是引用对象的内存地址，所以修改其中一个值，另一个值也会跟着变化，原理如下图所示：

因此为了防止这种问题的发生，就要使用对象克隆来解决引用类型复制的问题。

1）浅克隆

默认的 clone() 方法，为浅克隆，代码如下：

class CloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
Dog dog = new Dog();
dog.name = “旺财”;
dog.age = 5;
// 克隆
Dog dog3 = (Dog) dog.clone();
dog3.name = “小白”;
dog3.age = 2;
System.out.println(dog.name + “，” + dog.age + “岁”);
System.out.println(dog3.name + “，” + dog3.age + “岁”);
}
}
class Dog implements Cloneable {
public String name;
public int age;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

程序执行结果：

旺财，5岁
小白，2岁

可以看出使用克隆就可以解决引用类型复制的问题了，原理如下图所示：

以上这种复制方式叫做 浅克隆。

浅克隆的实现条件 ：需要克隆的对象必须实现 Cloneable 接口，并重写 clone() 方法，即可实现对此对象的克隆。

然而 使用浅克隆也会存在一个问题 ，请参考以下代码。

class CloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
DogChild dogChild = new DogChild();
dogChild.name = “二狗”;
Dog dog4 = new Dog();
dog4.name = “大黄”;
dog4.dogChild = dogChild;
Dog dog5 = (Dog) dog4.clone();
dog5.name = “旺财”;
dog5.dogChild.name = “狗二”;
System.out.println(“dog name 4：”+dog4.name);
System.out.println(“dog name 5：”+dog5.name);
System.out.println(“dog child name 4：”+dog4.dogChild.name);
System.out.println(“dog child name 5：”+dog5.dogChild.name);
}
}
class Dog implements Cloneable {
public String name;
public DogChild dogChild;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class DogChild {
public String name;
}

程序执行结果：

dog name 4：大黄
dog name 5：旺财
dog child name 4：狗二
dog child name 5：狗二

也就是说浅克隆，只会复制对象的值类型，而不会复制对象的引用类型。原因如下图所示：

要处理引用类型不被复制的问题，就要使用到 深克隆 。

2）深克隆

定义：深克隆就是复制整个对象信息，包含值类型和引用类型。

深克隆的实现方式 通常包含以下两种。

序列化实现深克隆：先将原对象序列化到内存的字节流中，再从字节流中反序列化出刚刚存储的对象，这个新对象和原对象就不存在任何地址上的共享，这样就实现了深克隆。
所有引用类型都实现克隆：要复制对象的所有引用类型都要实现克隆，所有对象都是复制的新对象，从而实现了深克隆。

深克隆实现方式一：序列化

实现思路：先将要拷贝对象写入到内存中的字节流中，然后再从这个字节流中读出刚刚存储的信息，作为一个新对象返回，那么这个新对象和原对象就不存在任何地址上的共享，自然实现了深拷贝。请参考以下代码：

class CloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
BirdChild birdChild = new BirdChild();
birdChild.name = “小小鸟”;
Bird bird = new Bird();
bird.name = “小鸟”;
bird.birdChild = birdChild;
// 使用序列化克隆对象
Bird bird2 = CloneUtils.clone(bird);
bird2.name = “黄雀”;
bird2.birdChild.name = “小黄雀”;
System.out.println(“bird name:” + bird.name);
System.out.println(“bird child name:” + bird.birdChild.name);
System.out.println(“bird name 2:” + bird2.name);
System.out.println(“bird child name 2:” + bird2.birdChild.name);
}
}
class CloneUtils {
public static T clone(T obj) {
T cloneObj = null;
try {
//写入字节流
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bo);
oos.writeObject(obj);
oos.close();
//分配内存,写入原始对象,生成新对象
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());//获取上面的输出字节流
ObjectInputStream oi = new ObjectInputStream(bi);
//返回生成的新对象
cloneObj = (T) oi.readObject();
oi.close();
} catch (Exception e) {
e.printStackTrace();
}
return cloneObj;
}
}

程序执行结果：

bird name:小鸟
bird child name:小小鸟
bird name 2:黄雀
bird child name 2:小黄雀

深克隆实现方式二：所有引用类型都实现克隆

class SerializableTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ParrotChild parrotChild = new ParrotChild();
parrotChild.name = “小鹦鹉”;
Parrot parrot = new Parrot();
parrot.name = “大鹦鹉”;
parrot.parrotChild = parrotChild;
// 克隆
Parrot parrot2 = (Parrot) parrot.clone();
parrot2.name = “老鹦鹉”;
parrot2.parrotChild.name = “少鹦鹉”;
System.out.println(“parrot name:” + parrot.name);
System.out.println(“parrot child name:” + parrot.parrotChild.name);
System.out.println(“parrot name 2:” + parrot2.name);
System.out.println(“parrot child name 2:” + parrot2.parrotChild.name);
}
}
class Parrot implements Cloneable {
public String name;
public ParrotChild parrotChild;
@Override
protected Object clone() throws CloneNotSupportedException {
Parrot bird = (Parrot) super.clone();
bird.parrotChild = (ParrotChild) parrotChild.clone();
return bird;
}
}
class ParrotChild implements Cloneable {
public String name;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

程序执行结果：

parrot name:大鹦鹉
parrot child name:小鹦鹉
parrot name 2:老鹦鹉
parrot child name 2:少鹦鹉

序列化和反序列化

1）介绍

内存中的数据对象只有转换成二进制流才能进行数据持久化或者网络传输，将对象转换成二进制流的过程叫做序列化（Serialization）；相反，把二进制流恢复为数据对象的过程就称之为反序列化（Deserialization）。

2）序列化和反序列代码实现

先把对象序列化到磁盘，再从磁盘中反序列化出对象，请参考以下代码：

class SerializableTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 对象赋值
User user = new User();
user.setName(“老王”);
user.setAge(30);
System.out.println(user);
// 创建输出流（序列化内容到磁盘）
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“test.out”));
// 序列化对象
oos.writeObject(user);
oos.flush();
oos.close();
// 创建输入流（从磁盘反序列化）
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“test.out”));
// 反序列化
User user2 = (User) ois.readObject();
ois.close();
System.out.println(user2);
}
}
class User implements Serializable {
private static final long serialVersionUID = 3831264392873197003L;
private String name;
private int age;
@Override
public String toString() {
return “{name:” + name + “,age:” + age + “}”;
}
// setter/getter…
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

程序执行结果：

{name:老王,age:30}
{name:老王,age:30}

更多序列化和反序列化的实现方式以及代码示例，请看下文面试部分的内容。

开发工具设置 ：IDEA 开启自动生成 serialVersionUID
点击 Settings → Inspections → 搜索 Serialization issues → 勾选 Serializable class
without ‘SerialVersionUID’ 保存设置，如下图所示：

设置完之后，光标放到类名上，点击提示，生成 serialVersionUID，如下图所示：

总结

序列化常见的使用场景是远程服务调用（RPC）和网络对象传输等，可通过 implements Serializable
来实现对象序列化，在序列化对象中通过定义 serialVersionUID 来防止执行不兼容的类更改。调用 Object 类中的 clone()
方法默认是浅克隆，浅克隆只能复制值类型，不能复制引用类型，因此更多的时候我们需要深克隆，深克隆通常的实现方式有两种：序列化和所有引用类型都实现克隆。

集合详解之 Collection + 面试题

先来看看集合的继承关系图，如下图所示：

其中：

外框为虚线的表示接口，边框为实线的表示类；
箭头为虚线的表示实现了接口，箭头为实线的表示继承了类。

为了方便理解，我隐藏了一些与本文内容无关的信息，隐藏的这些内容会在后面的章节中进行详细地介绍。

从图中可以看出，集合的根节点是 Collection，而 Collection 下又提供了两大常用集合，分别是：

List：使用最多的有序集合，提供方便的新增、修改、删除的操作；
Set：集合不允许有重复的元素，在许多需要保证元素唯一性的场景中使用。

下面我们分别对集合类进行详细地介绍。

集合使用

1）Vector

Vector 是 Java 早期提供的线程安全的有序集合，如果不需要线程安全，不建议使用此集合，毕竟同步是有线程开销的。

使用示例代码：

Vector vector = new Vector();
vector.add("dog");
vector.add("cat");
vector.remove("cat");
System.out.println(vector);

程序执行结果：[dog]

2）ArrayList

ArrayList
是最常见的非线程安全的有序集合，因为内部是数组存储的，所以随机访问效率很高，但非尾部的插入和删除性能较低，如果在中间插入元素，之后的所有元素都要后移。ArrayList
的使用与 Vector 类似。

3）LinkedList

LinkedList 是使用双向链表数据结构实现的，因此增加和删除效率比较高，而随机访问效率较差。

LinkedList 除了包含以上两个类的操作方法之外，还新增了几个操作方法，如 offer() 、peek() 等，具体详情，请参考以下代码：

LinkedList linkedList = new LinkedList();
// 添加元素
linkedList.offer("bird");
linkedList.push("cat");
linkedList.push("dog");
// 获取第一个元素
System.out.println(linkedList.peek());
// 获取第一个元素，并删除此元素
System.out.println(linkedList.poll());
System.out.println(linkedList);

程序的执行结果：

dog
dog
[cat, bird]

4）HashSet

HashSet 是一个没有重复元素的集合。虽然它是 Set 集合的子类，实际却为 HashMap 的实例，相关源码如下：

public HashSet() {
    map = new HashMap<>();
}

因此 HashSet 是无序集合，没有办法保证元素的顺序性。

HashSet 默认容量为 16，每次扩充 0.75 倍，相关源码如下：

public HashSet(Collection c) {
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}

HashSet 的使用与 Vector 类似。

5）TreeSet

TreeSet 集合实现了自动排序，也就是说 TreeSet 会把你插入数据进行自动排序。

示例代码如下：

TreeSet treeSet = new TreeSet();
treeSet.add("dog");
treeSet.add("camel");
treeSet.add("cat");
treeSet.add("ant");
System.out.println(treeSet);

程序执行结果：[ant, camel, cat, dog]

可以看出，TreeSet 的使用与 Vector 类似，只是实现了自动排序。

6）LinkedHashSet

LinkedHashSet 是按照元素的 hashCode
值来决定元素的存储位置，但同时又使用链表来维护元素的次序，这样使得它看起来像是按照插入顺序保存的。

LinkedHashSet 的使用与 Vector 类似。

集合与数组

集合和数组的转换可使用 toArray() 和 Arrays.asList() 来实现，请参考以下代码示例：

List list = new ArrayList();
list.add("cat");
list.add("dog");
// 集合转数组
String[] arr = list.toArray(new String[list.size()]);
// 数组转集合
List list2 = Arrays.asList(arr);

集合与数组的区别，可以参考「数组和排序算法的应用 +
面试题」的内容。

集合排序

在 Java 语言中排序提供了两种方式：Comparable 和 Comparator，它们的区别也是常见的面试题之一。下面我们彻底地来了解一下
Comparable 和 Comparator 的使用与区别。

1）Comparable

Comparable 位于 java.lang 包下，是一个排序接口，也就是说如果一个类实现了 Comparable 接口，就意味着该类有了排序功能。

Comparable 接口只包含了一个函数，定义如下：

package java.lang;
import java.util.*;
public interface Comparable {
  public int compareTo(T o);
}

Comparable 使用示例 ，请参考以下代码：

class ComparableTest {
    public static void main(String[] args) {
        Dog[] dogs = new Dog[]{
                new Dog("老旺财", 10),
                new Dog("小旺财", 3),
                new Dog("二旺财", 5),
        };
        // Comparable 排序
        Arrays.sort(dogs);
        for (Dog d : dogs) {
            System.out.println(d.getName() + "：" + d.getAge());
        }
    }
}
class Dog implements Comparable {
    private String name;
    private int age;
    @Override
    public int compareTo(Dog o) {
        return age - o.age;
    }
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

程序执行结果：

小旺财：3
二旺财：5
老旺财：10

如果 Dog 类未实现 Comparable 执行代码会报程序异常的信息，错误信息为：

Exception in thread “main” java.lang.ClassCastException: xxx cannot be cast
to java.lang.Comparable

compareTo() 返回值有三种：

e1.compareTo(e2) > 0 即 e1 > e2；
e1.compareTo(e2) = 0 即 e1 = e2；
e1.compareTo(e2) < 0 即 e1 < e2。

2）Comparator

Comparator 是一个外部比较器，位于 java.util 包下，之所以说 Comparator 是一个外部比较器，是因为它无需在比较类中实现
Comparator 接口，而是要新创建一个比较器类来进行比较和排序。

Comparator 接口包含的主要方法为 compare()，定义如下：

public interface Comparator {
  int compare(T o1, T o2);
}

Comparator 使用示例 ，请参考以下代码：

class ComparatorTest {
    public static void main(String[] args) {
        Dog[] dogs = new Dog[]{
                new Dog("老旺财", 10),
                new Dog("小旺财", 3),
                new Dog("二旺财", 5),
        };
        // Comparator 排序
        Arrays.sort(dogs,new DogComparator());
        for (Dog d : dogs) {
            System.out.println(d.getName() + "：" + d.getAge());
        }
    }
}
class DogComparator implements Comparator {
    @Override
    public int compare(Dog o1, Dog o2) {
        return o1.getAge() - o2.getAge();
    }
}
class Dog {
    private String name;
    private int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

程序执行结果：

小旺财：3
二旺财：5
老旺财：10

总结

本文介绍的集合都实现自 Collection，因此它们都有同样的操作方法，如 add()、addAll()、remove() 等，Collection
接口的方法列表如下图：

当然部分集合也在原有方法上扩充了自己特有的方法，如 LinkedList 的 offer()、push()
等方法。本文也提供了数组和集合互转方法，List.toArray() 把集合转换为数组，Arrays.asList(array)
把数组转换为集合。最后介绍了 Comparable 和 Comparator 的使用和区别，Comparable 和 Comparator 是 Java
语言排序提供的两种排序方式，Comparable 位于 java.lang 包下，如果一个类实现了 Comparable 接口，就意味着该类有了排序功能；而
Comparator 位于 java.util 包下，是一个外部比较器，它无需在比较类中实现 Comparator
接口，而是要新创建一个比较器类来进行比较和排序。

集合详解之 Map + 面试题

集合有两个大接口：Collection 和 Map，本文重点来讲解集合中另一个常用的集合类型 Map。

以下是 Map 的继承关系图：

Map 简介

Map 常用的实现类如下：

Hashtable ：Java 早期提供的一个哈希表实现，它是线程安全的，不支持 null 键和值，因为它的性能不如 ConcurrentHashMap，所以很少被推荐使用。
HashMap ：最常用的哈希表实现，如果程序中没有多线程的需求，HashMap 是一个很好的选择，支持 null 键和值，如果在多线程中可用 ConcurrentHashMap 替代。
TreeMap ：基于红黑树的一种提供顺序访问的 Map，自身实现了 key 的自然排序，也可以指定 Comparator 来自定义排序。
LinkedHashMap ：HashMap 的一个子类，保存了记录的插入顺序，可在遍历时保持与插入一样的顺序。

Map 常用方法

常用方法包括：put、remove、get、size 等，所有方法如下图：

使用示例，请参考以下代码：

Map hashMap = new HashMap();
// 增加元素
hashMap.put("name", "老王");
hashMap.put("age", "30");
hashMap.put("sex", "你猜");
// 删除元素
hashMap.remove("age");
// 查找单个元素
System.out.println(hashMap.get("age"));
// 循环所有的 key
for (Object k : hashMap.keySet()) {
    System.out.println(k);
}
// 循环所有的值
for (Object v : hashMap.values()) {
    System.out.println(v);
}

以上为 HashMap 的使用示例，其他类的使用也是类似。

HashMap 数据结构

HashMap 底层的数据是数组被成为哈希桶，每个桶存放的是链表，链表中的每个节点，就是 HashMap 中的每个元素。在 JDK 8 当链表长度大于等于
8 时，就会转成红黑树的数据结构，以提升查询和插入的效率。

HashMap 数据结构，如下图：

HashMap 重要方法

1）添加方法：put(Object key, Object value)

执行流程如下：

对 key 进行 hash 操作，计算存储 index；
判断是否有哈希碰撞，如果没碰撞直接放到哈希桶里，如果有碰撞则以链表的形式存储；
判断已有元素的类型，决定是追加树还是追加链表，当链表大于等于 8 时，把链表转换成红黑树；
如果节点已经存在就替换旧值；
判断是否超过阀值，如果超过就要扩容。

源码及说明：

public V put(K key, V value) {
    // 对 key 进行 hash()
    return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
    int h;
  // 对 key 进行 hash() 的具体实现
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node[] tab; Node p; int n, i;
    // tab为空则创建
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 计算 index，并对 null 做处理
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node e; K k;
        // 节点存在
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 该链为树
        else if (p instanceof TreeNode)
            e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
        // 该链为链表
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 写入
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 超过load factor*current capacity，resize
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

put() 执行流程图如下：

2）获取方法：get(Object key)

执行流程如下：

首先比对首节点，如果首节点的 hash 值和 key 的 hash 值相同，并且首节点的键对象和 key 相同（地址相同或 equals 相等），则返回该节点；
如果首节点比对不相同、那么看看是否存在下一个节点，如果存在的话，可以继续比对，如果不存在就意味着 key 没有匹配的键值对。

源码及说明：

public V get(Object key) {
  Node e;
  return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* 该方法是 Map.get 方法的具体实现
* 接收两个参数
* @param hash key 的 hash 值，根据 hash 值在节点数组中寻址，该 hash 值是通过 hash(key) 得到的
* @param key key 对象，当存在 hash 碰撞时，要逐个比对是否相等
* @return 查找到则返回键值对节点对象，否则返回 null
*/
final Node getNode(int hash, Object key) {
    Node[] tab; Node first, e; int n; K k; // 声明节点数组对象、链表的第一个节点对象、循环遍历时的当前节点对象、数组长度、节点的键对象
    // 节点数组赋值、数组长度赋值、通过位运算得到求模结果确定链表的首节点
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // 首先比对首节点，如果首节点的 hash 值和 key 的 hash 值相同，并且首节点的键对象和 key 相同（地址相同或 equals 相等），则返回该节点
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first; // 返回首节点

        // 如果首节点比对不相同、那么看看是否存在下一个节点，如果存在的话，可以继续比对，如果不存在就意味着 key 没有匹配的键值对    
        if ((e = first.next) != null) {
            // 如果存在下一个节点 e，那么先看看这个首节点是否是个树节点
            if (first instanceof TreeNode)
                // 如果是首节点是树节点，那么遍历树来查找
                return ((TreeNode)first).getTreeNode(hash, key); 

            // 如果首节点不是树节点，就说明还是个普通的链表，那么逐个遍历比对即可    
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k)))) // 比对时还是先看 hash 值是否相同、再看地址或 equals
                    return e; // 如果当前节点e的键对象和key相同，那么返回 e
            } while ((e = e.next) != null); // 看看是否还有下一个节点，如果有，继续下一轮比对，否则跳出循环
        }
    }
    return null; // 在比对完了应该比对的树节点 或者全部的链表节点 都没能匹配到 key，那么就返回 null

总结

通过本文可以了解到：

Map 的常用实现类 Hashtable 是 Java 早期的线程安全的哈希表实现；
HashMap 是最常用的哈希表实现，但它是非线程安全的，可使用 ConcurrentHashMap 替代；
TreeMap 是基于红黑树的一种提供顺序访问的哈希表实现；
LinkedHashMap 是 HashMap 的一个子类，保存了记录的插入顺序，可在遍历时保持与插入一样的顺序。

HashMap 在 JDK 7 可能在扩容时会导致链表的循环引用而造成 CPU 100%，HashMap 在 JDK 8 时数据结构变更为：数组 + 链表

红黑树的存储方式，在没有冲突的情况下直接存放数组，有冲突，当链表长度小于 8 时，存放在单链表结构中，当链表长度大于 8
时，树化并存放至红黑树的数据结构中。

为什么要使用泛型和迭代器 + 面试题

泛型

1）为什么要用泛型？

在泛型没有诞生之前，我们经常会遇到这样的问题，如以下代码所示：

ArrayList arrayList = new ArrayList();
arrayList.add("Java");
arrayList.add(24);
for (int i = 0; i < arrayList.size(); i++) {
    String str = (String) arrayList.get(i);
    System.out.println(str);
}

看起来好像没有什么大问题，也能正常编译，但真正运行起来就会报错：

Exception in thread “main” java.lang.ClassCastException: java.lang.Integer
cannot be cast to java.lang.String

at xxx(xxx.java:12)

类型转换出错，当我们给 ArrayList
放入不同类型的数据，却使用一种类型进行接收的时候，就会出现很多类似的错误，可能更多的时候，是因为开发人员的不小心导致的。那有没有好的办法可以杜绝此类问题的发生呢？这个时候
Java 语言提供了一个很好的解决方案——“泛型”。

2）泛型介绍

泛型：泛型本质上是类型参数化，解决了不确定对象的类型问题。
泛型的使用，请参考以下代码：

ArrayList arrayList = new ArrayList();
arrayList.add("Java");

这个时候如果给 arrayList 添加非 String 类型的元素，编译器就会报错，提醒开发人员插入相同类型的元素。

报错信息如下图所示：

这样就可以避免开头示例中，类型不一致导致程序运行过程中报错的问题了。

3）泛型的优点

泛型的优点主要体现在以下三个方面。

安全：不用担心程序运行过程中出现类型转换的错误。
避免了类型转换：如果是非泛型，获取到的元素是 Object 类型的，需要强制类型转换。
可读性高：编码阶段就明确的知道集合中元素的类型。

迭代器（Iterator）

1）为什么要用迭代器？

我们回想一下，在迭代器（Iterator）没有出现之前，如果要遍历数组和集合，需要使用方法。

数组遍历，代码如下：

String[] arr = new String[]{"Java", "Java虚拟机", "Java中文社群"};
for (int i = 0; i < arr.length; i++) {
    String item = arr[i];
}

集合遍历，代码如下：

List list = new ArrayList() {{
    add("Java");
    add("Java虚拟机");
    add("Java中文社群");
}};
for (int i = 0; i < list.size(); i++) {
    String item = list.get(i);
}

而迭代器的产生，就是为不同类型的容器遍历，提供标准统一的方法。

迭代器遍历，代码如下：

Iterator iterator = list.iterator();
while (iterator.hasNext()) {
    Object object = iterator.next();
    // do something
}

总结：使用了迭代器就可以不用关注容器的内部细节，用同样的方式遍历不同类型的容器。

2）迭代器介绍

迭代器是用来遍历容器内所有元素对象的，也是一种常见的设计模式。

迭代器包含以下四个方法。

hasNext():boolean —— 容器内是否还有可以访问的元素。
next():E —— 返回下一个元素。
remove():void —— 删除当前元素。
forEachRemaining(Consumer super E>):void —— JDK 8 中添加的，提供一个 lambda 表达式遍历容器元素。

迭代器使用如下：

List list = new ArrayList() {{
    add("Java");
    add("Java虚拟机");
    add("Java中文社群");
}};
Iterator iterator =  list.iterator();
// 遍历
while (iterator.hasNext()){
    String str = (String) iterator.next();
    if (str.equals("Java中文社群")){
        iterator.remove();
    }
}
System.out.println(list);

程序执行结果：

[Java, Java虚拟机]

forEachRemaining 使用如下：

List list = new ArrayList() {{
    add("Java");
    add("Java虚拟机");
    add("Java中文社群");
}};
// forEachRemaining 使用
list.iterator().forEachRemaining(item -> System.out.println(item));

组合方式	性能分析
同步阻塞	最常用的一种用法，使用也是最简单的，但是 I/O 性能一般很差，CPU 大部分在空闲状态
同步非阻塞	提升 I/O 性能的常用手段，就是将 I/O 的阻塞改成非阻塞方式，尤其在网络 I/O
是长连接，同时传输数据也不是很多的情况下，提升性能非常有效。这种方式通常能提升 I/O 性能，但是会增加 CPU 消耗，要考虑增加的 I/O
性能能不能补偿 CPU 的消耗，也就是系统的瓶颈是在 I/O 还是在 CPU 上
异步阻塞
这种方式在分布式数据库中经常用到。例如，在往一个分布式数据库中写一条记录，通常会有一份是同步阻塞的记录，而还有两至三份是备份记录会写到其他机器上，这些备份记录通常都是采用异步阻塞的方式写
I/O；异步阻塞对网络 I/O 能够提升效率，尤其像上面这种同时写多份相同数据的情况
异步非阻塞	这种组合方式用起来比较复杂，只有在一些非常复杂的分布式情况下使用，像集群之间的消息同步机制一般用这种 I/O
组合方式。例如，Cassandra 的 Gossip
通信机制就是采用异步非阻塞的方式。它适合同时要传多份相同的数据到集群中不同的机器，同时数据的传输量虽然不大，但是却非常频繁。这种网络 I/O
用这个方式性能能达到最高

JAVA面试汇总第二章 类和数据结构

克隆和序列化应用 + 面试题

克隆

1）浅克隆

2）深克隆

序列化和反序列化

1）介绍

2）序列化和反序列代码实现

相关面试题

1.serialVersionUID 的作用是什么？

2.可序列化接口（Serializalbe）的用途是什么？

3.常用的序列化方式都有哪些？

4.使用克隆有什么好处？

5.浅克隆和深克隆有什么区别？

6.如何实现浅克隆？

7.以下代码执行的结果是？

8.深克隆如何实现？有几种实现方式？

9.为什么不能直接使用 Object 的 Clone 方法，还要重写 clone() 方法之后才能实现克隆？

10.序列化可不可以实现深克隆？实现的原理是什么？

11.序列化时某些成员不需要序列化，如何实现？

12.是否可以自定义序列化过程，覆盖 Java 中的默认序列化过程？

13.在 Java 中的序列化和反序列化过程中使用了哪些方法？

总结

集合详解之 Collection + 面试题

集合使用

1）Vector

2）ArrayList

3）LinkedList

4）HashSet

5）TreeSet

6）LinkedHashSet

集合与数组

集合排序

1）Comparable

2）Comparator

相关面试题

1.List 和 Set 有什么区别？

2.哪种集合可以实现自动排序？

3.Vector 和 ArrayList 初始化大小和容量扩充有什么区别？

4.Vector、ArrayList、LinkedList 有什么区别？

5.Vector、ArrayList、LinkedList 使用场景有什么区别？

6.Collection 和 Collections 有什么区别？

7.以下选项没有继承 Collection 接口的是？

8.LinkedHashSet 如何保证有序和唯一性？

9.HashSet 是如何保证数据不可重复的？

10.执行以下程序会输出什么结果？为什么？

11.如何用程序实现后进先出的栈结构？

12.LinkedList 中的 peek() 和 poll() 有什么区别？

13.Comparable 和 Comparator 有哪些区别？

总结

集合详解之 Map + 面试题

Map 简介

Map 常用方法

HashMap 数据结构

HashMap 重要方法

1）添加方法：put(Object key, Object value)

2）获取方法：get(Object key)

相关面试题

1.Map 常见实现类有哪些？

2.使用 HashMap 可能会遇到什么问题？如何避免？

3.以下说法正确的是？

4.TreeMap 怎么实现根据 value 值倒序？

5.以下哪个 Set 实现了自动排序？

6.以下程序运行的结果是什么？

7.HashMap 有哪些重要的参数？用途分别是什么？

8.HashMap 和 Hashtable 有什么区别？

9.什么是哈希冲突？

10.有哪些方法可以解决哈希冲突？

11.HashMap 使用哪种方法来解决哈希冲突（哈希碰撞）？

12.HashMap 的扩容为什么是 2^n ？

13.有哈希冲突的情况下 HashMap 如何取值？

14.以下程序会输出什么结果？

15.为什么重写 equals() 时一定要重写 hashCode()？

16.HashMap 在 JDK 7 多线程中使用会导致什么问题？

17.HashMap 在 JDK 7 和 JDK 8 中有哪些不同？

总结

为什么要使用泛型和迭代器 + 面试题

泛型

1）为什么要用泛型？

2）泛型介绍

JAVA面试汇总第二章类和数据结构