eaby面经二

最新推荐文章于 2022-08-06 15:19:13 发布

晒太阳的斑马

最新推荐文章于 2022-08-06 15:19:13 发布

阅读量186

点赞数

分类专栏： java 面试经文章标签： java面试，eaby面试

本文链接：https://blog.csdn.net/weixin_43840954/article/details/93419530

版权

java 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

面试经

3 篇文章 0 订阅

订阅专栏

Sean JAVA面试：

1、项目：项目情况介绍，难点解决

2、Java基础：

4）String对象判等

**：

        情况1：

                String s1 = "a" + "b";

                String s2 = "ab";

答：不相等，因为地址不等

        情况2：

                public void method(String s11, String s12) {

                    String s1 = s11 + s12;   //s11="a", s12="b"

                    String s2 = "ab";

                }

答：不相等，因为地址不等

Sean Java面试题：k8s有哪些组件，分别是干什么的？
引用链接

你们在项目里怎么使用的k8s，具体描述一下，怎么new新的实例？

描述一下你最印象深刻的项目，有什么难点，你是怎么解决的？会问很细。

项目里redis集群是怎么样的？
引用链接
redis的三种集群方式
redis有三种集群方式：主从复制，哨兵模式和集群。

1.主从复制

主从复制原理：

从服务器连接主服务器，发送SYNC命令；
主服务器接收到SYNC命名后，开始执行BGSAVE命令生成RDB文件并使用缓冲区记录此后执行的所有写命令；
主服务器BGSAVE执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令；
从服务器收到快照文件后丢弃所有旧数据，载入收到的快照；
主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令；
从服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令；（从服务器初始化完成）
主服务器每执行一个写命令就会向从服务器发送相同的写命令，从服务器接收并执行收到的写命令（从服务器初始化完成后的操作）
主从复制优缺点：

优点：

支持主从复制，主机会自动将数据同步到从机，可以进行读写分离
为了分载Master的读操作压力，Slave服务器可以为客户端提供只读操作的服务，写服务仍然必须由Master来完成
Slave同样可以接受其它Slaves的连接和同步请求，这样可以有效的分载Master的同步压力。
Master Server是以非阻塞的方式为Slaves提供服务。所以在Master-Slave同步期间，客户端仍然可以提交查询或修改请求。
Slave Server同样是以非阻塞的方式完成数据同步。在同步期间，如果有客户端提交查询请求，Redis则返回同步之前的数据
缺点：

Redis不具备自动容错和恢复功能，主机从机的宕机都会导致前端部分读写请求失败，需要等待机器重启或者手动切换前端的IP才能恢复。
主机宕机，宕机前有部分数据未能及时同步到从机，切换IP后还会引入数据不一致的问题，降低了系统的可用性。
Redis较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。
2.哨兵模式

当主服务器中断服务后，可以将一个从服务器升级为主服务器，以便继续提供服务，但是这个过程需要人工手动来操作。为此，Redis 2.8中提供了哨兵工具来实现自动化的系统监控和故障恢复功能。

哨兵的作用就是监控Redis系统的运行状况。它的功能包括以下两个。

（1）监控主服务器和从服务器是否正常运行。 
（2）主服务器出现故障时自动将从服务器转换为主服务器。

哨兵的工作方式：

