"Java Senior Development engineer" nearly one months of interview summary __ Interview

After two years, once again the face of the job to find work, this time to change a little bit of work, but also a bit helpless. Personal technical team is good, two years time has grown a lot, also very do not give this team. However, due to some of the company's reasons and the comprehensive consideration of its own future development, but also have to leave, to find a more appropriate place to grow and develop. Compared to two years ago, now looking for a job is not so anxious, and not so urgent, there is no special want to go to the company, anyway to the company's basic internet companies are working overtime. Perhaps, this is the work of three years I will face a hurdle bar. For future choices and considerations, fear for the future. Perhaps I am unfounded, maybe it is doomed me to go to a certain company, anyway, insist on doing the best of their own. Keep on progressing and growing.

The following will be the recent interview some of the topics are summarized as follows, I hope that the students are now looking for a job and now facing graduation to find a job to help students. 1. Common design Pattern

Single case mode: Lazy type, a hungry man type, double check lock, static loading, internal class loading, enumeration class loading. Guarantees that a class has only one instance and provides a global access point to access it.

Agent mode: Dynamic agents and static proxies, when to use dynamic proxies.

Adapter Mode: Converts the interface of a class into another interface that the customer expects. Adapter mode makes it possible for those classes that cannot work together because of incompatible interfaces.

Decorator mode: Dynamic to Class plus function.

Observer pattern: sometimes referred to as the Publish/subscribe model, the Observer pattern defines a one-to-many dependency that allows multiple observer objects to listen to one subject object at the same time. When the state changes, the subject object notifies all the observer objects so that they can automatically update themselves.

Policy pattern: Define a series of algorithms, encapsulate them, and make them interchangeable with each other.

Appearance mode: Provides a consistent interface for a set of interfaces in a subsystem, and the appearance pattern defines a high-level interface that makes the subsystem easier to use.

Command mode: Encapsulates a request into an object so that you can parameterize the customer with different requests.

Creator pattern: Separates a complex build from its presentation, allowing the same build process to create different representations.

Abstract Factory Pattern: Provides an interface to create a series of related or interdependent objects without specifying their specific classes. 2. Basic Knowledge

Java basic types which, bytes and ranges

The difference and connection of Set, List, map

When to use HashMap

When to use Linkedhashmap, Concurrenthashmap, Weakhashmap

Which collection classes are thread-safe

Why set, List, and map do not implement cloneable and serializable interfaces

Implementation of the CONCURRENTHASHMAP, 1.7 and 1.8 implementations

The realization of Arrays.sort

When to use Copyonarraylist

The use of volatile

The use of synchronied

The difference between the realization of Reentrantlock and synchronied

The implementation principle and problems of CAs

The realization principle of AQS

The difference between an interface and an abstract class, and when to use

The steps of the class loading mechanism, what each step does, the static and final modified member variable loading time

Parental delegation Model

Reflection mechanism: Dynamic erasure of reflection generic, reflection dynamic invocation method, etc.

Dynamic binding: The parent class reference points to the child class object

JVM Memory management mechanism: what are the areas, what each zone does

JVM garbage collection mechanism: garbage collection algorithm garbage collector garbage Collection policy

JVM parameter settings and JVM tuning

What happens to the young generation memory overflow, what happens to the old generation memory overflow

Internal classes: Use and differences between static internal classes and anonymous inner classes

Redis and memcached: When to choose Redis, when to choose memcached, what is the memory model and storage strategy?

MySQL basic operation master-slave database consistency Maintenance

What are the MySQL optimization strategies

Implementation principle of B + tree for MySQL indexing

What happens when an index does not hit, causing a full table scan

Differences and relationships in the Java bio-NiO AIO

Why the bio is blocked NiO is non-blocking NiO is what the model is

The overall architecture of Java IO and the design patterns used

Reactor model and Proactor model

HTTP request message structure and content

HTTP three handshake and four waves

RPC-Related: How to design an RPC framework, from the IO Model Transport protocol serialization approach to consider

