java面试题（java面试题汇总）

精选文章1

21小时28分钟前整理

Java常见数据结构面试题（带答案）

1.栈和队列的共同特点是（只允许在端点处插入和删除元素）
4.栈通常采用的两种存储结构是（线性存储结构和链表存储结构）
5.下列关于栈的叙述正确的是（D）
     A.栈是非线性结构B.栈是一种树状结构C.栈具有先进先出的特征D.栈有后进先出的特征
6.链表不具有的特点是（B）A.不必事先估计存储空间       B.可随机访问任一元素
C.插入删除不需要移动元素      D.所需空间与线性表长度成正比
7.用链表表示线性表的优点是（便于插入和删除操作）
8.在单链表中，增加头结点的目的是（方便运算的实现）
9.循环链表的主要优点是（从表中任一结点出发都能访问到整个链表）
10.线性表L＝（a1,a2,a3,……ai,……an），下列说法正确的是（D）
     A.每个元素都有一个直接前件和直接后件   B.线性表中至少要有一个元素
     C.表中诸元素的排列顺序必须是由小到大或由大到小
     D.除第一个和最后一个元素外，其余每个元素都有一个且只有一个直接前件和直接后件
11.线性表若采用链式存储结构时，要求内存中可用存储单元的地址（D）
A.必须是连续的 B.部分地址必须是连续的C.一定是不连续的 D.连续不连续都可以
12.线性表的顺序存储结构和线性表的链式存储结构分别是（随机存取的存储结构、顺序存取的存储结构）
13.树是结点的集合，它的根结点数目是（有且只有1）
14.在深度为5的满二叉树中，叶子结点的个数为（31）
15.具有3个结点的二叉树有（5种形态）
16.设一棵二叉树中有3个叶子结点，有8个度为1的结点，则该二叉树中总的结点数为（13）
17.已知二叉树后序遍历序列是dabec，中序遍历序列是debac，它的前序遍历序列是（cedba）
18.已知一棵二叉树前序遍历和中序遍历分别为ABDEGCFH和DBGEACHF，则该二叉树的后序遍历为（DGEBHFCA）
19.若某二叉树的前序遍历访问顺序是abdgcefh，中序遍历访问顺序是dgbaechf，则其后序遍历的结点访问顺序是（gdbehfca）
20.数据库保护分为：安全性控制、完整性控制、并发性控制和数据的恢复。

1. 在计算机中，算法是指（解题方案的准确而完整的描述）
2.在下列选项中，哪个不是一个算法一般应该具有的基本特征（无穷性）
说明：算法的四个基本特征是：可行性、确定性、有穷性和拥有足够的情报。
3. 算法一般都可以用哪几种控制结构组合而成（顺序、选择、循环）
4.算法的时间复杂度是指（算法执行过程中所需要的基本运算次数）
5. 算法的空间复杂度是指（执行过程中所需要的存储空间）     
6. 算法分析的目的是（分析算法的效率以求改进）     
7. 下列叙述正确的是（C）
A．算法的执行效率与数据的存储结构无关
B．算法的空间复杂度是指算法程序中指令（或语句）的条数
C．算法的有穷性是指算法必须能在执行有限个步骤之后终止
D．算法的时间复杂度是指执行算法程序所需要的时间
8.数据结构作为计算机的一门学科，主要研究数据的逻辑结构、对各种数据结构进行的运算，以及（数据的存储结构）
9. 数据结构中，与所使用的计算机无关的是数据的（C）
A．存储结构   B．物理结构     C．逻辑结构     D．物理和存储结构
10. 下列叙述中，错误的是（B）
A．数据的存储结构与数据处理的效率密切相关
B．数据的存储结构与数据处理的效率无关
C．数据的存储结构在计算机中所占的空间不一定是连续的
D．一种数据的逻辑结构可以有多种存储结构
11. 数据的存储结构是指（数据的逻辑结构在计算机中的表示）
12. 数据的逻辑结构是指（反映数据元素之间逻辑关系的数据结构）
13. 根据数据结构中各数据元素之间前后件关系的复杂程度，一般将数据结构分为（线性结构和非线性结构）
14. 下列数据结构具有记忆功能的是（C）A．队列B．循环队列C．栈D．顺序表
15. 下列数据结构中，按先进后出原则组织数据的是（B）
A．线性链表   B．栈            C．循环链表        D．顺序表
16. 递归算法一般需要利用（队列）实现。
17. 下列关于栈的叙述中正确的是（D）A．在栈中只能插入数据B．在栈中只能删除数据
C．栈是先进先出的线性表            D．栈是先进后出的线性表
20. 由两个栈共享一个存储空间的好处是（节省存储空间，降低上溢发生的机率）

