Iterator

Iterator是Java集合框架中的一个接口，用于遍历集合中的元素。它提供了一种统一的方式来访问集合中的元素，而不暴露底层数据结构的实现细节。

通过Iterator接口，我们可以依次访问集合中的每个元素，并在遍历过程中进行一些操作，比如删除元素。Iterator接口定义了以下常用方法：

boolean hasNext()：判断集合中是否还有下一个元素。
E next()：返回集合中的下一个元素。
void remove()：从集合中删除当前元素（可选操作）。

使用Iterator接口可以实现对各种集合类（如List、Set、Map等）的遍历，无需关心底层数据结构的具体实现。例如，可以通过以下方式使用Iterator遍历一个List集合：

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

上述代码中，通过list.iterator()方法获取到一个Iterator对象，然后使用while循环遍历集合中的元素。iterator.hasNext()方法用于判断是否还有下一个元素，iterator.next()方法用于返回下一个元素。通过使用Iterator，我们可以在遍历集合时安全地删除元素，而不会导致并发修改异常。调用iterator.remove()方法可以删除当前元素。需要注意的是，一旦使用Iterator开始遍历集合，就不能在遍历过程中修改集合的结构（添加、删除元素），否则会抛出ConcurrentModificationException异常。总而言之，Iterator提供了一种统一且安全的方式来遍历集合中的元素，并支持元素的删除操作。它是Java集合框架中常用的接口之一，用于提供集合的迭代功能。

equals和==的区别

在Java中，equals() 和 == 是用于比较对象的两个不同的方法。

equals() 方法用于比较对象的内容（属性值），而不是比较对象的引用地址。通常情况下，我们需要重写 equals() 方法来定义对象之间的相等性逻辑。默认情况下，equals() 方法与 == 操作符的行为相同，即比较对象的引用地址。
== 操作符用于比较对象的引用地址，即判断两个对象是否指向同一块内存地址。当使用 == 操作符比较基本数据类型时，比较的是它们的值；而比较引用类型时，比较的是对象的引用地址。

下面是它们的区别总结：

equals() 方法用于比较对象的内容（属性值）是否相等，需要重写以定义自定义的相等性逻辑。
== 操作符用于比较对象的引用地址是否相等，即判断两个对象是否指向同一块内存地址。示例：

String str1 = new String("Hello");
String str2 = new String("Hello");

System.out.println(str1.equals(str2));  // true，比较的是内容
System.out.println(str1 == str2);       // false，比较的是引用地址

需要注意的是，在某些情况下，equals() 方法和 == 操作符的行为可能相同，比如比较基本数据类型的值和比较对象引用时，但在大多数情况下，它们的行为是不同的。

equals,compareTo,hashCode

equals, compareTo, 和 hashCode 是Java中用于对象比较和哈希计算的重要方法。

equals() 方法：
- 用于比较两个对象是否相等。
- 定义在Object类中，子类可以重写该方法来实现自定义的相等逻辑。
- 通常需要重写 equals() 方法以满足业务需求，比如比较对象的属性值是否相等。
- equals() 方法的常规约定是满足自反性、对称性、传递性和一致性。
- 重写 equals() 方法时通常还需要重写 hashCode() 方法以保证一致性。
compareTo() 方法：
- 用于比较两个对象的大小关系。
- 定义在 Comparable 接口中，要求实现类必须实现该方法以支持对象的比较。
- compareTo() 方法的返回值为整数，表示两个对象的大小关系。返回值为负数表示当前对象小于被比较对象，返回值为正数表示当前对象大于被比较对象，返回值为0表示两个对象相等。
- 通过实现 Comparable 接口并重写 compareTo() 方法，可以对自定义类的对象进行排序操作。
hashCode() 方法：
- 用于计算对象的哈希码。
- 定义在 Object 类中，子类可以重写该方法来实现自定义的哈希计算逻辑。
- 哈希码用于支持哈希表等数据结构的高效存储和查找。
- 重写 equals() 方法时通常需要同时重写 hashCode() 方法，以保证相等的对象具有相同的哈希码。
- hashCode() 方法的常规约定是相等的对象必须具有相同的哈希码，但相同哈希码的对象不一定相等。