Linux command statistics, sorting, first few questions, etc.

Stringbuff and StringBuilder implementations, the underlying implementation is achieved by byte data, plus an array of copies

Use of CAS operations

Synchronous implementation of memory cache and database consistency

Advantages and disadvantages of micro-service

Parameter problem of thread pool

How IP issues determine whether IP is in multiple IP segments

Determines whether the sum of any two numbers in an array two is a given value

The realization of optimistic lock and pessimistic lock

Synchronized realization principle

The difficulties you have encountered in the project and how to solve them

The highlights of the project that you've done better

The difference between Message Queuing broadcast mode and publish/Subscribe mode

Producer Consumer Code implementation

Deadlock Code Implementation

Thread pool: parameters, function of each parameter, comparison of several different thread pools, blocking the use of queues, rejecting policies

Future and Listenablefuture asynchronous callback related

Algorithm correlation: To determine whether two digits can be found from the array and for the given value, randomly generated 1~10000 and put into the array, to find the array of the largest and the binary lookup algorithm and time complex calculation 3, other

Algorithm: Common sort algorithm, binary lookup, linked list correlation, array correlation, string correlation, tree correlation, etc.

Common serialization protocols and their pros and cons

Memcached memory principle, why is block based storage

What needs to be prepared to build an RPC

If a full GC appears frequently on an online server, how to troubleshoot

If a moment on the line machine suddenly changed a lot, the service can not carry, how to solve

Implementation of Lur algorithm

Linkedhashmap realize LRU

Define the data structure of the stack, implement a min function in that type that can find the minimum stack element

The solution of mass data processing

Evolution of the reactor model

Blocking, non-blocking, synchronous, asynchronous differences

Collection of the Child interface

JVM Tuning Related

Zookeeper related, node type, how to implement service discovery and service registration

Nginx load balancing, let you achieve load balancing, how to achieve

Linux commands, awk, cat, sort, cut, grep, Uniq, WC, top, etc.

Stress test related, how to analyze, single interface pressure measurement and multi-case pressure measurement

What do you think your little is and what is your disadvantage

The implementation principle of spring MVC

Netty Bottom implementation, IO Model, channelpipeline implementation and principle

Caching Design and optimization

Caching and database consistency synchronization solutions

The system architecture of your project, talk about the overall implementation

Usage Scenarios for message queues

The difference between ActiveMQ, RABBITMQ and Kafka

JVM memory allocation policies and timing of garbage collection

JVM garbage collection policies and the actual lifecycle of objects

The above content for the recent interview summary. Subsequent updates will continue if new content is available.

Preface

Plan to change a job, nearly one months interviewed a lot of companies, the following will be some interview experience and thinking to share. Another school recruit is about to start, for students in the school to provide some experience for reference, hoping to find a satisfactory job.

Just started the interview of several companies, is a variety of blows, is a crazy ask, the results of the answer to the problem of a few, began to their own confidence caused a certain impact, and later adjusted, and restored to a state of full confidence. On the one hand, work experience is limited, on the other hand, there is no systematic review. The latter occupies the main position. So how to review good technical points is necessary to find a good job (but also a large part of the luck component in it). For fresh students, because of the limited skills in school, so in the beginning of the interview after several companies, the feeling of shock is very normal, at this time must not lose heart, from each interview to sum up their own shortcomings, not to make up for their knowledge, then you will find that the job search is not so difficult, Ask to ask about those things.

I do not specifically say which company's interview, that is not good for the company. First of all, summarize some of the most important points of knowledge; Then, analyze some of the knowledge points, and finally, list the face questions and the pen questions that can be recalled. Hope to help you.

Key Knowledge

Because of the Java developers I interviewed for Java, the key things to understand are:

JVM memory management mechanism and garbage collection mechanism (basically every interview will ask, must be thorough)