21. 应用程序在执行过程中，需要通过打印机输出数据时，一般先形成一个打印作业，将其存放在硬盘中的一个指定（队列）中，当打印机空闲时，就会按先来先服务的方式从中取出待打印的作业进行打印。
22.下列关于队列的叙述中正确的是（C）A．在队列中只能插入数据 B．在队列中只能删除数据   C．队列是先进先出的线性表            D．队列是先进后出的线性表
23.下列叙述中，正确的是（D）A．线性链表中的各元素在存储空间中的位置必须是连续的
B．线性链表中的表头元素一定存储在其他元素的前面 C．线性链表中的各元素在存储空间中的位置不一定是连续的，但表头元素一定存储在其他元素的前面 D．线性链表中的各元素在存储空间中的位置不一定是连续的，且各元素的存储顺序也是任意的
24.下列叙述中正确的是（A）A．线性表是线性结构      B．栈与队列是非线性结构
C．线性链表是非线性结构                                 D．二叉树是线性结构
25. 线性表L＝（a1,a2,a3,……ai,……an），下列说法正确的是（D）
A．每个元素都有一个直接前件和直接后件      B．线性表中至少要有一个元素
C．表中诸元素的排列顺序必须是由小到大或由大到小D．除第一个元素和最后一个元素外，其余每个元素都有一个且只有一个直接前件和直接后件
26.线性表若采用链式存储结构时，要求内存中可用存储单元的地址（连续不连续都可以）     
27. 链表不具有的特点是（B）A．不必事先估计存储空间            B．可随机访问任一元素
C．插入删除不需要移动元素            D．所需空间与线性表长度成正比
28. 非空的循环单链表head的尾结点（由p所指向），满足（p->next=head）
29.与单向链表相比，双向链表的优点之一是（更容易访问相邻结点）     
30. 在（D）中，只要指出表中任何一个结点的位置，就可以从它出发依次访问到表中其他所有结点。A．线性单链表            B．双向链表            C．线性链表            D．循环链表
31. 以下数据结构属于非线性数据结构的是（C）A．队列      B．线性表C．二叉树      D．栈
32.树是结点的集合，它的根结点数目是（有且只有1）
33.具有3个结点的二叉树有（5种形态）     
34. 在一棵二叉树上第8层的结点数最多是（128）注：2K-1
35. 在深度为5的满二叉树中，叶子结点的个数为（16）注：2n-1
36. 在深度为5的满二叉树中，共有（31）个结点。注：2n－1
37.设一棵完全二叉树共有699个结点，则在该二叉树中的叶子结点数为（350）
说明：完全二叉树总结点数为N，若N为奇数，则叶子结点数为（N+1）/2；若N为偶数，则叶子结点数为N/2。
38. 设有下列二叉树，对此二叉树中序遍历的结果是（B）
A．ABCDEF     
B．DBEAFC
C．ABDECF     
D．DEBFCA
39.已知二叉树后序遍历序列是dabec，中序遍历序列debac，它的前序遍历序列是（cedba）     
40. 已知一棵二叉树前序遍历和中序遍历分别为ABDEGCFH和DBGEACHF，则该二叉树的后序遍历为（DGEBHFCA）

41.若某二叉树的前序遍历访问顺序是abdgcefh，中序遍历访问顺序是dgbaechf，则其后序遍历的结点访问顺序是（gdbehfca）
42. 串的长度是（串中所含字符的个数）     
43.设有两个串p和q，求q在p中首次出现位置的运算称做（模式匹配）
44. N个顶点的连通图中边的条数至少为（N-1）
45.N个顶点的强连通图的边数至少有（N）
46.对长度为n的线性表进行顺序查找，在最坏情况下所需要的比较次数为（N）
47. 最简单的交换排序方法是（冒泡排序）     
48.假设线性表的长度为n，则在最坏情况下，冒泡排序需要的比较次数为（n(n-1)/2）     
49. 在待排序的元素序列基本有序的前提下，效率最高的排序方法是（冒泡排序）
50. 在最坏情况下，下列顺序方法中时间复杂度最小的是（堆排序）     
51. 希尔排序法属于（插入类排序）
52. 堆排序法属于（选择类排序）
53. 在下列几种排序方法中，要求内存量最大的是（归并排序）     
54. 已知数据表A中每个元素距其最终位置不远，为节省时间，应采用（直接插入排序）
55. 算法的基本特征是可行性、确定性、有穷性   和拥有足够的情报。

1.一个算法通常由两种基本要素组成：一是对数据对象的运算和操作，二是算法的控制结构。
1. 算法的复杂度主要包括时间复杂度和空间复杂度。
2. 实现算法所需的存储单元多少和算法的工作量大小分别称为算法的空间复杂度和时间复杂度。
3.所谓数据处理是指对数据集合中的各元素以各种方式进行运算，包括插入、删除、查找、更改等运算，也包括对数据元素进行分析。
4.数据结构是指相互有关联的数据元素的集合。
5.数据结构分为逻辑结构与存储结构，线性链表属于存储结构。
6.数据结构包括数据的逻辑结构和数据的存储结构。
7. 数据结构包括数据的逻辑结构、数据的存储结构以及对数据的操作运算。
8.数据元素之间的任何关系都可以用前趋和后继关系来描述。
9.数据的逻辑结构有线性结构和非线性结构两大类。
10.常用的存储结构有顺序、链接、索引等存储结构。
11. 顺序存储方法是把逻辑上相邻的结点存储在物理位置   相邻的存储单元中。
12. 栈的基本运算有三种：入栈、退栈与读栈顶元素。
13. 队列主要有两种基本运算：入队运算与退队运算。
14. 在实际应用中，带链的栈可以用来收集计算机存储空间中所有空闲的存储结点，这种带链的栈称为可利用栈。
15.栈和队列通常采用的存储结构是链式存储和顺序存储   。
16.当线性表采用顺序存储结构实现存储时，其主要特点是逻辑结构中相邻的结点在存储结构中仍相邻。
17. 循环队列主要有两种基本运算：入队运算与退队运算。每进行一次入队运算，队尾指针就进1 。
18.当循环队列非空且队尾指针等于对头指针时，说明循环队列已满，不能进行入队运算。这种情况称为上溢   。
19.当循环队列为空时，不能进行退队运算，这种情况称为下溢。
20. 在一个容量为25的循环队列中，若头指针front=16，尾指针rear=9，则该循环队列中共有 18 个元素。注：当rear<front时，元素个数＝总容量－（front－rear）；
当rear>front时，元素个数＝rear－front。