这些方法在Java中常常用于对象的比较、排序和哈希计算。通过正确实现和使用这些方法，可以确保对象在集合操作和算法中的正确行为和预期结果。

什么是fail-fast,什么是fail-safe

Fail-fast 和 fail-safe 是两种不同的策略用于处理集合（Collection）在遍历过程中发生修改的情况。

Fail-Fast（快速失败）： Fail-fast 是一种机制，它在遍历集合时检测到集合被修改（添加、删除元素）后立即抛出 ConcurrentModificationException 异常，以防止在不一致的状态下继续遍历。这个机制可以及早地发现并解决并发修改的问题，避免了潜在的错误和数据不一致。

常见的使用 fail-fast 策略的集合类包括 ArrayList、HashMap、HashSet 等。它们在遍历时使用迭代器（Iterator）来检测并发修改。如果在遍历过程中通过集合自身的方法修改了集合的结构（增删元素），则会触发快速失败，抛出异常。

Fail-Safe（安全失败）： Fail-safe 是一种机制，它在遍历集合时不会抛出 ConcurrentModificationException 异常，即使集合在遍历过程中被修改。相反，它会创建迭代器的一个副本或者使用一份快照（snapshot）来遍历集合，而不是直接在原集合上进行操作。这样可以避免并发修改带来的问题，但可能会导致迭代器遍历的结果不一定完全准确。

常见的使用 fail-safe 策略的集合类包括 ConcurrentHashMap 和 CopyOnWriteArrayList 等。它们采用一些特殊的数据结构和算法来保证在遍历时不会抛出异常，或者在修改集合时创建副本，以确保遍历过程的安全性。

总结：

Fail-fast 是一种在遍历过程中检测到并发修改的机制，立即抛出异常，保证数据的一致性和正确性。
Fail-safe 是一种在遍历过程中不会抛出异常的机制，通过副本或快照来遍历集合，保证遍历的安全性，但可能导致迭代结果不一定准确。
使用哪种策略取决于具体的需求和场景。如果要求数据一致性和避免潜在的错误，可以选择 fail-fast 策略；如果更关注遍历的安全性和不希望抛出异常，可以选择 fail-safe 策略。

fail-fast，fail-safe的使用场景有什么不同

Fail-fast 和 fail-safe 的使用场景有所区别：

Fail-Fast（快速失败）适用场景：

当多个线程并发修改同一个集合时，通过快速失败机制可以及早地发现并解决并发修改的问题，避免潜在的错误和数据不一致。
快速失败机制适用于对集合的修改操作比较频繁，而对遍历操作的实时性要求不高的情况。

Fail-Safe（安全失败）适用场景：

当多个线程并发修改同一个集合，但不希望遍历操作受到修改的影响时，可以选择使用安全失败机制。
安全失败机制适用于对集合的遍历操作比较频繁，而对遍历操作的准确性要求较低的情况。
安全失败机制可以保证遍历操作的安全性，即使在遍历过程中有其他线程修改了集合，也不会抛出异常，但可能导致迭代结果不一定准确。

总体来说，选择使用哪种机制取决于对数据一致性和遍历操作实时性的要求。如果需要及时发现并发修改问题并保证数据一致性，可以选择快速失败机制；如果更关注遍历操作的安全性，不希望抛出异常，可以选择安全失败机制。

Stream

Java 8 引入了一个新的抽象概念 Stream，它可以帮助我们以声明性方式处理数据。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API 可以极大提高 Java 程序员的生产力，让程序员能够用函数式编程方式写出高效率、干净、简洁的代码。这种“偷懒”的方式又称为“宽表思维”。以下是一些基本的 Stream 流的使用方法： 1. 创建 Stream 你可以通过 Collection 系列集合提供的 stream() 或 parallelStream()，或者使用 Arrays.stream()，Stream.of()等方法创建一个 Stream：

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();
Stream<String> stream = Stream.of("a", "b", "c");