每个Sentinel（哨兵）进程以每秒钟一次的频率向整个集群中的Master主服务器，Slave从服务器以及其他Sentinel（哨兵）进程发送一个 PING 命令。
如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值，则这个实例会被 Sentinel（哨兵）进程标记为主观下线（SDOWN）
如果一个Master主服务器被标记为主观下线（SDOWN），则正在监视这个Master主服务器的所有 Sentinel（哨兵）进程要以每秒一次的频率确认Master主服务器的确进入了主观下线状态
当有足够数量的 Sentinel（哨兵）进程（大于等于配置文件指定的值）在指定的时间范围内确认Master主服务器进入了主观下线状态（SDOWN），则Master主服务器会被标记为客观下线（ODOWN）
在一般情况下，每个 Sentinel（哨兵）进程会以每 10 秒一次的频率向集群中的所有Master主服务器、Slave从服务器发送 INFO 命令。
当Master主服务器被 Sentinel（哨兵）进程标记为客观下线（ODOWN）时，Sentinel（哨兵）进程向下线的 Master主服务器的所有 Slave从服务器发送 INFO 命令的频率会从 10 秒一次改为每秒一次。
若没有足够数量的 Sentinel（哨兵）进程同意 Master主服务器下线， Master主服务器的客观下线状态就会被移除。若 Master主服务器重新向 Sentinel（哨兵）进程发送 PING 命令返回有效回复，Master主服务器的主观下线状态就会被移除。
哨兵模式的优缺点

优点：

哨兵模式是基于主从模式的，所有主从的优点，哨兵模式都具有。
主从可以自动切换，系统更健壮，可用性更高。
缺点：

Redis较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。
3.Redis-Cluster集群

redis的哨兵模式基本已经可以实现高可用，读写分离，但是在这种模式下每台redis服务器都存储相同的数据，很浪费内存，所以在redis3.0上加入了cluster模式，实现的redis的分布式存储，也就是说每台redis节点上存储不同的内容。

Redis-Cluster采用无中心结构,它的特点如下：

所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽。

节点的fail是通过集群中超过半数的节点检测失效时才生效。

客户端与redis节点直连,不需要中间代理层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可。

工作方式：

在redis的每一个节点上，都有这么两个东西，一个是插槽（slot），它的的取值范围是：0-16383。还有一个就是cluster，可以理解为是一个集群管理的插件。当我们的存取的key到达的时候，redis会根据crc16的算法得出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，通过这个值，去找到对应的插槽所对应的节点，然后直接自动跳转到这个对应的节点上进行存取操作。

为了保证高可用，redis-cluster集群引入了主从模式，一个主节点对应一个或者多个从节点，当主节点宕机的时候，就会启用从节点。当其它主节点ping一个主节点A时，如果半数以上的主节点与A通信超时，那么认为主节点A宕机了。如果主节点A和它的从节点A1都宕机了，那么该集群就无法再提供服务了。

算法题;寻找平衡点，有一个数组，对于数组里某一个元素，他左边的数之和等于右边数的和，称这个元素为平衡点。找出数组的所有平衡点。讲出思路，会问复杂度。

Sean面试总结：老外video：spring相关知识，数据库连接池，算法题是旋转过的排序数组找target值，gc。Sean：top k问题。手写类和方法，还有几个follow up问题。分布式cap原理和base原理，最终一致性，一致性哈希

题目（算法题是旋转过的排序数组找target值）
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

示例 1:

输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true
1
2
示例 2:

输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false

代码实现：

class Solution {
    public boolean search(int[] nums, int target) {
     if (nums == null || nums.length == 0) {
            return false;
        } 
        if (nums.length == 1 && nums[0] == target) {
            return true;
        } else if (nums.length == 1 && nums[0] != target) {
            return false;
        }
        
        // Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                return true;
            }
        }
        return false;
    }
}

作者：fan23_0708
来源：CSDN
原文：https://blog.csdn.net/sinat_35050808/article/details/84141189
版权声明：本文为博主原创文章，转载请附上博文链接！

Top K问题在数据分析中非常普遍的一个问题（在面试中也经常被问到），比如：
从20亿个数字的文本中，找出最大的前100个。
解决Top K问题有两种思路，
最直观：小顶堆（大顶堆 -> 最小100个数）；
较高效：Quick Select算法。
LeetCode上有一个问题215. Kth Largest Element in an Array，类似于Top K问题。

