整型溢出 & sleep() wait() 的区别 & Java 堆排序 快速排序 计数排序

offer 110 ，109 ， 预热篇

预热：2014年5月13日

要准备看《Effective Java》

记住啦，技术是一点一点积累的，同时在简历上要写上自己会的东西，先让简历变厚，再让它变薄。

Hadoop, H2 Database Engine , Mondrian, 等，详情参见博文：亚信联创面试总结

反正无论做什么都不一定能成功，我还能怎样？只能去做但是却不一定成功。

我想做的事情，都是有几率的，我在走的路，也是只有几率能走下去，也许实现不了，也许最后还是会遗憾，这种感觉像是回到以往在大二的时候和杭杭参加那场演讲的时候那样，成功吗，只是有这样的几率，还要看你的应变。

既然无论怎样都只是增加几率，那能增加一点是一点。

看了刘未鹏的博客，接下来的路应该这样走（我不选择完全按照july或者其他人的C++路来走是因为，没有任何一个人是可以完美复制，必须要结合自己的处境判断。）

从博客和Github上面来增加自己获胜的砝码；

但是这只是他的观点，是他觉得企业这样可以更好的了解一个人，我可以将读过的书都写在简历上，但难道我所想进入的企业都会要这样的我吗？

我能做的其实是去了解这所企业，像当初哪位大神刘一舟一样，上台来不是说自己，是直接为企业出谋划策，要成为企业需要的人，就要满足企业需求，现在找找阿里招聘人员的推荐书单。

所以其实培训机构的价值是：与学生联系，与企业联系，了解双方需求，把学生培养成企业需要的人，他们就收钱，但是也许不能百分百保证这种联系是到位的，但是至少几率会提升很多，如果没钱找企业去培训，就自己去了解企业需求，至少人本身，总是最重要的。

那么，如我所想：阿里巴巴需要怎样的人？阿里在开拓什么样的业务？答案是：不知道，去找吧。

有什么东西是，无论什么企业都需要的？

答案1 ： 数据结构和算法，无论从道听途说还是各种面经，做后台的人数据结构重要性不言而喻，虽然现在晚了，现在干只能增加几率，但是比不起步好，像当初的那场演讲一样。

答案2： 数据库，和后台打交道不用数据库的话就搞笑了。。。进阿里必学吧，MySQL。

答案3：编程语言Java，精通Java有多难不需要说了吧，但是要怎样去补充Java知识？做Java认证的题目和试卷。看Java的书。

答案4：Linux，把它放在后面是因为开发平台也可能是windows，不过我希望进的企业必定是使用Linux的，所以要看Linux相关知识。

答案5：TCP/IP网络协议或者是操作系统概念之类的书要看，要了解基本原理。

再思考：

答案1企业需要吗？

答：从笔试题看无论如何都必须考，也是要掌握的，但是这是核心吗？换言之，在排序，这个是第一位吗？这是我的最有力砝码吗？答案：如果你要做编程，是的，其实排序应该换一换。

答案1 ： 数据结构和算法，无论从道听途说还是各种面经，做后台的人数据结构重要性不言而喻，虽然现在晚了，现在干只能增加几率，但是比不起步好，像当初的那场演讲一样。

答案2：编程语言Java，精通Java有多难不需要说了吧，但是要怎样去补充Java知识？做Java认证的题目和试卷。看Java的书。

答案3： 数据库，和后台打交道不用数据库的话就搞笑了。。。进阿里必学吧，MySQL。

答案4：Linux，把它放在后面是因为开发平台也可能是windows，不过我希望进的企业必定是使用Linux的，所以要看Linux相关知识。

答案5：TCP/IP网络协议或者是操作系统概念之类的书要看，要了解基本原理。

最后一点不是不重要，也很重要，罢了，把书看了再说。

做什么项目呢？什么项目最能锻炼自己呢？

1. 我能做什么项目

2. 企业需要怎样的人才，企业在做什么业务，怎么用现有的技术实现企业正在做的业务（对某个公司来说这是极好的，也是dian哥说的对口）

3. 怎么把我的项目和企业需求结合起来，下面就是目前我的答案。

如果我能根据现在有的他们上线的产品，猜测他们的技术，同时自己根据自己思路实现一个，这样进入的机会不会大一点，像刘一舟一样，站在招聘者的角度出谋划策。

想法1：既然我的目标是阿里，是电商，就应该做一个电商的后台。这样才是对口！