JVM Memory tuning (understand what's going on, generally do more with the project process)

Design pattern (familiar with common design patterns of the application scene, will draw class diagram, it is not possible to recite a few also useful)

Multithreading (ask each time, including thread and process, thread state, thread concurrent operation, etc., need to be reviewed in depth)

Java Collection Class Framework (understanding the relationships and differences between frames, HASHMAP, ArrayList, HashSet, and so on, where the HASHMAP storage mechanism is almost always asked)

Java Exception handling mechanisms (classification of exceptions, common exceptions, Try catch finally used)

JVM running mechanism (understanding how the JVM works)

Linux Basics (There are some requirements for Linux in the interview written test, it is advisable to build a Linux virtual machine, and practice the commonly used commands)

data structures and algorithms

The common sorting algorithm does not say, need to understand its principles and write code, and time space complexity also need to know

Queues, stacks: need to understand their access structure and can be used in some scenarios

Binary tree: Tree traversal, tree depth, hierarchical output, balanced binary tree, reverse print tree, etc.

Linked list: Reverse order, merge two orderly linked list, determine whether the linked list is also ring, the chain list of the reciprocal k elements, etc.

String: KMP algorithm, dynamic programming (this is the focus, need to understand the dynamic programming, common problems are: the longest palindrome string, solve the longest common substring, etc.)

Mass data processing: Now a lot of big companies will ask a large number of processing, so need to master common processing methods, such as Bit-map, divide and conquer, hash map, etc., you can see the relevant articles Baidu, deepen understanding

Database Related (database is the focus of the interview, each company will ask)

Basic database CRUD operations familiar with the ability to write the required SQL statements from a table

transactions, zero tables, indexes, table locks, row and column locks, views, stored procedures, and so on, should be thoroughly understood

Internet companies deal with a large amount of data, so it is necessary to database optimization and large data processing to understand and familiar with

It is recommended to look at the books and materials related to non relational databases such as NoSQL and Redis.

Open Source Framework

Open source frameworks like SSH are rarely asked during the interview process, but it is also necessary to understand how SSH works and how to use it. Interview is the basis of the main study, so more inclined to study the data structure, algorithms, databases, Java basics, and so on. Therefore, if you have limited time, you can focus on basic knowledge of learning and review, if you have ample time, you can learn and review the open source framework related knowledge. For the open source framework: It is best to look at the source code, the advantages of their own is very large.

Personal Advice

The above detailed list and analysis of the recent interview process problems, because the time is long, can not all recall, but the overall difference is not big. For an interview, some personal advice:

(1) The mentality should put well, cannot be anxious. Do not see people get an offer, they do not have the heart pressure, in fact, who can find the work, to see satisfaction is not satisfied, so worry is no use.

(2) The body is very important. Do not stay up all night to review, study, the body to bring down the candle. Keep a good sleep.

(3) Good at summarizing the interview problems. Every written test, after the interview, need to be summed up, will not be their knowledge points must be clear, if not clear, next time there may be asked. In fact, the process of looking for a job is to accumulate knowledge of the process, so good at summarizing is very important.

(4) Do not blindly delivery resumes. Do not see large companies on delivery, do not send their own do not want to go to the city, that is in the blind toss, the company even if you, you do not go, you might as well put the time in their own places to go.

(5) Review needs to continue. Because the memory will be forgotten, so review process, need to be repeated, while understanding one side of memory, to close your eyes can see the knowledge of the architecture.

Finally, hope to find a job friends can find a satisfactory job. The following specific list of the common knowledge of the interview, for your reference, I hope to help you.

main detailed knowledge points A survey of common algorithms

Bubble sort

Quick Sort

Insert Sort

Hill sort

Merge sort

Heap Sort

Bucket sort

Dynamic programming

Longest common substring

The longest palindrome string

Maximum k value of array

The sum of the maximum contiguous array of numbers

Left rotation string

String matching algorithm: KMP algorithm

Two-point Search

Linked list

Reverse order of single linked list

Two sequential single linked list merging

Two single linked lists intersect

The node at the intersection

Number of reciprocal K of single linked list

Single linked list sorting

Stacks and Queues