2. 中间操作 Stream 提供了多种中间操作，例如 filter、map、limit、skip、sorted 等：

stream.filter(e -> e.contains("b")) // 过滤出包含b的元素
      .map(String::toUpperCase) // 将元素转为大写
      .sorted() // 对元素进行排序
      .limit(2); // 限制流的大小为2

3. 终止操作 中间操作只描述 Stream，最终操作才会触发计算。常见的终止操作有 forEach、toArray、reduce、collect 等：

stream.forEach(System.out::println); // 输出流中的每个元素

List<String> list = stream.collect(Collectors.toList()); // 将流转换为列表

Optional<String> reduced = stream.reduce((value, combined) -> combined += value); // reduce操作

注意：一旦进行了终止操作，就不能再对 Stream 进行其他操作了。

compareTo()和equals()

在Java中，equals() 和 compareTo() 都是用于比较两个对象的方法，但它们的使用场景和返回的结果是不同的。

equals() 方法：该方法来自于 Object 类，用于检测两个对象是否相等。对于一些类如 String、Integer 等，该方法已被重写，可以比较对象的内容是否相等。equals() 方法返回一个布尔值，如果两个对象相等则返回 true，否则返回 false。equals() 方法需要满足的特性包括：自反性（对于任何非空引用值 x，x.equals(x) 应返回 true）、对称性、传递性、一致性以及对于任何非空引用值 x，x.equals(null) 应返回 false。
compareTo() 方法：该方法来自于 Comparable 接口，用于对类的一个实例进行“自然排序”。compareTo() 方法返回一个整数，其结果是负数、零或正数，分别表示此对象小于、等于或大于指定的对象。自然排序可能根据类的具体实现而不同，例如，对于字符串类，compareTo() 会按照字典顺序进行比较。为了保证compareTo的合理性，需要保证其与equals的一致性，即x.compareTo(y) == 0 等价于 x.equals(y)为true。

总的来说，equals()方法是判断两个对象是否相等，而compareTo()方法是进行两个对象的大小比较。

HashMap的扩容过程

HashMap 的扩容过程主要涉及到重新计算存储元素的位置以及复制元素的操作。下面是 HashMap 扩容的主要步骤：

创建新的存储结构：当元素的数量超过了负载因子（load factor，默认值为0.75）和当前容量（cap）的乘积时，HashMap 会进行扩容。扩容过程中，首先会创建一个新的 Entry 数组，其容量是原数组的两倍。
重新计算位置并复制元素：扩容后，旧的元素需要复制到新的 Entry 数组中。由于新数组的长度是原数组的两倍，所以元素在新数组中的位置需要重新计算。重新计算的方法是通过元素的 hash 值对新的数组长度进行取模运算。

具体的复制过程如下：

遍历旧的 Entry 数组，对数组中的每个 Entry 元素进行操作。
对于每个 Entry，它可能是一个单独的元素，也可能是一个链表（如果有 hash 冲突的情况）。对于链表的情况，需要遍历链表，对链表中的每个元素进行操作。
对于每个元素，首先计算其在新数组中的位置，然后将其复制到新的位置上。如果新的位置已经有元素了（可能是其他的元素已经复制过来了），则需要处理冲突。HashMap 的处理方法是将新的元素插入到链表的头部。

替换旧的存储结构：当所有的元素都复制完成后，新的 Entry 数组就可以替换掉旧的数组了。旧的数组会被丢弃，等待垃圾回收。

以上就是 HashMap 的扩容过程。需要注意的是，由于扩容过程需要重新计算位置并复制元素，所以这是一个比较耗时的操作，尤其是当 HashMap 中存储的元素数量非常大时。因此，在使用 HashMap 时，如果可以预估存储的元素数量，最好在创建 HashMap 时指定一个足够大的初始容量，以避免后续的扩容操作。

为什么负载因子是0.75

负载因子（load factor）是一个时间和空间效率的折衷。具体到HashMap中，当我们将负载因子设置得较高时，例如0.9或者1，意味着我们允许HashMap变得更满，这可以节省内存空间。但是，HashMap的查找效率可能会因此降低，因为哈希冲突的机会变得更大。