1.判断链表是否存在环型链表问题：判断一个链表是否存在环，例如下面这个链表就存在一个环：
例如N1->N2->N3->N4->N5->N2就是一个有环的链表，环的开始结点是N5这里有一个比较简单的解法。设置两个指针p1，p2。每次循环p1向前走一步，p2向前走两步。直到p2碰到NULL指针或者两个指针相等结束循环。如果两个指针相等则说明存在环。

struct link 
{
 int data;
  link* next;
};
bool IsLoop(link* head)
{
  link* p1=head, *p2 = head;
  if (head ==NULL || head->next ==NULL) 
  {
   return false;
  }
  do{
  p1= p1->next;
  p2 = p2->next->next;
  } while(p2 && p2->next && p1!=p2);  
  if(p1 == p2)
   return true;
  else
   return false;
}

2,链表反转单向链表的反转是一个经常被问到的一个面试题，也是一个非常基础的问题。比如一个链表是这样的： 1->2->3->4->5 通过反转后成为5->4->3->2->1。最容易想到的方法遍历一遍链表，利用一个辅助指针，存储遍历过程中当前指针指向的下一个元素，然后将当前节点元素的指针反转后，利用已经存储的指针往后面继续遍历。源代码如下：

struct linka {
  int data;
  linka* next;
};
void reverse(linka*& head)
{
  if(head ==NULL)
  return;
  linka*pre, *cur, *ne;
  pre=head;
  cur=head->next;
  while(cur)
  {
  ne = cur->next;
  cur->next = pre;
  pre = cur;
  cur = ne;
  }
  head->next = NULL;
  head = pre;
}

还有一种利用递归的方法。这种方法的基本思想是在反转当前节点之前先调用递归函数反转后续节点。源代码如下。不过这个方法有一个缺点，就是在反转后的最后一个结点会形成一个环，所以必须将函数的返回的节点的next域置为NULL。因为要改变head指针，所以我用了引用。算法的源代码如下：

linka* reverse(linka* p,linka*& head)
{
  if(p == NULL || p->next == NULL)
  {
  head=p;
  return p;
  }
  else
  {
  linka* tmp = reverse(p->next,head);
  tmp->next = p;
  return p;
  }
}

3,判断两个数组中是否存在相同的数字给定两个排好序的数组，怎样高效得判断这两个数组中存在相同的数字？
这个问题首先想到的是一个O(nlogn)的算法。就是任意挑选一个数组，遍历这个数组的所有元素，遍历过程中，在另一个数组中对第一个数组中的每个元素进行binary search。用C++实现代码如下：

bool findcommon(int a[],int size1,int b[],int size2)
{
  int i;
  for(i=0;i<size1;i++)
  {
  int start=0,end=size2-1,mid;
  while(start<=end)
  {
   mid=(start+end)/2;
   if(a[i]==b[mid])
    return true;
   else if (a[i]<b[mid])
    end=mid-1;
   else
    start=mid+1;
  }
  }
  return false;
}

后来发现有一个 O(n)算法。因为两个数组都是排好序的。所以只要一次遍历就行了。首先设两个下标，分别初始化为两个数组的起始地址，依次向前推进。推进的规则是比较两个数组中的数字，小的那个数组的下标向前推进一步，直到任何一个数组的下标到达数组末尾时，如果这时还没碰到相同的数字，说明数组中没有相同的数字。

bool findcommon2(int a[], int size1, int b[], int size2)
{
  int i=0,j=0;
  while(i<size1 && j<size2)
  {
  if(a[i]==b[j])
    return true;
  if(a[i]>b[j])
   j++;
  if(a[i]<b[j])
   i++;
  }
  return false;
}

4,最大子序列问题：
给定一整数序列A1， A2，... An （可能有负数），求A1~An的一个子序列Ai~Aj，使得Ai到Aj的和最大
例如：
整数序列-2, 11, -4, 13, -5, 2, -5, -3, 12, -9的最大子序列的和为21。
对于这个问题，最简单也是最容易想到的那就是穷举所有子序列的方法。利用三重循环，依次求出所有子序列的和然后取最大的那个。当然算法复杂度会达到O(n^3)。显然这种方法不是最优的，下面给出一个算法复杂度为O(n)的线性算法实现，算法的来源于Programming Pearls一书。在给出线性算法之前，先来看一个对穷举算法进行优化的算法，它的算法复杂度为O(n^2)。其实这个算法只是对对穷举算法稍微做了一些修改：其实子序列的和我们并不需要每次都重新计算一遍。假设Sum(i, j)是A[i] ... A[j]的和，那么Sum(i, j+1) = Sum(i, j) + A[j+1]。利用这一个递推，我们就可以得到下面这个算法：

