この記事では、秋採用の Java 面接でよくある質問の分析を紹介します。困っている友人は参考にしていただければ幸いです。
序文
ハゲ頭だけが強くなれる
Redisはまだ見守っています、今日は秋の採用活動を共有します私が見た（遭遇した）面接の質問（比較的一般的なもの）
0. 最後のキーワード
最後のキーワードについて簡単に説明します。 「final」という単語は修飾に使用できますか?
実際の面接でこの質問に遭遇しましたが、その時はうまく答えられませんでした。
#Final はクラス、メソッド、メンバー変数を変更できます
#final がクラスを変更する場合、そのクラスは継承できないことを意味します- 初期の頃は、最終的に変更されたメソッドは次のようになります。これらのメソッドへの呼び出しはすべてインライン呼び出しに変換され、効率が向上します (ただし、コンパイラと JVM はより賢くなっているので、現在はこれについては一般的に気にしていません)
#final がメンバー変数を変更する場合、次の 2 つの状況が発生します。
-
これが基本型の場合、この変数によって表される値は決して変更できないことを意味します。 (再割り当てはできません)!
。たとえば、次のようなコードを書くことができます:
private Final int java3y = new Randon().nextInt(20);
コンパイラでコードを記述するようなプログラミング経験はありますか?これを行うときは、特定のシナリオで変数を Final として宣言する必要があります。そうしないと、コンパイルが失敗します。なぜこのように設計されているのでしょうか?
外部クラス インスタンス変数
#jdk1.8 コンパイル環境に切り替えるとコンパイルできます~
それについて話しましょうまず、宣言が最終である理由を以下に示します。
内部データと外部データの一貫性を維持するため、
Java はキャプチャの形式でのみクロージャを実装します。 -by-value (匿名) この関数は関数内で自由変数
を再コピーします。その後、関数の外と関数内に
その後、匿名内部クラスの外部基本型変数の値を変更したり、外部参照変数のポインティングを変更しようとすると、表面上 すべてが成功したように見えますが、
は実際には外部変数
に影響を与えません。したがって、Java 自体が奇妙に見えるのを防ぐために、この最後の制限を追加しました。 参考資料:
1 char と varchar の違い
を使用するものと、##を使用するものがあります。 #ページングメカニズム
。 char的存储方式是：英文字符占1个字节，汉字占用2个字节；varchar的存储方式是：英文和汉字都占用2个字节，两者的存储数据都非unicode的字符数据。
char是固定长度，长度不够的情况下，用空格代替。varchar表示的是实际长度的数据类型
选用考量：
二、多个线程顺序打印问题
三个线程分别打印A，B，C，要求这三个线程一起运行，打印n次，输出形如“ABCABCABC....”的字符串。
原博主给出了4种方式，我认为信号量这种方式比较简单和容易理解，我这里粘贴一下(具体的可到原博主下学习)..
public class PrintABCUsingSemaphore {
private int times;
private Semaphore semaphoreA = new Semaphore(1);
private Semaphore semaphoreB = new Semaphore(0);
private Semaphore semaphoreC = new Semaphore(0);
public PrintABCUsingSemaphore(int times) {
this.times = times;
}
public static void main(String[] args) {
PrintABCUsingSemaphore printABC = new PrintABCUsingSemaphore(10);
// 非静态方法引用 x::toString 和() -> x.toString() 是等价的！
new Thread(printABC::printA).start();
new Thread(printABC::printB).start();
new Thread(printABC::printC).start();
/*new Thread(() -> printABC.printA()).start();
new Thread(() -> printABC.printB()).start();
new Thread(() -> printABC.printC()).start();
*/
}
public void printA() {
try {
print("A", semaphoreA, semaphoreB);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void printB() {
try {
print("B", semaphoreB, semaphoreC);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void printC() {
try {
print("C", semaphoreC, semaphoreA);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void print(String name, Semaphore current, Semaphore next)
throws InterruptedException {
for (int i = 0; i < times; i++) {
current.acquire();
System.out.print(name);
next.release();
}
}
}ログイン後にコピー
2018年9月14日18:15:36 yy笔试题就出了..
三、生产者和消费者
在不少的面经都能看到它的身影哈~~~基本都是要求能够手写代码的。
其实逻辑并不难，概括起来就两句话：
基于原作者的代码，我修改了部分并给上我认为合适的注释(下面附上了原作者出处，感兴趣的同学可到原文学习)
生产者：
import java.util.Random;
import java.util.Vector;
import java.util.concurrent.atomic.AtomicInteger;
public class Producer implements Runnable {
// true--->生产者一直执行，false--->停掉生产者
private volatile boolean isRunning = true;
// 公共资源
private final Vector sharedQueue;
// 公共资源的最大数量
private final int SIZE;
// 生产数据
private static AtomicInteger count = new AtomicInteger();
public Producer(Vector sharedQueue, int SIZE) {
this.sharedQueue = sharedQueue;
this.SIZE = SIZE;
}
@Override
public void run() {
int data;
Random r = new Random();
System.out.println("start producer id = " + Thread.currentThread().getId());
try {
while (isRunning) {
// 模拟延迟
Thread.sleep(r.nextInt(1000));
// 当队列满时阻塞等待
while (sharedQueue.size() == SIZE) {
synchronized (sharedQueue) {
System.out.println("Queue is full, producer " + Thread.currentThread().getId()
+ " is waiting, size：" + sharedQueue.size());
sharedQueue.wait();
}
}
// 队列不满时持续创造新元素
synchronized (sharedQueue) {
// 生产数据
data = count.incrementAndGet();
sharedQueue.add(data);
System.out.println("producer create data:" + data + ", size：" + sharedQueue.size());
sharedQueue.notifyAll();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupted();
}
}
public void stop() {
isRunning = false;
}
}ログイン後にコピー
消费者：
import java.util.Random;
import java.util.Vector;
public class Consumer implements Runnable {
// 公共资源
private final Vector sharedQueue;
public Consumer(Vector sharedQueue) {
this.sharedQueue = sharedQueue;
}
@Override
public void run() {
Random r = new Random();
System.out.println("start consumer id = " + Thread.currentThread().getId());
try {
while (true) {
// 模拟延迟
Thread.sleep(r.nextInt(1000));
// 当队列空时阻塞等待
while (sharedQueue.isEmpty()) {
synchronized (sharedQueue) {
System.out.println("Queue is empty, consumer " + Thread.currentThread().getId()
+ " is waiting, size：" + sharedQueue.size());
sharedQueue.wait();
}
}
// 队列不空时持续消费元素
synchronized (sharedQueue) {
System.out.println("consumer consume data：" + sharedQueue.remove(0) + ", size：" + sharedQueue.size());
sharedQueue.notifyAll();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
}
}ログイン後にコピー
Main方法测试：
import java.util.Vector;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test2 {
public static void main(String[] args) throws InterruptedException {
// 1.构建内存缓冲区
Vector sharedQueue = new Vector();
int size = 4;
// 2.建立线程池和线程
ExecutorService service = Executors.newCachedThreadPool();
Producer prodThread1 = new Producer(sharedQueue, size);
Producer prodThread2 = new Producer(sharedQueue, size);
Producer prodThread3 = new Producer(sharedQueue, size);
Consumer consThread1 = new Consumer(sharedQueue);
Consumer consThread2 = new Consumer(sharedQueue);
Consumer consThread3 = new Consumer(sharedQueue);
service.execute(prodThread1);
service.execute(prodThread2);
service.execute(prodThread3);
service.execute(consThread1);
service.execute(consThread2);
service.execute(consThread3);
// 3.睡一会儿然后尝试停止生产者(结束循环)
Thread.sleep(10 * 1000);
prodThread1.stop();
prodThread2.stop();
prodThread3.stop();
// 4.再睡一会儿关闭线程池
Thread.sleep(3000);
// 5.shutdown()等待任务执行完才中断线程(因为消费者一直在运行的，所以会发现程序无法结束)
service.shutdown();
}
}ログイン後にコピー
另外，上面原文中也说了可以使用阻塞队列来实现消费者和生产者。这就不用我们手动去写wait/notify的代码了，会简单一丢丢。可以参考：
四、算法[1]
我现在需要实现一个栈，这个栈除了可以进行普通的push、pop操作以外，还可以进行getMin的操作，getMin方法被调用后，会返回当前栈的最小值，你会怎么做呢？你可以假设栈里面存的都是int整数
解决方案：
import java.util.ArrayList;
import java.util.List;
public class MinStack {
private List<Integer> data = new ArrayList<Integer>();
private List<Integer> mins = new ArrayList<Integer>();
public void push(int num) {
data.add(num);
if (mins.size() == 0) {
// 初始化mins
mins.add(num);
} else {
// 辅助栈mins每次push当时最小值
int min = getMin();
if (num >= min) {
mins.add(min);
} else {
mins.add(num);
}
}
}
public int pop() {
// 栈空，异常，返回-1
if (data.size() == 0) {
return -1;
}
// pop时两栈同步pop
mins.remove(mins.size() - 1);
return data.remove(data.size() - 1);
}
public int getMin() {
// 栈空，异常，返回-1
if (mins.size() == 0) {
return -1;
}
// 返回mins栈顶元素
return mins.get(mins.size() - 1);
}
}ログイン後にコピー
继续优化：
但是，如果一直push的值是最小值，那我们的mins辅助栈还是会有大量的重复元素，此时我们可以使用索引(mins辅助栈存储的是最小值索引，非具体的值)！
最终代码：
import java.util.ArrayList;
import java.util.List;
public class MinStack {
private List<Integer> data = new ArrayList<Integer>();
private List<Integer> mins = new ArrayList<Integer>();
public void push(int num) throws Exception {
data.add(num);
if(mins.size() == 0) {
// 初始化mins
mins.add(0);
} else {
// 辅助栈mins push最小值的索引
int min = getMin();
if (num < min) {
mins.add(data.size() - 1);
}
}
}
public int pop() throws Exception {
// 栈空，抛出异常
if(data.size() == 0) {
throw new Exception("栈为空");
}
// pop时先获取索引
int popIndex = data.size() - 1;
// 获取mins栈顶元素，它是最小值索引
int minIndex = mins.get(mins.size() - 1);
// 如果pop出去的索引就是最小值索引，mins才出栈
if(popIndex == minIndex) {
mins.remove(mins.size() - 1);
}
return data.remove(data.size() - 1);
}
public int getMin() throws Exception {
// 栈空，抛出异常
if(data.size() == 0) {
throw new Exception("栈为空");
}
// 获取mins栈顶元素，它是最小值索引
int minIndex = mins.get(mins.size() - 1);
return data.get(minIndex);
}
}ログイン後にコピー
参考资料：
5 マルチスレッドでの HashMap ご存知のとおり、HashMap はスレッドセーフなクラスではありません。しかし、面接中に「HashMap をマルチスレッド環境で使用するとどうなるのですか?」と質問されるかもしれません。 ?
結論:
- put() によって引き起こされるマルチスレッドのデータの不整合 (データの損失)
- #resize()
操作により循環リンクリストが生成されます
jdk1.8 は循環チェーンの問題を解決しました (2 つのペアの宣言)ポインタの数と 2 つのリンク リストの維持)
フェイルファスト メカニズム。現在の HashMap を同時に削除/変更すると、ConcurrentModificationException 例外がスローされます
HashMap スレッドのセキュリティ不安の現れについて話す: http://www.importnew.com/22011.html-
jdk1.8 ハッシュマップ マルチスレッド put は無限ループを引き起こしません: https://blog.csdn.net/qq_27007251/article/details/71403647
## 6. Spring と Springboot の違い1. SpringBoot は独立した Spring アプリケーションを作成できます
2. Spring の構成を簡素化します。 ##Spring その煩雑な設定により、かつては「設定地獄」と呼ばれていました。さまざまな XML や Annotation の設定は目まぐるしく、何か問題が発生した場合に原因を見つけるのが困難です。
##G1 は メモリを整理しますプロセスのガベージ コレクターは、大量のメモリ フラグメントを生成しません。
大規模データの処理は、面接と筆記試験の両方で頻繁にテストされる知識ポイントでもあります。比較的一般的です。幸いなことに、私は次の記事を読み、大量のデータを解決するためのいくつかのアイデアを抜粋しました。
適用範囲:データ ディクショナリの実装、データの重みの決定、またはセットの交差部分の検索に使用できます
#ハッシュ 適用範囲: 素早い検索と削除のための基本的なデータ構造。通常、必要なデータの総量はメモリに格納できます。
bit-map適用範囲: データの検索、決定、削除を高速に行うことができます。一般的に、データ範囲は int
ヒープ 適用範囲: 最初の n は大量のデータに対して大きく、n は比較的小さく、ヒープをメモリに配置できます - # ＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃２層バケツの分割----実際には、それは本質的に「分割する」というテクニックに焦点を当てた、[分割して征服]の考え方です！
#適用範囲: k 番目に大きい、中央値、非繰り返しまたは繰り返しの数値データベース インデックス
-
##転置インデックス(転置インデックス)
- ##外部並べ替え
##適用範囲: ビッグデータのソート、重複排除
分散処理mapreduce
詳細については、原文を参照してください:
9. べき等性
9.1HTTP べき等性
昨日、私は一連の筆記試験問題、つまり従来の HTTP の get/post の違いを受けました。今日再度検索してみたところ、以前の理解とは少し異なっていることがわかりました。 人が最初から Web 開発を行う場合、
HTTP プロトコルでの HTML の使用が、HTTP プロトコルの唯一の合理的な使用法であるとみなされる可能性が非常に高くなります。したがって、
を過度に一般化するという間違いを犯しました。HTTP プロトコル仕様から単純に言えば、前に要約した
GET/POST の区別は役に立たない可能性があります。 (ただし、記事全体を読んだ後、個人的に思う: インタビューで GET/POST の違いがある場合は、デフォルトで Web 開発シナリオで回答する方が良いです。これは面接官が望んでいることかもしれません 回答)
GET と POST の違いは何ですか?そして、なぜインターネット上のほとんどの答えが間違っているのか。 http://www.cnblogs.com/nankezhishi/archive/2012/06/09/getandpost.html
メソッドには、(エラーや有効期限の問題を除けば) N > 0 個の同一のリクエストの副作用が 1 つのリクエストの場合と同じであるという「冪等性」の特性もあります。
定義によれば、HTTP メソッドの冪等性は
であり、リソースに対する 1 つまたは複数のリクエストが同じ副作用を持つ必要があることを意味します。
GET/POST/DELETE/PUT メソッド冪等性:
- GET
は冪等で副作用はありません
DELETE/PUT- は冪等であり、副作用があります
たとえば、次のようにします。 ID 2 の注文を削除または更新します: #POST- は非になります。 -idempotent 、副作用あり
#たとえば、 3y:HTTP プロトコル自体は
リソース指向のアプリケーション層プロトコル ですが、HTTP プロトコルの実際の使用方法は次のとおりです。インターネットには 2 つの異なる方法があります。1 つは
RESTful です。これは、HTTP をアプリケーション層プロトコルとして扱い、HTTP プロトコルのさまざまな規制をより忠実に遵守します ( は HTTP メソッド # を最大限に活用します) ##); もう 1 つの は SOA です。これは、HTTP をアプリケーション層プロトコルとして完全にはみなしませんが、HTTP プロトコルをトランスポート層プロトコルとして使用し、HTTP 層プロトコルの上に独自のアプリケーションを構築します参考資料:
HTTP 冪等性について http://www.cnblogs.com/weidagang2046/archive/2011/06/04/2063696.html#!comments
- RESTful の冪等性を理解する方法http://blog.720ui.com/2016/restful_idempotent/
- Get との違いについての浅い話HTTP での投稿 http://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html
## HTTP リクエスト内の POST リクエストと GET リクエストの違いは何ですか? https://www.zhihu.com/question/27622127/answer/37676304- ##9.2 インターフェイスの冪等性
情報を確認すると、多くのブログで interfaces の冪等性について言及されていることがわかります。上記から、POST メソッドが非冪等であることもわかります。ただし、何らかの手段を使用して、POST メソッドのインターフェイスを冪等にすることができます。
ここまで述べてきましたが、冪等インターフェイスを設計する利点は何でしょうか? ? ? ?
非冪等性のデメリットの例を挙げてください:
3y 私は 1 年生のとき、体育の授業を受講しなければなりませんでしたが、学校の授業受講システムはひどいものでした（非常に高い遅延）。クラスを取得したかったので、10 個以上の Chrome タブを開いて取得しました (1 つの Chrome タブがクラッシュしても、別の Chrome タブはまだ利用可能でした)。卓球のボールかバドミントンのボールをつかみたいです。
クラスを受講する時間が来たら、受講したい卓球またはバドミントンを順番にクリックします。システムが適切に設計されておらず、リクエストが非冪等であり (またはトランザクションが適切に制御されておらず)、私の手の速度が十分に速く、ネットワークが十分に優れている場合は、卓球やバドミントンのレッスンをたくさん受けたかもしれません。 (これは不合理です。1 人が選択できるコースは 1 つだけですが、私は複数または繰り返しのコースを取得しました)
モールに関係するアプリケーション シナリオは次のとおりです。ユーザーが複数の重複注文を行った
#クラス取得インターフェイスが冪等であれば、この問題は発生しません。冪等性とは、リソースに対する複数のリクエストが同じ 副作用を持つことを意味するためです。
データベース バックグラウンドには最大でも 1 つのレコードしか存在しないため、複数のコースを取得することはできません。
繰り返しの送信を防ぐためです (データベース内の複数の重複データ)。 インターネット上の一部のブロガーも、繰り返しの送信を解決するためのいくつかの一般的な解決策を共有しました。
同期ロック (シングル スレッド、クラスター内で失敗する可能性があります)- トークンテーブルの一意性制約 (単純な推奨事項)
---->冪等インターフェイスを実装する手段
mysql の挿入無視または重複キー更新時 (単純)
-
共有ロックの通常のインデックス (単純)
-
MQ または Redis 拡張を使用する (キューイング)
-
その他のソリューションマルチバージョン制御 MVCC 楽観的ロック 悲観的ロック ステートマシンなど。
-
参考資料:
分散システム インターフェイスの冪等性 http://blog.brucefeng.info/post/api-idempotent以上が秋採用の Java 面接でよくある質問のいくつかの分析の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。
![[Web フロントエンド] Node.js クイック スタート](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