相反，如果我们将负载因子设置得较低，例如0.5，意味着我们允许HashMap的数组部分空着，这可能会增加查找效率，因为哈希冲突的机会变得更小。但同时，这也会浪费内存空间。

那么，为什么默认的负载因子是0.75呢？这是一个折衷的选择。0.75是时间和空间效率之间的一个平衡。这个值在实践中被证明是非常有效的，它在空间效率和时间效率之间取得了一个比较好的平衡。

需要注意的是，具体的负载因子应该根据实际的使用情况进行选择。如果内存空间充足，而且希望能提供更快的查询效率，可以选择一个较小的负载因子。如果内存空间紧张，可以选择一个较大的负载因子。

详细介绍一下红黑树什么时候设置节点为黑什么时候设置为红

红黑树是一种自平衡二叉查找树，它首先满足二叉查找树的基本性质，即每个节点的左子树的所有节点都比当前节点小，每个节点的右子树的所有节点都比当前节点大。而且，红黑树通过一些额外的规则，保证了树的相对平衡，使得查找、插入和删除等操作的最坏时间复杂度都能达到O(log n)。

红黑树的规则如下：

每个节点不是红色就是黑色。
根节点是黑色。
所有叶子节点（通常是NULL或者哨兵节点）都是黑色。
如果一个节点是红色，那么它的两个子节点都是黑色（也就是说，在每条从根到叶子的路径上不能有两个连续的红色节点）。
从任一节点到其每个叶子节点的所有路径都包含相同数量的黑色节点（这些黑色节点的数量也叫做黑高）。

这些规则确保了红黑树的关键性质：从根节点到叶子节点最长的可能路径不多于最短的可能路径的两倍长。结果是红黑树大致上是平衡的。因为操作如插入、删除和查找某个值最坏情况下时间复杂度为O(log n)次，其中n是树中节点的数目。

红黑树在很多语言的标准库中都有应用，如Java中的TreeMap和TreeSet，C++ STL中的map，multimap，multiset都是采用红黑树实现的。

节点的颜色在红黑树中起到了平衡的作用。节点设置为红色或者黑色是为了满足红黑树的五个性质。

当我们插入或者删除节点时，我们先按照二叉查找树的规则进行操作，然后通过调整节点的颜色和进行旋转来保证满足红黑树的性质。

具体来说：

插入操作：插入节点默认为红色。因为插入红色节点比插入黑色节点破坏红黑树的性质的可能性要小。插入红色节点只有可能违反性质4（如果一个节点是红色，那么它的两个子节点都是黑色）。如果插入黑色节点，可能会导致违反性质5（从任一节点到其每个叶子节点的所有路径都包含相同数量的黑色节点）。然后，我们可以通过颜色调整和树旋转，将它调整为一颗合法的红黑树。
删除操作：删除节点时，如果删除的是红色节点，那么整棵树的黑色节点的数量并没有变化，所以红黑树的性质依然保持。如果删除的是黑色节点，可能会导致性质5被破坏。这时我们需要通过颜色调整和树旋转，来恢复红黑树的性质。

CAS 是什么举一个具体的例子

CAS，全称为Compare-and-Swap，是一种无锁的线程安全实现技术。它是一种基于CPU原语的原子操作，用于管理对共享数据的并发访问。

CAS有三个操作数：内存值V、旧的预期值A和要修改的新值B。CAS指令执行时，当内存值V和预期值A相等时，才会将内存值修改为B，否则不会执行任何操作。无论是否修改成功，都会返回操作前的旧值V。通常，这个操作是在一个循环中执行的，直到成功为止。

一个简单的例子是用CAS实现一个线程安全的计数器：

java

class CASCounter {
    private AtomicInteger value;

    public CASCounter() {
        value = new AtomicInteger(0);
    }

    public int incrementAndGet() {
        int oldVal, newVal;
        do {
            oldVal = value.get();
            newVal = oldVal + 1;
        } while (!value.compareAndSet(oldVal, newVal));
        return newVal;
    }
}