int max_sub(int a[],int size)
{
  int i,j,v,max=a[0];
  for(i=0;i<size;i++)
  {
  v=0;
  for(j=i;j<size;j++)
  {
   v=v+a[j];//Sum(i, j+1) = Sum(i, j) + A[j+1]
   if(v>max)
    max=v;
  }
  }
  return max;
}

那怎样才能达到线性复杂度呢？这里运用动态规划的思想。先看一下源代码实现：

int max_sub2(int a[], int size)
{
  int i,max=0,temp_sum=0;
  for(i=0;i<size;i++)
  {
  temp_sum+=a[i];
  if(temp_sum>max)
   max=temp_sum;
  else if(temp_sum<0)
   temp_sum=0;
  }
  return max;
}

6,按单词反转字符串并不是简单的字符串反转，而是按给定字符串里的单词将字符串倒转过来，就是说字符串里面的单词还是保持原来的顺序，这里的每个单词用空格分开。
如果只是简单的将所有字符串翻转的话，可以遍历字符串，将第一个字符和最后一个交换，第二个和倒数第二个交换，依次循环。其实按照单词反转的话可以在第一遍遍历的基础上，再遍历一遍字符串，对每一个单词再反转一次。这样每个单词又恢复了原来的顺序。

char* reverse_word(const char* str)
{
  int len = strlen(str);
  char* restr = new char[len+1];
  strcpy(restr,str);
  int i,j;
  for(i=0,j=len-1;i<j;i++,j--)
  {
  char temp=restr[i];
  restr[i]=restr[j];
  restr[j]=temp;
  }
  int k=0;
  while(k<len)
  {
  i=j=k;
  while(restr[j]!=' ' && restr[j]!='' )
   j++;
  k=j+1;
  j--;
  for(;i<j;i++,j--)
  {
   char temp=restr[i];
   restr[i]=restr[j];
   restr[j]=temp;
  }
  }
  return restr;
}

如果考虑空间和时间的优化的话，当然可以将上面代码里两个字符串交换部分改为异或实现。

例如将
               

 char temp=restr[i];
  restr[i]=restr[j];
  restr[j]=temp;

改为
        

 restr[i]^=restr[j];
   restr[j]^=restr[i];
  restr[i]^=restr[j];
 

7,字符串反转我没有记错的话是一道MSN的笔试题，网上无意中看到的，拿来做了一下。题目是这样的，给定一个字符串，一个这个字符串的子串，将第一个字符串反转，但保留子串的顺序不变。例如：

输入：第一个字符串: "This is mianwww's Chinese site: http://www.mianwww.com.cn/cn"

子串: "mianwww"

输出： "nc/nc.moc.mianwww.www//:ptth :etis esenihC s'mianwww si sihT"

一般的方法是先扫描一边第一个字符串，然后用stack把它反转，同时记录下子串出现的位置。然后再扫描一遍把记录下来的子串再用stack反转。我用的方法是用一遍扫描数组的方法。扫描中如果发现子串，就将子串倒过来压入堆栈。

最后再将堆栈里的字符弹出，这样子串又恢复了原来的顺序。源代码如下：
#include <iostream>
#include <cassert>
#include <stack>
using namespace std;
//reverse the string 's1' except the substring 'token'.
const char* reverse(const char* s1, const char* token)
{
  assert(s1 && token);
  stack<char> stack1;
  const char* ptoken = token, *head = s1, *rear = s1;
  while (*head != '')
  {
    while(*head!= '' && *ptoken == *head)
    {
    ptoken++;
    head++;
    }
    if(*ptoken == '')//contain the token
    {
    const char* p;
    for(p=head-1;p>=rear;p--)
      stack1.push(*p);
 
    ptoken = token;
    rear = head;
    }
    else
    {
    stack1.push(*rear);
     head=++rear;
    ptoken = token;
    }
  }
  char * return_v = new char[strlen(s1)+1];
  int i=0;
  while(!stack1.empty())
  {
    return_v[i++] = stack1.top();
    stack1.pop();
  }
  return_v[i]='';
  return return_v;
}
int main(int argc, char* argv[])
{cout<<"This is mianwww 's Chinese site: http://www.mianwww.com.cn/cn
";
  cout<<reverse("This is mianwww's Chinese site: http://www. mianwww.com.cn/cn"," mianwww ");
  return 0;
}

 8, 删除数组中重复的数字问题：一个动态长度可变的数字序列，以数字0为结束标志，要求将重复的数字用一个数字代替，例如：

将数组 1,1,1,2,2,2,2,2,7,7,1,5,5,5,0 转变成1,2,7,1,5,0 问题比较简单，要注意的是这个数组是动态的。所以避免麻烦我还是用了STL的vector。

#include <iostream>
#include <vector>
using namespace std;
//remove the duplicated numbers in an intger array, the array was end with 0;
//e.g. 1,1,1,2,2,5,4,4,4,4,1,0 --->1,2,5,4,1,0
void static remove_duplicated(int a[], vector<int>& _st)
{
  _st.push_back(a[0]);
  for(int i=1;_st[_st.size()-1]!=0;i++)
  {
    if(a[i-1]!=a[i])
    _st.push_back(a[i]);
  }
}

当然如果可以改变原来的数组的话，可以不用STL，仅需要指针操作就可以了。下面这个程序将修改原来数组的内容。

