1米2

final、finally和finalize的区别

heyuan8818 — 2011-03-21 09:31:00

这是一道再经典不过的面试题了，我们在各个公司的面试题中几乎都能看到它的身影。final、finally和finalize虽然长得像孪生三兄弟一样，但是它们的含义和用法却是大相径庭。这一次我们就一起来回顾一下这方面的知识。我们首先来说说final。它可以用于以下四个地方：定义变量，包括静态的和非静态的。定义方法的参数。定义方法。定义类。我们依次来回顾一下每种情况下final的作用。首先来看第一种情况，如果final修饰的是一个基本类型，就表示这个变量被赋予的值是不可变的，即它是个常量；如果final修饰的是一个对象，就表示这个变量被赋予的引用是不可变的，这里需要提醒大家注意的是，不可改变的只是这个变量所保存的引用，并不是这个引用所指向的对象。在第二种情况下，final的含义与第一种情况相同。实际上对于前两种情况，有一种更贴切的表述final的含义的描述，那就是，如果一个变量或方法参数被final修饰，就表示它只能被赋值一次，但是JAVA虚拟机为变量设定的默认值不记作一次赋值。被final修饰的变量必须被初始化。初始化的方式有以下几种：在定义的时候初始化。 final变量可以在初始化块中初始化，不可以在静态初始化块中初始化。静态final变量可以在静态初始化块中初始化，不可以在初始化块中初始化。 final变量还可以在类的构造器中初始化，但是静态final变量不可以。通过下面的代码可以验证以上的观点： Java代码 public class FinalTest { // 在定义时初始化 public final int A = 10; public final int B; // 在初始化块中初始化 { B = 20; } // 非静态final变量不能在静态初始化块中初始化 // public final int C; // static { // C = 30;

单态之饿汉，懒汉

heyuan8818 — 2011-03-11 11:03:00

饿汉式: public class Singleton{ private static Singleton singleton = new Singleton (); private Singleton (){} public Singleton getInstance(){return singletion;} } 懒汉式: public class Singleton{ private static Singleton singleton = null; private Singleton (){} public static synchronized synchronized getInstance(){ if(singleton==null){ singleton = new Singleton(); } return singleton; } } 比较: 饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的从实现方式来讲他们最大的区别就是懒汉式是延时加载, 他是在需要的时候才创建对象,而饿汉式在虚拟机启动的时候就会创建, 使用的场合根据具体环境和个人习惯吧. 饿汉式单例类在自己被加载时就将自己实例化。即便加载器是静态的，在饿汉式单例类被加载时仍会将自己实例化。单从资源利用效率角度来讲，这个比懒汉式单例类稍差些。从速度和反应时间角度来讲，则比懒汉式单例类稍好些。然而，懒汉式单例类在实例化时，必须处理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费时间。这意味着出现多线程同时首次引用此类的机率变得较大。饿汉式单例类可

Java 多线程入门大全(适用于有一定基础者)

heyuan8818 — 2011-03-10 20:32:00

先从线程的创建说起.线程的创建一共有两种形式: -------------------------------------------------------------------------------- 一种是继承自Thread类.Thread 类是一个具体的类,即不是抽象类,该类封装了线程的行为.要创建一个线程,程序员必须创建一个从 Thread 类导出的新类.程序员通过覆盖 Thread 的 run() 函数来完成有用的工作.用户并不直接调用此函数;而是通过调用 Thread 的 start() 函数,该函数再调用 run(). 例如: public class Test extends Thread{ public Test(){ } public static void main(String args[]){ Test t1 = new Test(); Test t2 = new Test(); t1.start();

SQL各个子句: outer join,on,where,group by,ha

heyuan8818 — 2011-03-09 16:45:00

where与having 1.作用的对象不同。WHERE 子句作用于表和视图，HAVING 子句作用于组(group)。 eg:SELECT city FROM weather WHERE temp_lo = (SELECT max(temp_lo) FROM weather); 2.WHERE 在分组和聚集计算之前选取输入行（因此，它控制哪些行进入聚集计算），而 HAVING 在分组和聚集之后选取分组的行。因此，WHERE 子句不能包含聚集函数；因为试图用聚集函数判断那些行输入给聚集运算是没有意义的。相反，HAVING 子句总是包含聚集函数。（严格说来，你可以写不使用聚集的 HAVING 子句，但这样做只是白费劲。同样的条件可以更有效地用于 WHERE 阶段。）在前面的例子里，我们可以在 WHERE 里应用城市名称限制，因为它不需要聚集。这样比在 HAVING 里增加限制更加高效，因为我们避免了为那些未通过 WHERE 检查的行进行分组和聚集计算。以下示例使用的数据库是MySQL 5。数据表：student 表结构： Field Name DataType Len id int 20 name varchar 25 major varchar 25 score int 20

union，union all，join

heyuan8818 — 2011-03-09 16:38:00

今天学习了联合和链接。联合有union和union all两种，前者是过滤表中的重复数据后显示；而后者是显示全部数据。链接是将多个表的各个字段连接在一起，关键字是join，其原理是：1、两个表的字段进行相加（相当于横加）；2、根据条件对两个表的记录进行匹配；3、没有条件则第一个表的每一条记录和第二个表的每一行记录进行连接，也叫做交叉连接，产生的乘积叫做“笛卡尔乘积”。连接类型又分交叉链接cross join、内链接（对等链接）join、左外链接left join、右外链接right join和全链接 full join（效率低）。内链接缺点是不能显示不匹配的数据；左外链接是用join左边的表去链接另外一个表；右外链接是用join右边的表去链接另外一个表；全链接是显示相链接的表的全部数据。联合和链接的区别是：联合相当于竖加，链接相当于横加。

设计模式之Singleton(单态)

heyuan8818 — 2011-03-08 10:27:00

设计模式之Singleton(单态) 板桥里人 http://www.jdon.com 2002/05/07 定义: Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录数据库连接都需要这样的单线程操作。还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。另外方面，Singleton也能够被无状态化。提供工具性质的功能， Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。我们常常看到工厂模式中类装入器(class loader)中也用Singleton模式实现的,因为被装入的类实际也属于资源。如何使用? 一般Singleton模式通常有几种形式: public class Singleton { 　　private Singleton(){} 　　//在自己内部定义自己一个实例，是不是很奇怪？　　//注意这是private 只供内部调用　　private static Singleton instance = new Singleton(); 　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　　　public static Singleton getInstance() { 　　　　return instance; 　　　　 } } 第二种形式: public class Singleton { 　　private static Singleton instance = null; 　　public static synchronized Singleton getInstance() { 　　//这个方法比上面有所改进，不用每次都进行生成对

深搜之简单排序

heyuan8818 — 2011-03-07 17:30:00

哈哈。一同事说面试题。让我做做。10分钟以内。结果。写完程序+调试花了20分钟。哎。看来自己老了。其实拿到题目想都没多想就编了。只是现在编码速度太低了。 //用1、2、2、3、4、5这六个数字，打印出所有不同的排列，如：512234、412345等， //要求："4"不能在第三位，"3"与"5"不能相连,写一个个小程序 import java.util.Map; import javolution.util.FastMap; public class test1 { public static Map mymap = FastMap.newInstance(); public static int count = 0; public static void main(String[] args) { // 用1、2、2、3、4、5这六个数字，打印出所有不同的排列，如：512234、412345等， //要求："4"不能在第三位，"3"与"5"不能相连,写一个个小程序 int []a = {0,0,0,0,0,0,0,0}; StringBuffer b = new StringBuffer(); dfs(1, a, b); System.out.println("OK");

SQL之纵表转横表问题

heyuan8818 — 2011-03-04 10:25:00

横表有这么四列，Id是主键， Id code1 code2 code3 111 aaa bbb ccc 纵表只有两列： ID code 111 aaa 111 bbb 111 ccc SQL模板1： select id,max(case when code='aaa' then code end) as code1, max(case when code='bbb' then code end) as code2, max(case when code='ccc' then code end) as code3 from tt group by id SQL模板2： select id,max(case code when 'aaa' then code else null end) as code1, max(case code when 'bbb' then code else null end) as code2, max(case code when 'ccc' then code else null end) as code3 from tt group by id

深入DB2索引

heyuan8818 — 2011-03-03 15:26:00

1、DB2索引简介索引优点：（1）创建索引可提高查询速度。（2）创建索引保证数据唯一性。索引类型：在介绍索引类型前介绍一下关于稠密度的概念. 稠密度定义：在数据分布均匀的情况下，稠密度=数据分布的可能数/数据总条数。例如：表1中有索引1在列1上，其中列1的数据分布有10中，分别是1-10，数据接近均匀分布，总数据量为1000，则该索引的稠密度=100/1000=10%，稠密度最高为1。稠密度越小，索引的选择性越大，查询性能越好。（1）非唯一索引可以说大部分的索引的非唯一索引，这和数据的分布有关系，一般的数据都具有可重复性特性，所以他们不能被定义为唯一索引。非唯一索引可以使用命令： CREATE INDEX ON ()来定义。（2）唯一索引唯一索引用来保证数据的唯一性，唯一索引一般性能要高于非唯一索引，这与索引的稠密度有关。唯一索引的稠密度永远等于数据总条数的倒数。（3）纯索引纯索引的概念是相对与一般索引。如下方式表中有俩个字段，其中字段1是唯一主键，字段2为数据，实际的查询中经常是select * from 表 where col1=? 这样的查询条件可以使用纯索引来避免表查询，具体创建命令为 CREATE UNIQUE INDEX ON (COL1_NAME) INCLUDE(COL2_NAME)。上述的语句的意思就是在col1上创建唯一索引，选择包含col2的数据，这些附加的数据将与键存储到一起，但是不作为索引的一部分，所以不被排序。纯索引访问是用来减少对数据页的访问，因为所需要的数据已经显示在索引中了。（4）群集索引群集索引允许对数据页采用更线性的访问模式，允许更有效的预取，并且避免排序。

删除表中重复数据模板

heyuan8818 — 2011-03-03 14:42:00

delete from AAA where (name ,valu) in( select name ,valu from AAA group by (name,valu) having count(*) > 1 ) and id not in (select min(id) from AAA group by (name,valu) having count(*)>1)

向表中插入原表已有数据（复制插入）模版

heyuan8818 — 2011-03-03 14:40:00

insert into 表名 (字段1,字段2,....) select 字段1 , 字段2,.... from 表名

Kill the monster HDU2616

heyuan8818 — 2009-07-19 05:38:00

昨天的比赛题目，其实就是深搜，一个一个的枚举。。。。。最多10个，就是9！次循环。不会超时！！ #include#includeint A[11],M[11];int mark[11];int n;int cout=INT_MAX;void dfs(int ,int ,int);int main(){ int xue; int i; while(scanf("%d %d",&n,&xue)!=EOF) { cout=INT_MAX; for(i=1;i<=n;i++) { scanf("%d %d",&A[i],&M[i]); mark[i]=0; } for(i=1;i<=n;i++) { mark[i]=1; dfs(1,xue,i); mark[i]=0; } if(cout==INT_MAX) printf("-1\n"); else printf("%d\n",cout); } return 0;}void dfs(int c,int xx,int i)//数量，血，第几块{ int j; int temp=xx; if(c>cout) return ; if(xx<=M[i]) { xx=xx-2*A[i]; } else xx=xx-A[i]; if(xx<=0) cout=c; else &nb

HDU 1130 How Many Trees?

heyuan8818 — 2009-07-16 21:26:00

其实递推式是很简单的！不过数据太大牵扯到了大整数，以前自己用c写过大整数的加减乘除。本来想调出来用用的，不过，想想，自己还是要学着写JAVA。决定用JAVA的大整数做。第一次试着用jAVA做，一次AC，太开心了。。。。递推式：f[n]=f[n-1]*2+f[i]*f[n-i-1] i:1.....n-1 import java.math.BigInteger; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Main { public static void main(String args[]) { List list = new ArrayList(101); BigInteger f= BigInteger.valueOf(1); list.add(f); f= BigInteger.valueOf(2); list.add(f); for(int i=2;i<100;i++) { f=(BigInteger)list.get(i-1); f=f.multiply(BigInteger.valueOf(2)); for(int j=0;j

Rescue HDU1242 广搜

heyuan8818 — 2009-07-15 11:12:00

超级无语，这样的题居然花了我这么久时间。头脑不清醒～～～本来一拿到题目是要用广搜的。头脑不知道一下子怎么短路了，明知道深搜会超时还是用了深搜！后来想想还是广搜。#include #include #define MAX 205 int a[MAX][MAX];//路形 int mark[MAX][MAX];//是否已搜标志 int f[1011][2];//搜索队列 int MIN[MAX][MAX]; int d[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//4个方向 int main() { char c; int M,N,i,j; int p,rear,dd; int si,sj,di,dj; while(scanf("%d%d",&M,&N)!=EOF) { for(i=0;i

Asteroids! hdu1240

heyuan8818 — 2009-07-15 08:47:00

很简单的一道广度优先搜索题 #includeint a[11][11][11];int mark[11][11][11];int f[1011][4];int d[6][3]={{0,0,1},{0,1,0},{1,0,0,},{0,0,-1},{0,-1,0},{-1,0,0}};//六个方向int main(){ char str[10],c; int N,i,j,k; int p,rear,flag,dd; int si,sj,sk,di,dj,dk; while(scanf("%s",str)!=EOF) { scanf("%d",&N); // scanf("%c",&c); for(i=0;i

FatMouse and Cheese hdu1078 搜索

heyuan8818 — 2009-07-14 10:48:00

FatMouse and Cheese 想不通，其实是很简单的一道搜索题，怎么说是题目分类时分到动规那一组，害得我做死的想动规怎么做还搞得我想了两天。用搜索不到一个小时搞定：不过，在我思路比较乱的情况下做的，所以这样搜也不是最优的。不管了，先贴出来再说： a[][]记录每格的食物数量。max[][]记录从i,j搜时能吃到最多的食物数量。mark[][]记录当前结点是否在本次搜索过。flag[][]记录的是i,j,结点是否已经进行过一次深搜！！！！ #includeint a[103][103];int max[103][103],k,n;int mark[103][103];int flag[103][103];int d[4][2]={{-1,0},{1,0},{0,1},{0,-1}};int DFS(int i,int j); int main(){ int i,j; while(scanf("%d%d",&n,&k)!=EOF) { if(n==-1&&k==-1) break; for(i=1;i<=n;i++) for(j=1;j<=n;j++) { scanf("%d",&a[i][j]);

Fast Food HDU1227 DP

heyuan8818 — 2009-07-13 22:58:00

int a[205],cost[205][205],f[35][205];//a保存的是rest的位置。cost保存的是i个rest与j个rest之间建一个dpot的各rest到该dpot的最短距离//f保存的是i个rest之间建j个dpot的最短距离。。。状态方程： f[i][j]=min{f[i-1][k]+cost[k+1][j]} k=i-1.......j-1; #include#includeint a[205],cost[205][205],f[35][205];//a保存的是rest的位置。cost保存的是i个rest与j个rest之间建一个dpot的各rest到该dpot的最短距离//f保存的是i个rest之间建j个dpot的最短距离。。。int abs(int a){ if(a<0) return -a; else return a;}int main(){ int i,j,kk,n,k,mid; int N=0; while(scanf("%d %d",&n,&k)!=EOF) { if(n==0&&k==0) break; N++; for(i=1;i<=n;i++) { scanf("%d",&a[i]); } &

Fourier's Lines HDU Dp

heyuan8818 — 2009-07-13 20:27:00

比赛时想偏了！不过我觉得我比赛时想的那种方向是没错的。不过边界值应该很难考虑！后来讨论时发现他们那种想法很好，写写：题目意思是给你n条线，n条线有m个交点，要你求出这样的线能将平面分成多少区域！首先 n条线最多有 (n-1)*n/2;个点最多能划分成(n+1)*n/2区域分别记为maxd。maxs 观察可得出规律：每减少一个点，就减少一个区域/ 所以n条线m个交点能分平面的区域数为：maxs-maxd+m+1; 问题解决。接下来就是判断存不存在这样的n条线有m个交点这就换成了一个DP问题 f[i][j]记录的是i条线能否有j个交线，若有存1，若无存0；则有如果f[i][j]=1; 则f[i+k][j+ki]=1 k=1,2,3.........(就相当于在i条线上加k条平行线能得的点数) 依次填表。代码如下： #includeint f[101][20000];int main(){ int N=0; int maxd,maxs,m,n,k,i,res; int max,j; f[0][0]=1; f[1][0]=1; f[2][0]=1; f[2][1]=1; for(i=3;i<101;++i) { // f[i][1]=1; //for(j=i;j) for(k=i-1;k>=0;--k) { for(m=0;m<=(k)*(k-1)/2;++m) &

hdu1480 钥匙计数之二

heyuan8818 — 2009-07-12 13:43:00

设lock[i]表示：有 i个槽的钥匙的个数设one[i]表示：有 i个槽且左边第一个槽深度为1的钥匙的个数设two[i]表示：有 i个槽且左边第一个槽深度为2的钥匙的个数....设six[i]表示：有 i个槽且左边第一个槽深度为6的钥匙的个数则显然：lock[i]=one[i]+two[i]+ three[i]+four[i]+five[i]+six[i] 由于易知：one[i]=six[i],two[i]=three[i]=four[i]=five[i]则可以得到：lock[i]=one[i]*2+two[i]*4 其中：one[i]=one[i-1]+two[i-1]+three[i-1]+four[i-1]+five[i-1]+a[i]; =one[i-1]+two[i-1]*4 +a[i] two[i]=one[i-1]*2+two[i-1]*4 +b[i]其中，a[i] 和b[i]的含义分别是：a[i]表示“有 i个槽且左边第一个槽深度为1，同时这种钥匙在除掉第一个槽后不再是钥匙”的钥匙的个数。例如 123,124,125,134,135,145,126,136,146,156 就属于这种情况。b[i]表示“有 i个槽且左边第一个槽深度为2，同时这种钥匙在除掉第一个槽后不再是钥匙” 的钥匙的个数。分析到这里，可以知道，关键的是求a[i]和b[i]，我们可以得到如下表达式：a[i]=(2^(i-1)-2)*6+(2^(i-2)-1)*4b[i]=(2^(i-1)-2)*9其中，a[i] 的各部分的含义如下：(2^(i-1)-2)*6：当去掉第一位，后面i-1位只有 (2,3)或者 (2,4) 或者(2,5) 或者(3,4) 或者(3,5) 或者(4,5)两种数字的时候，显然是不合法的钥匙（不满足至少有3个不同的深度），加上第一位的1则显然是一个合格的钥匙。所以后面的数字可以为一个组合中两个数字的任意一个，根据乘法原理i-1位一共有2^(i-1)种组合，当然还需要去掉两种特殊情况，就是后面i-1位完全相同的情况。满足这种条件的一共有上面六种组合，所以得到(2^(i-1)-2)*6。(2^(i-2)-1)*4：当去掉第一位，后面i-1位只有 (2,6)或者 (3,6) 或者(4,

钥匙计数之一 hdu1438

heyuan8818 — 2009-07-12 12:49:00

递推方程式如下1：如果X是钥匙则X1/2/3/4也是所以a[I]=a[I-1]*42: 如果X不是，X2/3是则X由1/4组成/但要除去全1和全4 所以a[I]+=(2^(I-1)-2)*23 如果X不是 X1/4是。则X=Y（1/4） M=X1/4=Y（4/1）（1/4）前I-2位可以是1234，但要除去全为1/4的情况还有就是X是钥匙且X是以1/4结尾的情况。我们用b[I]数组表示i位时以1/4结尾的的数量 temp=4^(i-2)-2^(i-2)-b[i-1]; 则 b[i]=a[i-1]*2+temp; 代码如下： #include#includeint main(){ int i; __int64 temp,a[32],b[32];//b[i]记录以1 4结尾的数 a[2]=0; a[3]=8; b[2]=0; b[3]=4; printf("N=2: 0\nN=3: 8\n"); for(i=4;i<=31;i++) { a[i]=a[i-1]*4; a[i]+=(__int64)pow(2,i)-4;//以2 3 结尾的 temp=((__int64)pow(4,i-2)-(__int64)pow(2,i-2))*2-b[i-1]; a[i]+=temp; b[i]=a[i-1]*2+temp;&n