在这个例子中，incrementAndGet方法将计数器加1，然后返回新的计数值。如果在尝试更新计数值时，value的当前值（oldVal）与期望的旧值（newVal - 1）不同，说明其他线程已经修改了计数值，这时compareAndSet会返回false，我们就需要在循环中再尝试一次。直到compareAndSet返回true，表示成功更新了计数值，我们才退出循环，返回新的计数值。

需要注意的是，虽然CAS能够实现无锁的线程安全操作，但也有一些问题，比如ABA问题，所以在实际使用中需要谨慎处理。

从Java 8开始，ConcurrentHashMap使用什么方式实现分段锁

从Java 8开始，ConcurrentHashMap已经不再使用分段锁的概念了。它改用一种更为高效和复杂的方式来保证线程安全性，并允许更高的并发性。

新的ConcurrentHashMap使用一种叫CAS (Compare-and-Swap) 的原子操作以及锁来保证线程安全。同时，通过将键值对在内部数组的不同位置进行操作，实现高并发性。也就是说，多个线程可以同时在不同的数组位置进行修改操作。

ConcurrentHashMap的内部数据结构是一个Node数组。每个Node包含一个键、一个值和一个指向下一个Node的引用。当发生哈希冲突时，会在对应的数组索引位置形成链表或红黑树（当链表长度超过一定阈值时，链表会转换为红黑树，以保证更高效的查找）。

在添加、删除和更新操作时，ConcurrentHashMap会尝试使用CAS操作进行，这是一种无锁的线程安全操作。如果CAS失败（可能因为其他线程同时进行了修改），ConcurrentHashMap可能会使用synchronized锁定部分数据，以保证线程安全。

所以，从Java 8开始，ConcurrentHashMap的实现方式更加复杂，但也更高效，能够提供更好的并发性能。虽然不再是传统意义上的“分段锁”，但其实质仍然是一种精细化的锁机制，允许多个线程在不同的数据部分上并发操作。

新的ConcurrentHashMap使用一种叫CAS (Compare-and-Swap) 的原子操作以及锁来保证线程安全。为什么这样可以比分段锁效率高

Java 8中的ConcurrentHashMap实现通过CAS（Compare-and-Swap）操作和精细的锁粒度来提高效率，主要有以下几个方面的优势：

更精细的锁粒度：在Java 7及之前版本的ConcurrentHashMap中，数据是按照“段”（Segment）来进行加锁的，每个段代表了ConcurrentHashMap的一部分数据。然而，在Java 8及之后的实现中，这种“段”锁的概念被移除了。取而代之的是，锁粒度更细的桶级别锁（bin-level lock）。只有当多个线程访问同一个桶（bin）时，它们才需要进行同步。如果它们访问的是不同的桶，那么这些操作可以同时进行，无需等待其他线程。
无锁操作的引入：ConcurrentHashMap在Java 8中引入了CAS操作，这是一种无锁的线程安全操作。在进行某些操作（如插入，删除，修改）时，它会首先尝试使用CAS操作，只有在CAS操作失败时，才会采用锁进行同步。这样可以减少获取锁的开销，从而提高效率。
节点的动态结构：在Java 8的ConcurrentHashMap中，每个桶内的节点结构会根据冲突的情况动态地进行调整。在冲突较少的情况下，使用链表结构。当冲突增多，链表长度超过一定阈值（默认为8）时，链表会转化为红黑树。红黑树的查询效率是对数级别的，远高于链表，因此在冲突较多的情况下能提供更好的性能。

因此，通过更精细的锁粒度，无锁操作的引入，以及动态的节点结构，Java 8及之后版本的ConcurrentHashMap在性能上超越了老版本的分段锁实现。

HashMap在java 1.7版本中有什么样的并发问题

在Java 1.7版本的HashMap中，如果多个线程同时进行put操作，可能会导致HashMap中的数据结构被破坏，具体表现为形成环形链表，也就是在一个链表中，某个节点的下一个节点可能是它自己或者链表中的其他节点，这样就形成了一个环。这会导致在访问HashMap时进入无限循环，也就是常说的死循环。