堆
小顶堆（min-heap）有个重要的性质——每个结点的值均不大于其左右孩子结点的值，则堆顶元素即为整个堆的最小值。JDK中PriorityQueue实现了数据结构堆，通过指定comparator字段来表示小顶堆或大顶堆，默认为null，表示自然序（natural ordering）。

小顶堆解决Top K问题的思路：小顶堆维护当前扫描到的最大100个数，其后每一次的扫描到的元素，若大于堆顶，则入堆，然后删除堆顶；依此往复，直至扫描完所有元素。Java实现第K大整数代码如下：

public int findKthLargest(int[] nums, int k) {
  PriorityQueue<Integer> minQueue = new PriorityQueue<>(k);
  for (int num : nums) {
    if (minQueue.size() < k || num > minQueue.peek())
      minQueue.offer(num);
    if (minQueue.size() > k)
      minQueue.poll();
  }
  return minQueue.peek();
}

Quick Select
Quick Select [1]脱胎于快排（Quick Sort），两个算法的作者都是Hoare，并且思想也非常接近：选取一个基准元素pivot，将数组切分（partition）为两个子数组，比pivot大的扔左子数组，比pivot小的扔右子数组，然后递推地切分子数组。Quick Select不同于Quick Sort的是其没有对每个子数组做切分，而是对目标子数组做切分。其次，Quick Select与Quick Sort一样，是一个不稳定的算法；pivot选取直接影响了算法的好坏，worst case下的时间复杂度达到了O(n2)。下面给出Quick Sort的Java实现：

public void quickSort(int arr[], int left, int right) {
  if (left >= right) return;
  int index = partition(arr, left, right);
  quickSort(arr, left, index - 1);
  quickSort(arr, index + 1, right);
}

// partition subarray a[left..right] so that a[left..j-1] >= a[j] >= a[j+1..right]
// and return index j
private int partition(int arr[], int left, int right) {
  int i = left, j = right + 1, pivot = arr[left];
  while (true) {
    while (i < right && arr[++i] > pivot)
      if (i == right) break;
    while (j > left && arr[--j] < pivot)
      if (j == left) break;
    if (i >= j) break;
    swap(arr, i, j);
  }
  swap(arr, left, j);  // swap pivot and a[j]
  return j;
}

private void swap(int[] arr, int i, int j) {
  int tmp = arr[i];
  arr[i] = arr[j];
  arr[j] = tmp;
}

Quick Select的目标是找出第k大元素，所以

若切分后的左子数组的长度 > k，则第k大元素必出现在左子数组中；
若切分后的左子数组的长度 = k-1，则第k大元素为pivot；
若上述两个条件均不满足，则第k大元素必出现在右子数组中。
Quick Select的Java实现如下：

public int findKthLargest(int[] nums, int k) {
  return quickSelect(nums, k, 0, nums.length - 1);
}

// quick select to find the kth-largest element
public int quickSelect(int[] arr, int k, int left, int right) {
  if (left == right) return arr[right];
  int index = partition(arr, left, right);
  if (index - left + 1 > k)
    return quickSelect(arr, k, left, index - 1);
  else if (index - left + 1 == k)
    return arr[index];
  else
    return quickSelect(arr, k - index + left - 1, index + 1, right);

}

上面给出的代码都是求解第k大元素；若想要得到Top K元素，仅需要将代码做稍微的修改：比如，扫描完成后的小顶堆对应于Top K，Quick Select算法用中间变量保存Top K元素。

分布式cap原理和base原理，最终一致性，一致性哈希

**
引用链接
 引用最终一致性，一致性哈希

晒太阳的斑马

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
eaby面经二

Sean JAVA面试：1、项目：项目情况介绍，难点解决2、Java基础：1）Java访问控制符：private这些2）StringBuilder、StringBuffer对比，使用场景3）==和equals方法的区别，使用场景4）String对象判等：情况1：String s1 = “a” + “b”;String s2 = “ab”;情况2：public void met...
复制链接

扫一扫