接下来的事情，选择一个项目暑期主力做（也许找不到实习），这样的情况下要了解阿里巴巴的所有的电商产品，Java后台技术等等，从宏观到细节。有不知道的问问伟铖，不过伟铖不是做后台的。

要点1：数据库检索角度

要点2：想google或者百度这种打一个字就弹出来很多搜索条目的情况是

要点3：阿里非常重视大数据，因为数据的确是大，天池大数据平台

要点4：阿里集群，深入剖析阿里巴巴云梯YARN集群

第一天：2014年5月14日

好吧孩子，今天真的真的非常热，同时没有收到UC的笔试通知晚上去霸面UC可能没去小测试感到遗憾，怎么办，怎么做？

不要放弃啊孩子，可以试试从钱方面着手，先就业再择业，数据结构和算法是为了择业做打算，但是Java基础和框架的精通是为了就业做打算，还有在教授那里拿到的如果有可以作为未来3个月找不到实习养活自己的钱（还是再找找吧），可以考虑下做个属于自己的校园网的项目，比什么都不做好，其实这两天就是在纠结着应该做什么项目，做什么项目有意义和价值。像顺平老师那样做个校园网页不错，至少算是电商类的，而且是oracle数据库。加油啊，即使事情再虐，也不要放弃。

今天看了知乎上面的一片精彩的文章，里面提到IT互联网的10个等级。

在这篇文章里面还可以看得内容是：连红黑树或者算法导论都没看过的人，真心不配做后台。。。

所以事实上，该做什么项目这一点还是没有定下来。

这个，可以在对阿里多一点了解以后，在6月份再开始，很不甘心，但也是没办法的。看书，搞掂现在手头上的项目，加油~~

第二天：2014年5月15日

日子总是过得很快，昨天夜晚去了UC笔试，霸笔成功了，同时觉得简历还应该修改一些东西。

UC的笔试题，不会的回忆如下：

1. Integer.MAX_VALUE

int a = Integer.MAX_VALUE;
long b =a+1 ;
printBinaryLong("long b",b);
printBinaryInt("int a+1",a+1);

printBinaryLong 和 printBinaryInt是自定义函数，完整代码如下：

public class template{
public static void main(String[] args){
test();
}

static void test()
{

// printBinaryInt("int a",a);
int d = 2147483647;
// printBinaryInt("int d",d);
int c = Integer.MIN_VALUE;
// printBinaryInt("int c",c);
int a = Integer.MAX_VALUE;
long b =a+1 ;
printBinaryLong("long b",b);
printBinaryInt("int a+1",a+1);

}

static void printBinaryInt(String s, int in){
System.out.println(s+", int: "+in+", binaryy: ");
System.out.print("  ");
for(int i=31; i>=0;i--){
if( ( (1<< i)& in)!=0)
{System.out.print("1");}
else{
System.out.print("0");
}

}
System.out.println();
}

static void printBinaryLong(String s, long l){
System.out.println(s+", long: "+l+", binaryy: ");
System.out.print("  ");
for(int i=63; i>=0;i--){
if( ( (1L<< i)& l)!=0)
{System.out.print("1");}
else{
System.out.print("0");
}

}
System.out.println();
}

}

由此可见，过程是：a = Integer.MAX_VALUE ， a+1 发生溢出

注意二进制表示的变化，011111111111111111111111111（大概如此）

变成 10000000000000000000000000 成为了Integer.MIN_VALUE，然后这个值赋予给b

b是能接受这个值的，同时保持值不变的情况下进行符号位拓展，成为了 33个1和31个0 的二进制表示。

2.

线程间的通讯方式：



以上是linux中的。

3. Thread中的sleep()和wait()的方式区别

sleep()在 Java SE 7 文档中的解释：

sleep是在java.lang.Thread中的

Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers. The thread does
not lose ownership of any monitors.

wait()的

wait()是在java.lang.object中的

Causes the current thread to wait until another thread invokes the

notify()

method
or the

notifyAll()

method
for this object. In other words, this method behaves exactly as if it simply performs the call

wait(0)

.

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call
to the

notify

method or the

notifyAll