这个问题主要出现在HashMap的resize()方法中，也就是当HashMap需要扩容时。这个方法会对HashMap的内部结构进行调整，如果多个线程同时调用这个方法，就可能会出现问题。因为HashMap没有同步机制来防止这种情况。

具体来说，当两个线程同时检测到HashMap需要扩容，并同时开始进行扩容操作时，就可能出现一个线程把另一个线程的操作覆盖掉，然后第二个线程又把第一个线程的操作覆盖掉，这就可能导致数据结构的破坏。

为了解决这个问题，一种方法是在操作HashMap时进行适当的同步。但是，这可能会降低性能。另一种更好的方法是使用Java提供的并发集合类，例如ConcurrentHashMap，这些类在内部已经处理了并发问题，可以安全地在多线程环境中使用。

什么是stream

在Java中，Stream是Java 8中引入的一个新的抽象概念，它可以让你以声明性方式处理数据集合（声明性就是说你只需告诉代码“我想要什么”，而无需告诉代码“我需要你怎么去做”）。

Java Stream API可以用于对数据进行操作，比如数据库查询和数据处理等场景。Stream API提供了一种高效且易于使用的处理数据的方式。

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。集合讲的是数据，Stream讲的是计算。

注意：

Stream 自己不会存储元素。
Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

举个简单的例子：

java

List<String> list = Arrays.asList("a", "b", "c");

// 使用Stream对list进行操作
List<String> result = list.stream()
    .filter(s -> s.startsWith("a"))  // 过滤出以"a"开头的元素
    .collect(Collectors.toList());   // 将结果收集到一个新的List中

// 输出：[a]
System.out.println(result);

以上例子中，我们通过stream对list进行了过滤操作，并将结果收集到了一个新的List中。这就是Java Stream的一个基本用法。

Stream的最终操作

Stream的最终操作（Terminal Operation）用于产生一个结果或者一个副作用。在应用了终止操作之后，你不能再使用Stream了。

Stream的最终操作包括：

forEach：对每个元素执行特定的操作，这是一个返回 void 的方法，所以它常常用于产生一个副作用，比如输出。
toArray：返回一个包含所有元素的数组。
reduce：通过给定的函数来把 Stream 元素组合成一个更复杂的值，如求和，求最大值等。
collect：通过提供的 Collector 对象，把 Stream 的元素收集到某种数据结构中，比如 List，Set 或者 Map。
min 和 max：根据给定的 Comparator 找到流中的最小值或最大值。
count：返回 Stream 的元素个数。
anyMatch，allMatch，noneMatch：返回 Stream 是否匹配给定的条件。
findFirst，findAny：返回 Stream 中的第一个元素，或者任意元素。

注意，这些操作都会消耗掉 Stream，这就意味着，在终止操作被调用之后，我们不能再使用 Stream 了。如果你需要对同一份数据源进行多次操作，那么每次操作都必须创建新的 Stream。

hashmap的负载因子为啥设置为0.75

负载因子是一个很重要的调优参数，用来在空间效率和时间效率之间进行权衡。负载因子的默认值0.75是由HashMap的设计者通过经验得出的，主要考虑了以下几个因素：

空间和时间的权衡：负载因子越大，HashMap中的Entry越多，也就意味着空间的利用率越高，但是查找效率可能会降低（因为链表长度增加，哈希冲突的可能性增大）。负载因子越小，虽然冲突的可能性小，查找效率高，但空间利用率低。
避免频繁的resize：HashMap在插入数据时，如果size > capacity * loadFactor，则会触发rehash操作，也就是会创建一个新的更大的数组，并把旧数组中的所有元素重新放入新的数组中。这是一个代价较高的操作。选择0.75可以在保持HashMap的性能的同时，尽量减少resize操作。
经验：0.75是经验上的选择，通过大量实验表明，这个数字可以提供不错的性能。

所以，0.75这个值在哈希表的实现中是一个比较好的折中，既能保证时间效率，也能保证空间效率，且避免了频繁的扩容操作。这是为什么Java的HashMap中负载因子的默认值是0.75的原因。

八股-集合类