void static remove_duplicated2(int a[])
{
  if(a[0]==0 || a==NULL)
    return;
  int insert=1,current=1;
  while(a[current]!=0)
  {
    if(a[current]!=a[current-1])
    {
    a[insert]=a[current];
    insert++;
    current++;
    }
    else
    current++;
  }
  a[insert]=0;
}

     
9,如何判断一棵二叉树是否是平衡二叉树问题：判断一个二叉排序树是否是平衡二叉树解决方案：
根据平衡二叉树的定义，如果任意节点的左右子树的深度相差不超过1，那这棵树就是平衡二叉树。
首先编写一个计算二叉树深度的函数，利用递归实现。

template<typename T>
static int Depth(BSTreeNode<T>* pbs)
{
  if (pbs==NULL)
    return 0;
  else
  {
    int ld = Depth(pbs->left);
    int rd = Depth(pbs->right);
    return 1 + (ld >rd ? ld : rd);
  }
}

下面是利用递归判断左右子树的深度是否相差1来判断是否是平衡二叉树的函数：

template<typename T>
static bool isBalance(BSTreeNode<T>* pbs)
{
  if (pbs==NULL) 
    return true;
  int dis = Depth(pbs->left) - Depth(pbs->right);
  if (dis>1 || dis<-1 )
    return false;
  else
    return isBalance(pbs->left) && isBalance(pbs->right);
4.abstract class Something {
 private abstract String doSomething ();
 }

该段代码有错吗？
答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract method封锁起来呢? (同理，abstract method前不能加final)。
5.看看下面的代码段错在哪里？

public class Something {
void doSomething () {
private String s = “”;
int l = s.length();
}
}

答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量
(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。
6. 下面该段代码是否有错，若是有错错在哪里？

abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}

答案: 错。abstract method必须以分号结尾，且不带花括号。

精选文章2

14小时21分钟前整理

阿里的一道Java并发面试题详解

题目

我个人一直认为： 网络、并发相关的知识，相对其他一些编程知识点更难一些，主要是不好调试并且涉及内容太多 ！

所以今天就取一篇并发相关的内容分享下，我相信大家认真看完会有收获的。

大家可以先看看这个问题，看看这个是否有问题呢？ 那里有问题呢？

如果你在这个问题上面停留超过5s的话，那么表示你对这块某些知识还有点模糊，需要再巩固下，下面我们一起来分析下！

结论
多线程并发的同时进行set、get操作，A线程调用set方法，B线程并不一定能对这个改变可见！！！

分析
这个类非常简单，里面有一个属性，有2个方法：get、set方法，一个用来设置属性值，一个用来获取属性值，在设置属性方法上面加了synchronized。

隐式信息： 多线程并发的同时进行set、get操作，A线程调用set方法，B线程可以里面感知到吗？？？

说到这里，问题就变成了synchronized在刚刚说的上下文下面能否保证可见性！！！

关键词synchronized的用法

• 指定加锁对象:对给定对象加锁，进入同步代码前需要获得给定对象的锁。
• 直接作用于实例方法:相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。
• 直接作用于静态方法:相当于对当前类加锁，进入同步代码前要获得当前类的锁。
  

synchronized它的工作就是对需要同步的代码加锁，使得每一次只有一个线程可以进入同步块（其实是一种悲观策略）从而保证线程之间得安全性。

从这里我们可以知道，我们需要分析的属于第二类情况，也就是说多个线程如果同时进行set方法的时候，由于存在锁，所以会一个一个进行set操作，并且是线程安全的，但是get方法并没有加锁，表示假如A线程在进行set的同时B线程可以进行get操作。并且可以多个线程同时进行get操作，但是同一时间最多只能有一个set操作。

Java 内存模型 happens-before原则

JSR-133 内存模型使用 happens-before 的概念来阐述操作之间的内存可见性。在 JMM 中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须要存在 happens-before 关系。这里提到的两个操作既可以是在一个线程之内，也可以是在不同线程之间。

与程序员密切相关的 happens-before 规则如下：

• 程序顺序规则：一个线程中的每个操作，happens-before 于该线程中的任意后续操作。
• 监视器锁规则：对一个监视器的解锁，happens-before 于随后对这个监视器的加锁。
• volatile 变量规则：对一个 volatile 域的写，happens-before 于任意后续对这个 volatile 域的读。
• 传递性：如果 A happens-before B，且 B happens-before C，那么 A happens-before C。

注意，两个操作之间具有 happens-before 关系，并不意味着前一个操作必须要在后一个操作之前执行！happens-before 仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前（the first is visible to and ordered before the second）。

其中有监视器锁规则：对一个监视器的解锁，happens-before 于随后对这个监视器的加锁。这一条，仅仅只是针对synchronized的set方法，而对于get并没有这方面的说明。

其实在这种上下文下面一个synchronized的set方法，一个普通的get方法，a线程调用set方法，b线程并不一定能对这个改变可见！

volatile

volatile可见性

前面happens-before原则就提到：volatile 变量规则：对一个 volatile 域的写，happens-before 于任意后续对这个 volatile 域的读。 volatile从而保证了多线程下的可见性！！！

volatile 禁止内存重排序

下面是 JMM 针对编译器制定的 volatile 重排序规则表：

为了实现 volatile 的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。

下面是基于保守策略的 JMM 内存屏障插入策略：

• 在每个 volatile 写操作的前面插入一个 StoreStore 屏障。
• 在每个 volatile 写操作的后面插入一个 StoreLoad 屏障。
• 在每个 volatile 读操作的后面插入一个 LoadLoad 屏障。
• 在每个 volatile 读操作的后面插入一个 LoadStore 屏障。

下面是保守策略下，volatile 写操作 插入内存屏障后生成的指令序列示意图：

下面是在保守策略下，volatile 读操作 插入内存屏障后生成的指令序列示意图：

上述 volatile 写操作和 volatile 读操作的内存屏障插入策略非常保守。在实际执行时，只要不改变 volatile 写-读的内存语义，编译器可以根据具体情况省略不必要的屏障。

双重检查锁实现单例中就需要用到这个特性！！！

模拟

通过上面的分析，其实这个题目涉及到的内容都提到了，并且进行了解答。

虽然你知道的原因，但是想模拟并不是一件容易的事情！，下面我们来模拟看看效果：

public class ThreadSafeCache {
int result;
public int getResult() {
return result;
}
public synchronized void setResult(int result) {
this.result = result;
}
public static void main(String[] args) {
ThreadSafeCache threadSafeCache = new ThreadSafeCache();
for (int i = 0; i < 8; i++) {
new Thread(() -> {
int x = 0;
while (threadSafeCache.getResult() < 100) {
x++;
}
System.out.println(x);
}).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
threadSafeCache.setResult(200);
}
}

效果：

程序会一直卡在这边不动，表示set修改的200，get方法并不可见！！！

添加volatile 关键词观察效果

其实例子中synchronized关键字可以去掉，仅仅用volatile即可。

效果：

代码很快正常结束了！

结论

多线程并发的同时进行set、get操作，A线程调用set方法，B线程并不一定能对这个改变可见！！！，上面的代码中，如果对get方法也加synchronized也是可见的，还是happens-before的监视器锁规则：对一个监视器的解锁，happens-before 于随后对这个监视器的加锁。只是volatile比synchronized更轻量级，所以本例直接用volatile。但是对于符合非原子操作i++这里还是不行的还是需要synchronized。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持码农之家。

精选文章3

24小时19分钟前整理

详解java面试题中的i++和++i

代码如下所示：

public class TestPlusPlus{
  public static void main(String[] args){
    int k = addAfterReturn(10);
    System.out.println(k);    //输出 10
    int k1 = addbeforeReturn(10);
    System.out.println(k1); //输出11
  }
  public static int addbeforeReturn(int i){
    return ++i;
  }
  public static int addAfterReturn(int i){
    return i++;
  }
}

我们从字节码层面来看，

addAfterReturn的字节码如下：

0: iload_0
1: iinc     0, 1
4: ireturn

很简单， iload_0 表示将局部变量表中索引为0的元素的值放到栈顶。所以讲传入的i的值放入到栈顶，其次 iinc 0,1 表示将局部变量表中

索引为0的元素进行加1，最后是 ireturn 将栈顶的int值放入到调用者栈桢的栈中。(这里的栈都是操作数栈)

因此其实 iinc 0,1 并没有实际影响到返回的值，所以返回依旧是10.

同理addBeforeReturn字节码如下：

0: iinc     0, 1
3: iload_0
4: ireturn

这里就留给大家自己分析，其实很明显可以看出，这里是先进行递增然后才入栈了。所以返回的值其实是递增了。

现在让我们来做一道我自己改过的面试题。

public class TestPlusPlus2{
  static{
    x=5;
    int y = 10;
  }
  static int x,y;
  public static void main(String args[]){
    x--;
    myMethod( );
    System.out.println(x+y+ ++x);
  }
  public static void myMethod( ){
    y=x++ + ++x;
  }
}

知道答案了吗？运行一下，正确答案是23.

如果你真正理解了上面的，这道题也很简单，首先是在执行main之前，知道x,y的值，这里有点牵扯到类加载机制，类加载的准备阶段会为static变量赋值为该类型的零值。int的话就对应0喽，在类的初始化阶段，根据代码顺序收集类中的静态块和静态变量赋值行为进行生成 方法。因此该测验中,x = 5, y = 0；

继续分析，在执行myMethod之前执行了 x--' ,所以x = 4,y = 0, myMethod 中 y = x++ + ++x;

x++在执行后面的加操作之前是不会加1的，就跟 return i++ 在return之后才会进行i++,(这里的return 你可以理解为上面的iload入栈操作,而不是iretrun这条指令)，所以第一个加数为4，但是这里需要注意的是在执行++x之前，递增已经对实际的x生效了，即x已经为5了，所以第二个加数为 ++i 为6，从而y=10.

随后就很简单了 x+y+ ++x 为 6+10+7 为23。幸运的是如果你能看懂字节码，你可以翻译该代码的字节码，用字节码来验算，也可以发现这样的结果。

再来看一道例子 ,是群里大佬提供的。我觉得也很针对基础。

public static int plus(int i){
  try{
    ++i;
    System.out.println("try");
    return i++;
  }finally{
    System.out.println("finally");
    i++;
     //return i;
  }
}
public static void main(String[] args){
  System.out.println(Test1.plus(5));
}

你能想到最后输出的是多少吗?如果去掉注释呢，这也就是为什么finally块里不要return的原因。因为无论对错，可能永远都返回某个值。

总结

以上所述是小编给大家介绍的详解java面试题中的i++和++i，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对码农之家网站的支持！

精选文章4

9小时54分钟前整理

Java main 方法面试题的详细整理

Java main 方法面试题的详细整理

1.不用main方法如何定义一个类？

不行，没有main方法我们不能运行Java类。

在java 7之前，你可以通过使用静态初始化运行Java类。但是，从Java 7开始就行不通了。

2.main()方法需要的参数不是字符串数组？

不是的，main()方法的参数必须是字符串数组。

但是，在引进变参时，你可以将字符串类型的变参作为参数传递给main()方法。变参一定得是数组。

package com.instanceofjava;
public class MainMethod
{
public static void main(String args[])
{
}
}

3.我们能不能改变main()方法的返回类型？

不能，main()方法的返回类型只能是空。任何其它类型都是不能接受的。

package com.instanceofjava;
public class A
{
public static int main(String[] args)
{
 return 1;  //run time error : No main method found
}
}

4.main()方法为什么必须是静态的？

main()方法一定是静态的。

如果main()允许是非静态的，那么在调用main方法时，JVM就得实例化它的类。

在实例化时，还得调用类的构造函数。如果这个类的构造函数有参数，那么届时就会出现歧义。

例如，在下面的程序中，在实例化类“A”的时候，JVM传递什么参数？

package com.instanceofjava;
public class A
{
public MainMethod(int i)
{
//Constructor taking one argument
}
 public void main(String[] args)
{
//main method as non-static
}

5.我们能不能声明main()方法为非静态？

不能，main()方法必须声明为静态的，这样JVM才可以调用main()方法而无需实例化它的类。

如果从main()方法去掉“static”这个声明，虽然编译依然可以成功，但在运行时会导致程序失败。

package com.instanceofjava;
public class A
{
public void main(String[] args)
{
System.out.println("indhu");     //Run time error
}
}

6.我们能否重载main()方法？

可以，我们可以重载main()方法。一个Java类可以有任意数量的main()方法。

为了运行java类，类的main()方法应该有例如“public static void main(String[] args)”的声明。如果你对此声明做任何修改，编译也是可以成功的。但是，运行不了Java程序。你会得到运行时错误，因为找不到main方法。

package com.instanceofjava;
public class A
{
public static void main(String[] args)
{
System.out.println("Indhu");
 }
void main(int args)
{
System.out.println("Sindhu");
}
long main(int i, long d)
{
System.out.println("Saidesh");
return d;
}
}

7.我们能否声明main()方法为private或protected，或者不用访问修饰符？

不能，main()方法必须public。你不能定义main()方法为private和protected，也不能不用访问修饰符。

这是为了能让JVM访问main()方法。如果你不定义main()方法为public，虽然编译也会成功，但你会得到运行时错误，因为找不到main方法。

package com.instanceofjava;
public class A
{
private static void main(String[] args)
{
//Run time error
}
}

8.我们能否在Java中覆盖main方法？

不能，你不能在Java中覆盖main方法。这是因为main方法是静态方法，而在Java中静态方法在编译时会结合在一起，所以你在Java中不能覆盖静态方法。

9.我们能否在Java中终结main方法？

你可以在Java中终结main方法。JVM对此没问题。

10.我们能否在Java中同步main方法？

是的，main方法可以在Java中同步，synchronized修饰符允许用于main方法的声明中，这样就可以在Java中同步main方法了。

如有疑问请留言或者到本站社区交流讨论，感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

精选文章5 Java常见基础后端面试题有哪些

2小时37分钟前整理

Java后端面试题最新整理

我们学习java知识，除了要做基础的程序运行外，不可避免的要在面试中遇到一些理论的考察。有些小伙伴程序做的不错，但是理论上面有所欠缺。这里小编整理了一些常见的后端面试题，希望能对小伙伴们有所帮助，下面一起看看吧。

一、八种基本数据类型的大小，以及他们的封装类。

byte(Byte) 1 ，short(Short) 2 ,int(Integer) 4 ,long(Long) 8 ,float(Float) 4 ,double(Double)8,boolean(Boolean),char(Character)2

二、Switch能否用string做参数？

switch语句中的变量类型可以使byte，short，int，char。从jdk1.7后可以使用String类型，是通过switch中的String.hashcode将String转换成int进行判断的。

三、equals与==的区别。

==操作符是用来比较两个变量的值是否相等，即就是比较变量在内存中的存储地址是否相同，equals（）方法时String类从Object类中继承的，被用来检测两个对象的内容是否相同。

四、String s=new String(‘xyz');创建了几个object对象?

会创建一个String类型的变量s。在类加载到此处之前没有出现“xyz”字面量的话，加载此处会创建一个对应“xyz”的String常量对象。在符合规范的JVM上，执行到此处new关键字会创建一个String对象。

五、 Object有哪些公用方法？

1、clone()创建斌返回此对象的副本

2、equals()判断

3、getclass（）返回object的运行类

4、hashcode（）返回对象的哈希码值

5、notify（）唤醒正在等待对象监听器的单个进程

6、notifyAll（）唤醒正在等待对象监听器的所有进程

7、wait（）导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。

8、toString（）返回此对象的字符串表示形式

9、finalize（）当垃圾收集确定不需要该对象时，垃圾回收器调用该方法

六、Java的四种引用，强弱软虚，用到的场景。

强引用：垃圾回收器不会回收

软引用：如果内存空间足够，垃圾回收器就不会进行回收，如果内存空间不足，垃圾回收器就会进行回收

弱引用：一旦发现了只有弱引用的对象，垃圾回收器就会进行回收。

虚引用：如果发现该对象还具有虚引用，就会在回收该对象之前，吧这个虚引用加入到与之关联的引用队列中。

七、静态变量和实例变量的区别。

静态变量前要加上关键字static，实例变量则不会。

实例变量是属于某个对象的属性，必须创建了实例对象，其中的实例变量才会分配空间，才能使用这个实例变量。静态变量不属于任何的实例对象，而是属于类，也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，就会被分配空间。总之就是，静态变量不需要创建任何的对象就可以直接使用，而实例变量需要先创建实例对象才能被使用。

八、 Overload和Override的区别：

重载Overload表示的是同一个类中可以有多个相同名称的方法，但这些方法的参数列表不同，即就是参数参数或参数类型不同。重载时返回值当然可以不一样，但是如果参数列表完全一致时，不能通过返回类型不一致而实现重载，这是不可以的。

重写Override表示子类中的方法可以与父类中的方法名称和参数完全相同，通过子类创建的对象来调用这个方法时，将调用子类中定义的方法，即就是子类中的该方法将父类的该方法覆盖了。子类覆盖父类方法时只能抛比父类更少或者更小的异常。重写的方法其返回必须和被覆盖的方法返回一致。

九、抽象类和接口的区别。

抽象类可以有默认的方法进行实现，可以有构造器，可以有main方法进行运行，可以直接在该类中添加实现的方法接口没有默认的方法进行实现，没有构造器，不可以使用main方法进行运行，在接口中添加方法时需要在具体实现的类中添加方法。

十、String、StringBuffer与StringBuilder的区别。

String表示内容不可修改的字符串，StringBuffer表示内容可以修改的字符串，String覆盖了equals（）方法和hashcode（）方法，而StringBuffer没有覆盖两个方法，，所以StringBuffer对象存储到java集合类中时会出现问题。

StringBulider也表示内容可以修改的字符串，但是其线程是不安全的，运行效率高。

到此这篇关于Java后端面试题最新整理的文章就介绍到这了,更多相关Java常见基础后端面试题有哪些内容请搜索码农之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持码农之家！

精选文章6

9小时32分钟前整理

关于javascript作用域的常见面试题分享

本文主要给大家分享了关于javascript作用域面试题的相关内容，分享出来供大家参考学习，下面来一起看看吧。

一、作用域:

在了解作用域之前，首先需要明白一些基础概念：

每一个变量、函数都有其作用的范围，超出作用不得使用，这个叫做作用域。

二、全局变量、局部变量：

1.全局变量：

     （1）在全局范围内声明的变量，如var a=1;

     （2）只有赋值没有声明的值，如a=2; （注：如果a=2在函数环境中，也是全局变量）

2.局部变量：

      写入函数中的变量，叫做局部变量。

3.作用：

     （1）程序的安全。

     （2）内存的释放。

三、作用域链：

查找量的过程。先找自己局部环境有没有声明或者是函数，如果有，则查看声明有无赋值或者是函数的内容，如果没有，则向上一级查找。

四、预解析顺序：

每个程序都要做的工作，程序开始先预解析语法，标点符号是否有误，解析内存是否可容纳，解析变量……直到解析无误了，才开始按正常的流程顺序走。试想一下，如果没有预解析顺序，直接按流程顺序走，可能程序执行到最后一个函数，发现了语法错误，才开始报错，那性能要有多差啊！

顺序内容：

      1.文件内引用的<script>块依次解析，从上到下连成一片。

      2.每个script块内部的var（注意：只解析变量名，不解析值，如var a=2;将var a解析在环境的开头，并不解析后面的值，只有当程序执行到var a=2这行时，才会给变量赋值），function解析到本块的开头。

      3.依次解析每个环境，将var,function解析到环境的开头。

五、应用场景（一些常见的作用域相关的面试题）：

var a="aa";
function test(){
 alert(a);//undefined，函数执行后，在函数环境内，var a会预解析，当弹出a时，首先先找本层环境内有无声明，发现有。但是代码没有执行到赋值，所以结果是undefined。
 var a="bb";//var a会预解析在函数开头，执行到这行才进行赋值
 alert(a);//“bb”
}
test();
alert(a);//"aa" 找全局环境下的声明，找到了var a="aa"

var a="aa";
function test(){
 alert(a);//“aa”，函数执行后，在函数环境内，没有找到本层环境关于a的声明，所以开始向上一层环境查找。
 a="bb";//执行到这行开始改变全局a的量
}
test();
alert(a);//"bb" 全局环境的a在函数执行时已经被改变

function test(){ 
 b();//函数b会被预解析，因此可以调用，执行了输出1；
 var a=1;
 function b(){
  console.log(1);
  console.log(a);//undefined
  var a=2;
 }
}
test();

六、总结：

要搞清楚一个变量的作用域，重点是搞清楚预解析顺序，然后再判断作用域的范围，这些都是有套路可言：先找本层环境有无声明，有的话，看是否进行了赋值；只有声明没有执行赋值，就是undefined。没有声明也没有赋值的话，就再向上一层查找，直到找到为止。如果所有的执行环境都没有找到，那么控制台就会报错变量找不到。

函数的话就更简单了：找本层环境是否有预解析的函数，有的话即可执行。没有的话还是向上查找。

好了，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对码农之家的支持。