method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.
他们两最大的区别是sleep没有释放线程锁，wait释放了，这篇博文有简单描述，只是简单理解，里面的内容有些不准确，还是应该查看Java SE API
4. Hashtable 和 HashMap的区别之完整答案：
1）. 线程安全和飞线程安全
2）. Hashtable不允许null（key和value都不可以），HashMap可以（key和value都可以）
他们的区别大概有6个，详情见以下博文
5. Vector和ArrayList的去区别（全都考容器类）
1）. 线程安全与非线程安全
2）. vector提供 indexof接口，
Returns the index of the first occurrence of the specified element in this vector, or -1 if this vector does not contain the
element.
3）. 当capacity不够的时候，vector增加100% ，ArrayList增加50%+1
6. 如果要你设计一个手机游戏网站下载站点，设计那些功能引用户（上 a.9game.cn 看一看）
1） 热门游戏
2）新游推荐
3）网游排行
4）飙升最快
5）热门分类
6）特色集合
7. 空指针的问题

int[] A = new int[8];
System.out.println(A.equals(0));

输出：false

A里面已经全部初始化为0
8. do-while和while-do的唯一区别是：do-while无论如何都会执行一次，其余都一样，看下面代码:

int a =-1 ;
do{
a = a-1;
System.out.println("do-while:"+a);
}while(a>0);

while(a>0){
a = a-1;
System.out.println("while-do:"+a);
}

输出为：do-while:-2

程序员必读文章10篇

下面给出Java的一个堆排序：

import java.util.*;

public class template{
public static void main(String[] args){
System.out.println(Arrays.toString(A));
HeapSort(A);

}

static int[] A = {0,5 , 7 , 8 , 9 ,10 ,11,2 ,0 ,1};

static int heap_size = 0;

static int Left(int i){
return 2*i;
}

static int Right(int i){
return 2*i+1;
}

static void MaxHeapify(int[] A, int i){
int l = Left(i);
int r = Right(i);
int largest = 0;
if(l<=heap_size && A[l]>A[i]){
largest = l;
}
else{
largest = i;
}
if(r<=heap_size && A[r]>A[largest]){
largest = r;
}
if(largest != i){
Swap(A,i,largest);
MaxHeapify(A,largest);
}
}

static void BuildHeap(int[] A){
heap_size = A.length-1;
for(int i=(A.length-1)/2;i>=1;i--){
// System.out.println("BuildHeap:"+i);
MaxHeapify(A,i);
}
}

static void HeapSort(int[] A){

BuildHeap(A);
System.out.print("(");
for(int i=A.length-1;i>=2;i--){
Output(A,1);
Swap(A,1,i);
heap_size--;
MaxHeapify(A,1);
}
System.out.print(A[1]);
System.out.print(")");
}

static void Output(int[] A, int i){
System.out.print(A[i]+",");
}

static void Swap(int[] A,int a, int b){
// System.out.println("swap:"+a);
// System.out.println("swap:"+b);
int temp = A[a];
A[a] = A[b];
A[b] = temp;
}

}

下面给出Java的快速排序：（使用了尾递归）

import java.util.*;
public class QuickSort{
public static void main(String[] args){
int[] A = {5 , 7 , 8 , 9 ,10 ,11,2 ,0 ,1};
quickSor(A,0,A.length-1);
System.out.println(Arrays.toString(A));
}

static void quickSor(int[] A,int begin, int end){
int p=0;
while(begin<end){
p=Partition(A,begin,end);
quickSor(A,p+1,end);
end = p-1;
}
}

static int Partition(int[] A,int begin, int end){
int compare = A[end];
int i = begin-1;
for(int j= begin;j<=end-1;j++){
if(A[j]>=compare){
// i++;
Swap(A,++i,j);
}
}
Swap(A,i+1,end);
return i+1;
}

static void Swap(int[] A, int a , int b){
int temp = A[a] ;
A[a] = A[b];
A[b] = temp;
}

}

下面给出计数排序（稳定排序）

import java.util.Arrays;
public class court_sort{
public static void main(String[] args){
int[] A = {5,2,4,5,9,10,7,1,0,9,2};
int k = max(A);
int[] B = new int[A.length];
CountSort(A,B,k);
System.out.println(Arrays.toString(A));
System.out.println(Arrays.toString(B));
}

static int max(int[] A){
int maxV = 0;
for(int a : A){
if(a>maxV)   maxV = a;
}
return maxV+1;
}

static void CountSort(int[] A, int[] B, int k){
int[] C = new int[k];
for(int i=0;i<C.length;i++){
C[i] =0;
}
for(int j=1;j<A.length;j++){
C[A[j]]++;
}
for(int i=1;i<C.length;i++){
C[i] = C[i]+C[i-1];
}
for(int j=A.length-1;j>=1;j--){
B[C[A[j]]] = A[j];
C[A[j]]--;
}
}

}