Reminder about your invitation from Ying_er Lin

2011-03-28T01:27:00.001-07:00

This is a reminder that on March 15, Ying_er Lin sent you an invitation to become part of his or her professional network at LinkedIn.

Follow this link to accept Ying_er Lin's invitation.

https://www.linkedin.com/e/-9ian2j-glt4wvb5-c/doi/2504874274/8ZyQZR2U/gir_442152234_1/EML-inv_17_rem/

Signing up is free and takes less than a minute.

On March 15, Ying_er Lin wrote:

> To: [melody.crazyCoding.7070520@blogger.com]
> From: Ying_er Lin [melody.crazycoding@gmail.com]
> Subject: Ying_er Lin wants to stay in touch on LinkedIn

> I'd like to add you to my professional network on LinkedIn.
>
> - Ying_er Lin

The only way to get access to Ying_er Lin's professional network on LinkedIn is through the following link:

https://www.linkedin.com/e/-9ian2j-glt4wvb5-c/doi/2504874274/8ZyQZR2U/gir_442152234_1/EML-inv_17_rem/

You can remove yourself from Ying_er Lin's network at any time.

--------------

一封程序员的爱情表白书

2010-06-03T05:14:00.001-07:00

    我能抽象出整个世界．．．
    但是我不能抽象出你．．．
    因为你在我心中是那么的具体．．．
    所以我的世界并不完整．．．
    我可以重载甚至覆盖这个世界里的任何一种方法．．．
    但是我却不能重载对你的思念．．．
    也许命中注定了你在我的世界里永远的烙上了静态的属性．．．
    而我不慎调用了爱你这个方法．．．
    当我义无返顾的把自己作为参数传进这个方法时．．．
    我才发现爱上你是一个死循环．．．
    它不停的返回对你的思念压入我心里的堆栈．．．
    在这无尽的黑夜中．．．
    我的内存里已经再也装不下别人．．．
    我不停的向系统申请空间．．．
    但却捕获一个异常－－－我爱的人不爱我．．．
    为了解决这个异常．．．
    我愿意虚拟出最后一点内存．．．
    把所有我能实现的方法地址压入堆栈．．．
    并且在栈尾压入最后一个方法－－－将字符串＂我爱你，你爱我吗？＂传递给你．．．
    如果返回值为真－－我将用尽一生去爱你．．．
    否则－－我将释放掉所有系资源．

HP大中华区总裁孙振耀退休感言

2010-03-31T17:54:00.001-07:00

如果这篇文章没有分享给你，那是我的错。
如果这篇文章分享给你了，你却没有读，继续走弯路的你不要怪我。
如果你看了这篇文章，只读了一半你就说没时间了，说明你已经是个“茫”人了。
如果你看完了，你觉得这篇文章只是讲讲大道理，说明你的人生阅历还不够，需要你把这篇文章珍藏，走出去碰几年壁，头破血流后再回来，再读，你就会感叹自己的年少无知。
如果你看完了，觉得很有道理，然后束之高阁，继续走进拥挤的地铁，依然用着自己昨日的观念来思考自己的未来，你的人生也将继续重复着昨日的状况。
如果你看完了，觉得那是一个过来人，对你的人生忠告，并你也愿意用他告诉你的思想去指导自己今后的生活，对你来讲成功不是很难，难的是你是否可以用这篇文章里的思想一直鞭策自己。
如果你看完了，觉得那是一个长辈用他的一生的时间来写的一篇对你忠告的文章，说明你已经有了和他相似的人生阅历，只要你继续努力，成就伟业并不难，难的是你是否可以把自己的人生经验和他人分享呢？
      体验决定深度，知识决定广度。你的人生是什么呢？

  一、关于工作与生活
　　
　　  我有个有趣的观

察，外企公司多的是25-35岁的白领，40岁以上的员工很少，二三十岁的外企员工是意气风发的，但外企公司40岁附近的经理人是很尴尬的。我见过的40岁附近的外企经理人大多在一直跳槽，最后大多跳到民企，比方说，唐骏。外企员工的成功很大程度上是公司的成功，并非个人的成功，西门子的确比国美大，但并不代表西门子中国经理比国美的老板强，甚至可以说差得很远。而进外企的人往往并不能很早理解这一点，把自己的成功90％归功于自己的能力，实际上，外企公司随便换个中国区总经理并不会给业绩带来什么了不起的影响。好了问题来了，当这些经理人40多岁了，他们的薪资要求变得很高，而他们的才能其实又不是那么出众，作为外企公司的老板，你会怎么选择？有的是只要不高薪水的，要出位的精明强干精力充沛的年轻人，有的是，为什么还要用你？
　　
　　  从上面这个例子，其实可以看到我们的工作轨迹，二三十岁的时候，生活的压力还比较小，身体还比较好，上面的父母身体还好，下面又没有孩子，不用还房贷，也没有孩子要上大学，当个外企小白领还是很光鲜的，挣得不多也够花了。但是人终归要结婚生子，终归会老，到了40岁，父母老了，要看病要吃药，要有人看护，自己要还房贷，要过基本体面的生活，要养小孩……那个时候需要挣多少钱才够花才重要。所以，看待工作，眼光要放远一点，一时的谁高谁低并不能说明什么。
　　
　　  从这个角度上来说，我不太赞成过于关注第一份工作的薪水，更没有必要攀比第一份工作的薪水，这在刚刚出校园的学生中间是很常见的。正常人大概要工作 35年，这好比是一场马拉松比赛，和真正的马拉松比赛不同的是，这次比赛没有职业选手，每个人都只有一次机会。要知到，有很多人甚至坚持不到终点，大多数人最后是走到终点的，只有少数人是跑过终点的，因此在刚开始的时候，去抢领先的位置并没有太大的意义。刚进社会的时候如果进500强公司，大概能拿到3k -6k/月的工资，有些特别技术的人才可能可以到8k/月，可问题是，5年以后拿多少？估计5k-10k了不起了。起点虽然高，但增幅有限，而且，后面的年轻人追赶的压力越来越大。
　　
　　  我前两天问我的一个销售，你会的这些东西一个新人2年就都学会了，但新人所要求的薪水却只是你的一半，到时候，你怎么办？
　　职业生涯就像一场体育比赛，有初赛、复赛、决赛。初赛的时候大家都刚刚进社会，大多数都是实力一般的人，这时候努力一点认真一点很快就能让人脱颖而出，于是有的人二十多岁做了经理，有的人迟些也终于赢得了初赛，三十多岁成了经理。然后是复赛，能参加复赛的都是赢得初赛的，每个人都有些能耐，在聪明才智上都不成问题，这个时候再想要胜出就不那么容易了，单靠一点点努力和认真还不够，要有很强的坚忍精神，要懂得靠团队的力量，要懂得收服人心，要有长远的眼光……
　　
　　  看上去赢得复赛并不容易，但，还不是那么难。因为这个世界的规律就是给人一点成功的同时让人骄傲自满，刚刚赢得初赛的人往往不知道自己赢得的仅仅是初赛，有了一点小小的成绩大多数人都会骄傲自满起来，认为自己已经懂得了全部，不需要再努力再学习了，他们会认为之所以不能再进一步已经不是自己的原因了。虽然他们仍然不好对付，但是他们没有耐性，没有容人的度量，更没有清晰长远的目光。就像一只愤怒的斗牛，虽然猛烈，最终是会败的，而赢得复赛的人则象斗牛士一样，不急不躁，跟随着自己的节拍，慢慢耗尽对手的耐心和体力。赢得了复赛以后，大约已经是一位很了不起的职业经理人了，当上了中小公司的总经理，大公司的副总经理，主管着每年几千万乃至几亿的生意。
　　
　　最终的决赛来了，说实话我自己都还没有赢得决赛，因此对于决赛的决胜因素也只能凭自己的猜测而已，这个时候的输赢或许就像武侠小说里写得那样，大家都是高手，只能等待对方犯错了，要想轻易击败对手是不可能的，除了使上浑身解数，还需要一点运气和时间。世界的规律依然发挥着作用，赢得复赛的人已经不只是骄傲自满了，他们往往刚愎自用，听不进去别人的话，有些人的脾气变得暴躁，心情变得浮躁，身体变得糟糕，他们最大的敌人就是他们自己，在决赛中要做的只是不被自己击败，等着别人被自己击败。这和体育比赛是一样的，最后高手之间的比赛，就看谁失误少谁就赢得了决赛。
　　
　　二、根源
　　
　　你工作快乐么？你的工作好么？
　　
　　有没有觉得干了一段时间以后工作很不开心？有没有觉得自己入错了行？有没有觉得自己没有得到应有的待遇？有没有觉得工作像一团乱麻每天上班都是一种痛苦？有没有很想换个工作？有没有觉得其实现在的公司并没有当初想象得那么好？有没有觉得这份工作是当初因为生存压力而找的，实在不适合自己？你从工作中得到你想要得到的了么？你每天开心么？
　　
　　  天涯上愤怒的人很多，你有没有想过，你为什么不快乐？你为什么愤怒？
　　
　　  其实，你不快乐的根源，是因为你不知道要什么！你不知道要什么，所以你不知道去追求什么，你不知道追求什么，所以你什么也得不到。
　　
　　  我总觉得，职业生涯首先要关注的是自己，自己想要什么？大多数人大概没想过这个问题，唯一的想法只是——我想要一份工作，我想要一份不错的薪水，我知道所有人对于薪水的渴望，可是，你想每隔几年重来一次找工作的过程么？你想每年都在这种对于工作和薪水的焦急不安中度过么？不想的话，就好好想清楚。饮鸩止渴，不能因为口渴就拼命喝毒药。越是焦急，越是觉得自己需要一份工作，越饥不择食，越想不清楚，越容易失败，你的经历越来越差，下一份工作的人看着你的简历就皱眉头。于是你越喝越渴，越渴越喝，陷入恶性循环。最终只能哀叹世事不公或者生不逢时，只能到天涯上来发泄一把，在失败者的共鸣当中寻求一点心理平衡罢了。大多数人都有生存压力，我也是，有生存压力就会有很多焦虑，积极的人会从焦虑中得到动力，而消极的人则会因为焦虑而迷失方向。所有人都必须在压力下做出选择，这就是世道，你喜欢也罢不喜欢也罢。
　　
　　一般我们处理的事情分为重要的事情和紧急的事情，如果不做重要的事情就会常常去做紧急的事情。比如锻炼身体保持健康是重要的事情，而看病则是紧急的事情。如果不锻炼身体保持健康，就会常常为了病痛烦恼。又比如防火是重要的事情，而救火是紧急的事情，如果不注意防火，就要常常救火。找工作也是如此，想好自己究竟要什么是重要的事情，找工作是紧急的事情，如果不想好，就会常常要找工作。往往紧急的事情给人的压力比较大，迫使人们去赶紧做，相对来说重要的事情反而没有那么大的压力，大多数人做事情都是以压力为导向的，压力之下，总觉得非要先做紧急的   事情，结果就是永远到处救火，永远没有停歇的时候。（很多人的工作也像是救火队一样忙碌痛苦，也是因为工作中没有做好重要的事情。）那些说自己活在水深火热为了生存顾不上那么多的朋友，今天找工作困难是当初你们没有做重要的事情，是结果不是原因。如果今天你们还是因为急于要找一份工作而不去思考，那么或许将来要继续承受痛苦找工作的结果。
　　
　　  我始终觉得我要说的话题，沉重了点，需要很多思考，远比唐笑打武警的话题来的枯燥乏味，但是，天下没有轻松的成功，成功，要付代价。请先忘记一切的生存压力，想想这辈子你最想要的是什么？所以，最要紧的事情，先想好自己想要什么。
　　
　　  三、什么是好工作
　　
　　  当初微软有个唐骏，很多大学里的年轻人觉得这才是他们向往的职业生涯，我在清华bbs里发的帖子被这些学子们所不屑，那个时候学生们只想出国或者去外企，不过如今看来，我还是对的，唐骏去了盛大，陈天桥创立的盛大，一家民营公司。一个高学历的海归在500强的公司里拿高薪水，这大约是很多年轻人的梦想，问题是，每年毕业的大学生都在做这个梦，好的职位却只有500个。
　　
　　  人都是要面子的，也是喜欢攀比的，即使在工作上也喜欢攀比，不管那是不是自己想要的。大家认为外企公司很好，可是好在哪里呢？好吧，他们在比较好的写字楼，这是你想要的么？他们出差住比较好的酒店，这是你想要的么？别人会羡慕一份外企公司的工作，这是你想要的么？那一切都是给别人看的，你干吗要活得那么辛苦给别人看？另一方面，他们薪水福利一般，并没有特别了不起，他们的晋升机会比较少，很难做到很高阶的主管，他们虽然厌恶常常加班，却不敢不加班，因为“你不干有得是人干”，大部分情况下会找个台湾人香港人新加坡人来管你，而这些人又往往有些莫名其妙的优越感。你想清楚了么？500强一定好么？找工作究竟是考虑你想要什么，还是考虑别人想看什么？
　　
　　  我的大学同学们大多数都到美国了，甚至毕业这么多年了，还有人最近到国外去了。出国真的有那么好么？我的大学同学们，大多数还是在博士、博士后、访问学者地挣扎着，至今只有一个正经在一个美国大学里拿到个正式的教职。国内的教授很难当么？我有几个表亲也去了国外了，他们的父母独自在国内，没有人照顾，有好几次人在家里昏倒都没人知道，出国，真的这么光彩么？就像有人说的“很多事情就像看A片，看的人觉得很爽，做的人未必。”
　　
　　  人总想找到那个最好的，可是，什么是最好的？你觉得是最好的那个，是因为你的确了解，还是因为别人说他是最好的？即使他对于别人是最好的，对于你也一定是最好的么？
　　
　　  对于自己想要什么，自己要最清楚，别人的意见并不是那么重要。很多人总是常常被别人的意见所影响，亲戚的意见，朋友的意见，同事的意见……问题是，你究竟是要过谁的一生？人的一生不是父母一生的续集，也不是儿女一生的前传，更不是朋友一生的外篇，只有你自己对自己的一生负责，别人无法也负不起这个责任。自己做的决定，至少到最后，自己没什么可后悔。对于大多数正常智力的人来说，所做的决定没有大的对错，无论怎么样的选择，都是可以尝试的。比如你没有考自己上的那个学校，没有入现在这个行业，这辈子就过不下去了？就会很失败？不见得。
　　
　　我想，好工作，应该是适合你的工作，具体点说，应该是能给你带来你想要的东西的工作，你或许应该以此来衡量你的工作究竟好不好，而不是拿公司的大小，规模，外企还是国企，是不是有名，是不是上市公司来衡量。小公司，未必不是好公司，赚钱多的工作，也未必是好工作。你还是要先弄清楚你想要什么，如果你不清楚你想要什么，你就永远也不会找到好工作，因为你永远只看到你得不到的东西，你得到的，都是你不想要的。
　　可能，最好的，已经在你的身边，只是，你还没有学会珍惜。人们总是盯着得不到的东西，而忽视了那些已经得到的东西。
　　
　　四、普通人
　　
　　我发现中国人的励志和国外的励志存在非常大的不同，中国的励志比较鼓励人立下大志愿，卧薪尝胆，有朝一日成富成贵。而国外的励志比较鼓励人勇敢面对现实生活，面对普通人的困境，虽然结果也是成富成贵，但起点不一样，相对来说，我觉得后者在操作上更现实，而前者则需要用999个失败者来堆砌一个成功者的故事。
　　
　　  我们都是普通人，普通人的意思就是，概率这件事是很准的。因此，我们不会买彩票中500万，我们不会成为比尔盖茨或者李嘉诚，我们不会坐飞机掉下来，我们当中很少的人会创业成功，我们之中有30％的人会离婚，我们之中大部分人会活过65岁……
　　
　　  所以请你在想自己要什么的时候，要得“现实”一点，你说我想要做李嘉诚，抱歉，我帮不上你。成为比尔盖茨或者李嘉诚这种人，是靠命的，看我写的这篇文章绝对不会让你成为他们，即使你成为了他们，也绝对不是我这篇文章的功劳。“王侯将相宁有种乎”但真正当皇帝的只有一个人，王侯将相，人也不多。目标定得高些对于喜欢挑战的人来说有好处，但对于大多数普通人来说，反而比较容易灰心沮丧，很容易就放弃了。
　　
　　  回过头来说，李嘉诚比你有钱大致50万倍，他比你更快乐么？或许。有没有比你快乐50万倍，一定没有。他比你最多也就快乐一两倍，甚至有可能还不如你快乐。寻找自己想要的东西不是和别人比赛，比谁要得更多更高，比谁的目标更远大。虽然成为李嘉诚这个目标很宏大，但你并不见得会从这个目标以及追求目标的过程当中获得快乐，而且基本上你也做不到。你必须听听你内心的声音，寻找真正能够使你获得快乐的东西，那才是你想要的东西。
　　你想要的东西，或者我们把它称之为目标，目标其实并没有高低之分，你不需要因为自己的目标没有别人远大而不好意思，达到自己的目标其实就是成功，成功有大有小，快乐却是一样的。我们追逐成功，其实追逐的是成功带来的快乐，而非成功本身。职业生涯的道路上，我们常常会被攀比的心态蒙住眼睛，忘记了追求的究竟是什么，忘记了是什么能使我们更快乐。

   社会上一夜暴富的新闻很多，这些消息，总会在我们的心里面掀起很多涟漪，涟漪多了就变成惊涛骇浪，心里的惊涛骇浪除了打翻承载你目标的小船，并不会使得你也一夜暴富。“只见贼吃肉，不见贼挨揍。”我们这些普通人既没有当贼的勇气，又缺乏当贼的狠辣绝决，虽然羡慕吃肉，却更害怕挨揍，偶尔看到几个没挨揍的贼就按奈不住，或者心思活动，或者大感不公，真要叫去做贼，却也不敢。

      我还是过普通人的日子，要普通人的快乐，至少，晚上睡得着觉。

       五、跳槽与积累

      首先要说明，工作是一件需要理智的事情，所以不要在工作上耍个性，天涯上或许会有人觉得你很有个性而叫好，煤气公司电话公司不会因为觉得你很有个性而免了你的帐单。当你很帅地炒掉了你的老板，当你很酷地挖苦了一番招聘的HR，账单还是要照付，只是你赚钱的时间更少了，除了你自己，没人受损失。

       我并不反对跳槽，但跳槽决不是解决问题的办法，而且频繁跳槽的后果是让人觉得没有忠诚度可言，而且不能安心工作。现在很多人从网上找工作，很多找工作的网站常常给人出些馊主意，要知道他们是盈利性企业，当然要从自身盈利的角度来考虑，大家越是频繁跳槽频繁找工作他们越是生意兴隆，所以鼓动人们跳槽是他们的工作。所以他们会常常告诉你，你拿的薪水少了，你享受的福利待遇差了，又是“薪情快报”又是“赞叹自由奔放的灵魂”。至于是否会因此让你不能安心，你跳了槽是否解决问题，是否更加开心，那个，他们管不着。

       要跳槽肯定是有问题，一般来说问题发生了，躲是躲不开的，很多人跳槽是因为这样或者那样的不开心，如果这种不开心，在现在这个公司不能解决，那么在下一个公司多半也解决不掉。你必须相信，90%的情况下，你所在的公司并没有那么烂，你认为不错的公司也没有那么好。就像围城里说的，“城里的人拼命想冲出来，而城外的人拼命想冲进去。”每个公司都有每个公司的问题，没有问题的公司是不存在的。换个环境你都不知道会碰到什么问题，与其如此，不如就在当下把问题解决掉。很多问题当你真的想要去解决的时候，或许并没有那么难。有的时候你觉得问题无法解决，事实上，那只是“你觉得”。

      人生的曲线应该是曲折向上的，偶尔会遇到低谷但大趋势总归是曲折向上的，而不是象脉冲波一样每每回到起点，我见过不少面试者，30多岁了，四五份工作经历，每次多则3年，少则1年，30多岁的时候回到起点从一个初级职位开始干起，拿基本初级的薪水，和20多岁的年轻人一起竞争，不觉得有点辛苦么？这种日子好过么？

       资本靠的就是积累，这种积累包括人际关系，经验，人脉，口碑……如果常常更换行业，代表几年的积累付之东流，一切从头开始，如果换了两次行业，35岁的时候大概只有5年以下的积累，而一个没有换过行业的人至少有了10年的积累，谁会占优势？工作到2-3年的时候，很多人觉得工作不顺利，好像到了一个瓶颈，心情烦闷，就想辞职，乃至换一个行业，觉得这样所有一切烦恼都可以抛开，会好很多。其实这样做只是让你从头开始，到了时候还是会发生和原来行业一样的困难，熬过去就向上跨了一大步，要知道每个人都会经历这个过程，每个人的职业生涯中都会碰到几个瓶颈，你熬过去了而别人没有熬过去你就领先了。跑长跑的人会知道，开始的时候很轻松，但是很快会有第一次的难受，但过了这一段又能跑很长一段，接下来会碰到第二次的难受，坚持过了以后又能跑一段，如此往复，难受一次比一次厉害，直到坚持不下去了。大多数人第一次就坚持不了了，一些人能坚持到第二次，第三次虽然大家都坚持不住了，可是跑到这里的人也没几个了，这点资本足够你安稳活这一辈子了。

        一份工作到两三年的时候，大部分人都会变成熟手，这个时候往往会陷入不断的重复，有很多人会觉得厌倦，有些人会觉得自己已经搞懂了一切，从而懒得去寻求进步了。很多时候的跳槽是因为觉得失去兴趣了，觉得自己已经完成比赛了。其实这个时候比赛才刚刚开始，工作两三年的人，无论是客户关系，人脉，手下，和领导的关系，在业内的名气……还都是远远不够的，但稍有成绩的人总是会自我感觉良好的，每个人都觉得自己跟客户关系铁得要命，觉得自己在业界的口碑好得很。其实可以肯定地说，一定不是，这个时候，还是要拿出前两年的干劲来，稳扎稳打，积累才刚刚开始。

        你足够了解你的客户吗？你知道他最大的烦恼是什么吗？你足够了解你的老板么？你知道他最大的烦恼是什么吗？你足够了解你的手下么？你知道他最大的烦恼是什么吗？如果你不知道，你凭什么觉得自己已经积累够了？如果你都不了解，你怎么能让他们帮你的忙，做你想让他们做的事情？如果他们不做你想让他们做的事情，你又何来的成功？

     六、等待

       这是个浮躁的人们最不喜欢的话题，本来不想说这个话题，因为会引起太多的争论，而我又无意和人争论这些，但是考虑到对于职业生涯的长久规划，这是一个躲避不了的话题，还是决定写一写，不爱看的请离开吧。

       并不是每次穿红灯都会被汽车撞，并不是每个罪犯都会被抓到，并不是每个错误都会被惩罚，并不是每个贪官都会被枪毙，并不是你的每一份努力都会得到回报，并不是你的每一次坚持都会有人看到，并不是你每一点付出都能得到公正的回报，并不是你的每一个善意都能被理解……这个，就是世道。好吧，世道不够好，可是，你有推翻世道的勇气么？如果没有，你有更好的解决办法么？有很多时候，人需要一点耐心，一点信心。每个人总会轮到几次不公平的事情，而通常，安心等待是最好的办法。

有很多时候我们需要等待，需要耐得住寂寞，等待属于你的那一刻。周润发等待过，刘德华等待过，周星驰等待过，王菲等待过，张艺谋也等待过……看到了他们如今的功成名就的人，你可曾看到当初他们的等待和耐心？你可曾看到金马奖影帝在街边摆地摊？你可曾看到德云社一群人在剧场里给一位观众说相声？你可曾看到周星驰的角色甚至连一句台词都没有？每一个成功者都有一段低沉苦闷的日子，我几乎能想象得出来他们借酒浇愁的样子，我也能想象得出他们为了生存而挣扎的窘迫。在他们一生最中灿烂美好的日子里，他们渴望成功，但却两手空空，一如现在的你。没有人保证他们将来一定会成功，而他们的选择是耐住寂寞。如果当时的他们总念叨着“成功只是属于特权阶级的”，你觉得他们今天会怎样？

        曾经我也不明白有些人为什么并不比我有能力却要坐在我的头上，年纪比我大就一定要当我的领导么？为什么有些烂人不需要努力就能赚钱？为什么刚刚改革开放的时候的人能那么容易赚钱，而轮到我们的时候，什么事情都要正规化了？有一天我突然想，我还在上学的时候他们就在社会里挣扎奋斗了，他们在社会上奋斗积累了十几二十年，我们新人来了，他们有的我都想要，我这不是在要公平，我这是在要抢劫。因为我要得太急，因为我忍不住寂寞。二十多岁的男人，没有钱，没有事业，却有蓬勃的欲望。

         人总是会遇到挫折的，人总是会有低潮的，人总是会有不被人理解的时候的，人总是有要低声下气的时候，这些时候恰恰是人生最关键的时候，因为大家都会碰到挫折，而大多数人过不了这个门槛，你能过，你就成功了。在这样的时刻，我们需要耐心等待，满怀信心地去等待，相信，生活不会放弃你，机会总会来的。至少，你还年轻，你没有坐牢，没有生治不了的病，没有欠还不起的债。比你不幸的人远远多过比你幸运的人，你还怕什么？路要一步步走，虽然到达终点的那一步很激动人心，但大部分的脚步是平凡甚至枯燥的，但没有这些脚步，或者耐不住这些平凡枯燥，你终归是无法迎来最后的那些激动人心。

       逆境，是上帝帮你淘汰竞争者的地方。要知道，你不好受，别人也不好受，你坚持不下去了，别人也一样，千万不要告诉别人你坚持不住了，那只能让别人获得坚持的信心，让竞争者看着你微笑的面孔，失去信心，退出比赛。胜利属于那些有耐心的人。

         在最绝望的时候，我会去看电影《The Pursuit of Happyness》《Jerry Maguire》，让自己重新鼓起勇气，因为，无论什么时候，我们总还是有希望。当所有的人离开的时候，我不失去希望，我不放弃。每天下班坐在车里，我喜欢哼着《隐形的翅膀》看着窗外，我知道，我在静静等待，等待属于我的那一刻。

   七、入对行跟对人

       在中国，大概很少有人是一份职业做到底的，虽然如此，第一份工作还是有些需要注意的地方，有两件事情格外重要，第一件是入行，第二件事情是跟人。第一份工作对人最大的影响就是入行，现代的职业分工已经很细，我们基本上只能在一个行业里成为专家，不可能在多个行业里成为专家。很多案例也证明即使一个人在一个行业非常成功，到另外一个行业，往往完全不是那么回事情，“你想改变世界，还是想卖一辈子汽水？”是乔布斯邀请百事可乐总裁约翰・斯考利加盟苹果时所说的话，结果这位在百事非常成功的约翰，到了苹果表现平平。其实没有哪个行业特别好，也没有哪个行业特别差，或许有报道说哪个行业的平均薪资比较高，但是他们没说的是，那个行业的平均压力也比较大。看上去很美的行业一旦进入才发现很多地方其实并不那么完美，只是外人看不见。

        说实话，我自己都没有发大财，所以我的建议只是让人快乐工作的建议，不是如何发大财的建议，我们只讨论一般普通打工者的情况。我认为选择什么行业并没有太大关系，看问题不能只看眼前。比如，从前年开始，国家开始整顿医疗行业，很多医药公司开不下去，很多医药行业的销售开始转行。其实医药行业的不景气是针对所有公司的，并非针对一家公司，大家的日子都不好过，这个时候跑掉是非常不划算的，大多数正规的医药公司即使不做新生意撑个两三年总是能撑的，大多数医药销售靠工资撑个两三年也是可以撑的，国家不可能永远捏着医药行业不放的，两三年以后光景总归还会好起来的，那个时候别人都跑了而你没跑，那时的日子应该会好过很多。有的时候觉得自己这个行业不行了，问题是，再不行的行业，做得人少了也变成了好行业，当大家都觉得不好的时候，往往却是最好的时候。大家都觉得金融行业好，金融行业门槛高不说，有多少人削尖脑袋要钻进去，竞争激励，进去以后还要时时提防，一个疏忽，就被后来的人给挤掉了，压力巨大，又如何谈得上快乐？也就未必是“好”工作了。

         太阳能这个东西至今还不能进入实际应用的阶段，但是中国已经有7家和太阳能有关的公司在纽交所上市了，国美苏宁永乐其实是贸易型企业，也能上市，鲁泰纺织连续10年利润增长超过50%，卖茶的一茶一座，卖衣服的海澜之家都能上市……其实选什么行业真的不重要，关键是怎么做。事情都是人做出来的，关键是人。

         有一点是需要记住的，这个世界上，有史以来直到我们能够预见得到的未来，成功的人总是少数，有钱的人总是少数，大多数人是一般的，普通的，不太成功的。因此，大多数人的做法和看法，往往都不是距离成功最近的做法和看法。因此大多数人说好的东西不见得好，大多数人说不好的东西不见得不好。大多数人都去炒股的时候说明跌只是时间问题，大家越是热情高涨的时候，跌的日子越近。大多数人买房子的时候，房价不会涨，而房价涨的差不多的时候，大多数人才开始买房子。不会有这样一件事情让大家都变成功，发了财，历史上不曾有过，将来也不会发生。有些东西即使一时运气好得到了，还是会在别的时候别的地方失去的。

         年轻人在职业生涯的刚开始，尤其要注意的是，要做对的事情，不要让自己今后几十年的人生总是提心吊胆，更不值得为了一份工作赔上自己的青春年华。我的公司是个不行贿的公司，以前很多人不理解，甚至自己的员工也不理解，不过如今，我们是同行中最大的企业，客户乐意和我们打交道，尤其是在国家打击腐败的时候，每个人都知道我们做生意不给钱的名声，都敢于和我们做生意。而勇于给钱的公司，不是倒了，就是跑了，要不就是每天睡不好觉，人还是要看长远一点。很多时候，看起来最近的路，其实是最远的路，看起来最远的路，其实是最近的路。

        跟对人是说，入行后要跟个好领导好老师，刚进社会的人做事情往往没有经验，需要有人言传身教。对于一个人的发展来说，一个好领导是非常重要的。所谓“好”的标准，不是他让你少干活多拿钱，而是以下三个。

        首先，好领导要有宽广的心胸，如果一个领导每天都会发脾气，那几乎可以肯定他不是个心胸宽广的人，能发脾气的时候却不发脾气的领导，多半是非常厉害的领导。中国人当领导最大的毛病是容忍不了能力比自己强的人，所以常常可以看到的一个现象是，领导很有能力，手下一群庸才或者手下一群闲人。如果看到这样的环境，还是不要去的好。

        其次，领导要愿意从下属的角度来思考问题，这一点其实是从面试的时候就能发现的，如果这位领导总是从自己的角度来考虑问题，几乎不听你说什么，这就危险了。从下属的角度来考虑问题并不代表同意下属的说法，但他必须了解下属的立场，下属为什么要这么想，然后他才有办法说服你，只关心自己怎么想的领导往往难以获得下属的信服。

        第三，领导敢于承担责任，如果出了问题就把责任往下推，有了功劳就往自己身上揽，这样的领导不跟也罢。选择领导，要选择关键时刻能抗得住的领导，能够为下属的错误买单的领导，因为这是他作为领导的责任。

         有可能，你碰不到好领导，因为，中国的领导往往是屁股决定脑袋的领导，因为他坐领导的位置，所以他的话就比较有道理，这是传统观念官本位的误区，可能有大量的这种无知无能的领导，只是，这对于你其实是好事，如果将来有一天你要超过他，你希望他比较聪明还是比较笨？相对来说这样的领导其实不难搞定，只是你要把自己的身段放下来而已。多认识一些人，多和比自己强的人打交道，同样能找到好的老师，不要和一群同样郁闷的人一起控诉社会，控诉老板，这帮不上你，只会让你更消极。和那些比你强的人打交道，看他们是怎么想的，怎么做的，学习他们，然后跟更强的人打交道。

    八、选择

        我们每天做的最多的事情，其实是选择，因此在谈职业生涯的时候不得不提到这个话题。

        我始终认为，在很大的范围内，我们究竟会成为一个什么样的人，决定权在我们自己，每天我们都在做各种各样的选择，我可以不去写这篇文章，去别人的帖子拍拍砖头，也可以写下这些文字，帮助别人的同时也整理自己的思路，我可以多注意下格式让别人易于阅读，也可以写成一堆，我可以就这样发上来，也可以在发以前再看几遍，你可以选择不刮胡子就去面试，也可以选择出门前照照镜子……每天，每一刻我们都在做这样那样的决定，我们可以漫不经心，也可以多花些心思，成千上万的小选择累计起来，就决定了最终我们是个什么样的人。

         从某种意义上来说我们的未来不是别人给的，是我们自己选择的，很多人会说我命苦啊，没得选择阿，如果你认为“去微软还是去IBM”“上清华还是上北大”“当销售副总还是当厂长”这种才叫选择的话，的确你没有什么选择，大多数人都没有什么选择。但每天你都可以选择是否为客户服务更周到一些，是否对同事更耐心一些，是否把工作做得更细致一些，是否把情况了解得更清楚一些，是否把不清楚的问题再弄清楚一些……你也可以选择在是否在痛苦中继续坚持，是否抛弃掉自己的那些负面的想法，是否原谅一个人的错误，是否相信我在这里写下的这些话，是否不要再犯同样的错误……生活每天都在给你选择的机会，每天都在给你改变自己人生的机会，你可以选择赖在地上撒泼打滚，也可以选择咬牙站起来。你永远都有选择。有些选择不是立杆见影的，需要累积，比如农民可以选择自己常常去浇地，也可以选择让老天去浇地，诚然你今天浇水下去苗不见得今天马上就长出来，但常常浇水，大部分苗终究会长出来的，如果你不浇，收成一定很糟糕。

         每天生活都在给你机会，他不会给你一叠现金也不会拱手送你个好工作，但实际上，他还是在给你机会。我的家庭是一个普通的家庭，没有任何了不起的社会关系，我的父亲在大学毕业以后就被分配到了边疆，那个小县城只有一条马路，他们那一代人其实比我们更有理由抱怨，他们什么也没得到，年轻的时候文化大革命，书都没得读，支援边疆插队落户，等到老了，却要给年轻人机会了。他有足够的理由象成千上万那样的青年一样坐在那里抱怨生不逢时，怨气冲天。然而在分配到边疆的十年之后，国家恢复招研究生，他考回了原来的学校。研究生毕业，他被分配到了安徽一家小单位里，又是3年以后，国家第一届招收博士生，他又考回了原来的学校，成为中国第一代博士，那时的他比现在的我年纪还大。生活并没有放弃他，他也没有放弃生活。10年的等待，他做了他自己的选择，他没有放弃，他没有破罐子破摔，所以时机到来的时候，他改变了自己的人生。你最终会成为什么样的人，就决定在你的每个小小的选择之间。

         你选择相信什么？你选择和谁交朋友？你选择做什么？你选择怎么做？……我们面临太多的选择，而这些选择当中，意识形态层面的选择又远比客观条件的选择来得重要得多，比如选择做什么产品其实并不那么重要，而选择怎么做才重要。选择用什么人并不重要，而选择怎么带这些人才重要。大多数时候选择客观条件并不要紧，大多数关于客观条件的选择并没有对错之分，要紧的是选择怎么做。一个大学生毕业了，他要去微软也好，他要卖猪肉也好，他要创业也好，他要做游戏代练也好，只要不犯法，不害人，都没有什么关系，要紧的是，选择了以后，怎么把事情做好。

         除了这些，你还可以选择时间和环境，比如，你可以选择把这辈子最大的困难放在最有体力最有精力的时候，也可以走一步看一步，等到了40岁再说，只是到了40多岁，那正是一辈子最脆弱的时候，上有老下有小，如果在那个时候碰上了职业危机，实在是一件很苦恼的事情。与其如此不如在20多岁30多岁的时候吃点苦，好让自己脆弱的时候活得从容一些。你可以选择在温室里成长，也可以选择到野外磨砺，你可以选择在办公室吹冷气的工作，也可以选择40度的酷热下，去见你的客户，只是，这一切最终会累积起来，引导你到你应得的未来。

        我不敢说所有的事情你都有得选择，但是绝大部分事情你有选择，只是往往你不把这当作一种选择。认真对待每一次选择，才会有比较好的未来。

     九、选择职业

        职业的选择，总的来说，无非就是销售、市场、客服、物流、行政、人事、财务、技术、管理几个大类，有个有趣的现象就是，500强的CEO当中最多的是销售出身，第二多的人是财务出身，这两者加起来大概超过95%。现代IT行业也有技术出身成为老板的，但实际上，后来他们还是从事了很多销售和市场的工作，并且表现出色，公司才获得了成功，完全靠技术能力成为公司老板的，几乎没有。这是有原因的，因为销售就是一门跟人打交道的学问，而管理其实也是跟人打交道的学问，这两者之中有很多相通的东西，他们的共同目标就是“让别人去做某件特定的事情。”而财务则是从数字的层面了解生意的本质，从宏观上看待生意的本质，对于一个生意是否挣钱，是否可以正常运作有着最深刻的认识。

          公司小的时候是销售主导公司，而公司大的时候是财务主导公司，销售的局限性在于只看人情不看数字，财务的局限性在于只看数字不看人情。公司初期，运营成本低，有订单就活得下去，跟客户也没有什么谈判的条件，别人肯给生意做已经谢天谢地了，这个时候订单压倒一切，客户的要求压倒一切，所以当然要顾人情。公司大了以后，一切都要规范化，免得因为不规范引起一些不必要的风险，同时运营成本也变高，必须提高利润率，把有限的资金放到最有产出的地方。对于上市公司来说，股东才不管你客户是不是最近出国，最近是不是那个省又在搞严打，到了时候就要把业绩拿出来，拿不出来就抛股票，这个时候就是数字压倒一切。

         前两天听到有人说一句话觉得很有道理，开始的时候我们想“能做什么？”，等到公司做大了有规模了，我们想“不能做什么。”很多人在工作中觉得为什么领导这么保守，这也不行那也不行，错过很多机会。很多时候是因为，你还年轻，你想的是“能做什么”，而作为公司领导要考虑的方面很多，他比较关心“不能做什么”。

         我并非鼓吹大家都去做销售或者财务，究竟选择什么样的职业，和你究竟要选择什么样的人生有关系，有些人就喜欢下班按时回家，看看书听听音乐，那也挺好，但就不适合找个销售的工作了，否则会是折磨自己。有些人就喜欢出风头，喜欢成为一群人的中心，如果选择做财务工作，大概也干不久，因为一般老板不喜欢财务太积极，也不喜欢财务话太多。先想好自己要过怎样的人生，再决定要找什么样的职业。有很多的不快乐，其实是源自不满足，而不满足，很多时候是源自于心不定，而心不定则是因为不清楚究竟自己要什么，不清楚要什么的结果就是什么都想要，结果什么都没得到。

         我想，我们还是因为生活而工作，不是因为工作而生活，生活是最要紧的，工作只是生活中的一部分。我总是觉得生活的各方方面都是相互影响的，如果生活本身一团乱麻，工作也不会顺利。所以要有娱乐、要有社交、要锻炼身体，要有和睦的家庭……最要紧的，要开心，我的两个销售找我聊天，一肚子苦水，我问他们，2年以前，你什么都没有，工资不高，没有客户关系，没有业绩，处于被开的边缘，现在的你比那时条件好了很多，为什么现在却更加不开心了？如果你做得越好越不开心，那你为什么还要工作？首先的首先，人还是要让自己高兴起来，让自己心态好起来，这种发自内心的改变会让你更有耐心，更有信心，更有气质，更能包容……否则，看看镜子里的你，你满意么？

         有人会说，你说得容易，我每天加班，不加班老板就会把我炒掉，每天累得要死，哪有时间娱乐、社交、锻炼？那是人们把目标设定太高的缘故，如果你还在动不动就会被老板炒掉的边缘，那么你当然不能设立太高的目标，难道你还想每天去打高尔夫？你没时间去健身房锻炼身体，但是上下班的时候多走几步可以吧，有楼梯的时候走走楼梯不走电梯可以吧？办公的间隙扭扭脖子拉拉肩膀做做俯卧撑可以吧？谁规定锻炼就一定要拿出每天2个小时去健身房？你没时间社交，每月参加郊游一次可以吧，周末去参加个什么音乐班，绘画班之类的可以吧，去尝试认识一些同行，和他们找机会交流交流可以吧？开始的时候总是有些难的，但迈出这一步就会向良性循环的方向发展。而每天工作得很苦闷，剩下的时间用来咀嚼苦闷，只会陷入恶性循环，让生活更加糟糕。

repeat 南国的孩子

2010-02-28T17:23:00.001-08:00

南国的孩子-张悬
风扬起了你的黑发
你不经心地甩过鬓颊
笑可以天然地飘洒
心是一底草野
唯一的家乡
是我从不能朝仰的远方
夜晚你含泥土的气息
纯然原始的粗旷
冷地热著的眼神消长
你握有誓言般的梦想
即不能停止流浪
流浪
回声中有人呼喊
有人悼念
有人不言不语地明白
你是南国来的孩子
有著不能负的性子
身上披覆了预言而浑然不知
奔跑著忘我的快乐悲伤都放肆
阳光也不愿阻止
你是南国来的孩子
人要爱人要恨的样子
血里流窜著远在古老的故事
手心刻划上帝的仁慈
与未知相似
与未知相似
夜晚你含泥土的气息
纯然原始的粗旷
冷地热著的眼神消长
你握有誓言般的梦想
即不能停止流浪
流浪
你是南国来的孩子
有著不能负的性子
身上披覆了预言而浑然不知
奔跑著忘我的快乐悲伤都放肆
阳光也不愿阻止
你是南国来的孩子
人要爱人要恨的样子
血里流窜著远在古老的故事
手心刻划上帝的仁慈
与未知相似
你是南国来的孩子
有著不能负的性子
身上披覆了预言而浑然不知
奔跑著忘我的快乐悲伤都放肆
阳光也不愿阻止
你是南国来的孩子
人要爱人要恨的样子
血里流窜著远在古老的故事
手心刻划上帝的仁慈
与未知相似
与未知相似
与未知相似
与未知相似
相思

不是东北人，累死念不出来。

2010-02-24T17:43:00.001-08:00

东北孩子小的时候，玩嘎啦哈，弹流流，扇pia几，滑爬篱，男孩子皮实，不喜欢女孩子成天尿叽的样子，所以长大后特尿性。

东北孩子小的时候，门牙卡掉过，波了盖儿在马路牙子上卡突噜皮了，回到家后爸妈总会问：咋整的啊，一天天毛楞三光的！

东北孩子小的时候，贼淘，晒的雀黑，每晚回到家小脸都魂儿画儿的，爸妈总会说：成天遥哪瞎跑，瞅你那脸，埋了巴汰的！

东北孩子小的时候，上课不听讲，唠嗑，瞎闹，滋哇乔叫唤，把老师整激眼了说：天天上课瞎白乎，不听课！

东北孩子小的时候，在课堂上喜欢吵吵，吵吵到鸡赤掰脸，旁边的人烦了说：你们俩找削啊！东北孩子各应爱溜虚拍马的屁精，看见了总恨不得谁家的驴撂蹶子踢他一脚。

东北小伙儿总喜欢跟东北丫头疯，东北丫头总会先翻愣小小子，然后大叫：又晒脸，是吧！

东北姑娘不能惹，一惹就炸营。

东北小伙儿总是这么说东北姑娘，一天天贼能扎哄，长的苛碜不说还跟欠儿登似的，没有消停时候！

东北小伙儿没事时不喜欢和东北姑娘叽咯浪，卖呆儿的时候还得听生气的东北丫头在旁边念叨：脑瓜带疼啊！

东北小伙儿要是哪天歇罕哪个东北姑娘还不意思说，东北姑娘倒挺直接：瞅你一天天假假估估，扭扭捏捏，叽叽歪歪，吭吃瘪肚的样，是不稀罕我？说完脸也红。东北姑娘总是冷不丁的亲她对象东北小伙儿一口，东北小伙儿心里美滋儿的，嘴上却说：嘎哈啊，整我一脸！东北姑娘能胡咧咧，小嘴叭叭的，东北小伙儿不愿听就会鸟儿悄的走开。

东北的冬天大家最喜欢坐夜炕头，拥护啥？脑乎呗！

东北男人没事喜欢整几盅小烧,喝的直吐回到家，东北媳妇见了心疼嘴上却骂：瞅瞅你，得儿呵的，又整这么多，成天洋了二正、五迷三道的，让你喝你就喝，虎啊！

东北男人血性，尿性，讲究，对人贼拉热情，看到那种二虎巴唧的人总会说：俺们那旮旯儿压根就没有你这种人儿!

test blogger

2010-02-21T00:21:00.001-08:00

我的新技术博客地址：http://www.blogjava.net/crazycoding

test

2010-02-20T18:37:00.001-08:00

韩信点兵

2009-05-10T03:47:00.001-07:00

秦朝末年，楚汉相争。一次，韩信将1500名将士与楚王大将李锋交战。苦战一场，楚军不敌，败退回营，汉军也死伤四五百人，于是韩信整顿兵马也返回大本营。当行至一山坡，忽有后军来报，说有楚军骑兵追来。只见远方尘土飞扬，杀声震天。汉军本来已十分疲惫，这时队伍大哗。韩信兵马到坡顶，见来敌不足五百骑，便急速点兵迎敌。他命令士兵3人一排，结果多出2名；接着命令士兵5人一排，结果多出3名；他又命令士兵7人一排，结果又多出2名。韩信马上向将士们宣布：我军有1073名勇士，敌人不足五百，我们居高临下，以众击寡，一定能打败敌人。汉军本来就信服自己的统帅，这一来更相信韩信是“神仙下凡”、“神机妙算”。于是士气大振。一时间旌旗摇动，鼓声喧天，汉军步步进逼，楚军乱作一团。交战不久，楚军大败而逃。
韩信是怎么计算出来的，你能用程序验证出来吗？

public class Main{
public static void main(String[] args){
for(int i=1000;i<1100;i++){
if(isPassed(i,3,2) && isPassed(i,5,3) && isPassed(i,7,2)){
System.out.println(i);
}
}
}

public static boolean isPassed(int count,int m,int n){
return count % m==n;
}
}

求一百以内的质数和

2009-05-10T03:41:00.000-07:00

质数的定义：一个大于1的自然数,除了1与它自身外,再没有其它的正约数了,这样的自然数叫做质数。
现要求编写一个程序，将一百以内的质数总和求出。

int sum=0;

for(int i=2;i<100;i++){
if(isZhiShu(i)){
sum=sum+i;
}
}
System.out.println(sum);

public static boolean isZhiShu(int num){
for(int i=2;i< num/2+1;i++){
if(num%i==0)
return false;
}

return true;

}

找出10000以内的所有回文数

2009-05-10T03:40:00.000-07:00

即12321是回文数，个位与万位相同，十位与千位相同。
131是回文数
141是回文数
2992是回文数
3003是回文数
3113是回文数
3223是回文数
3333是回文数

int flag=0;
String s;
for(int n=0;n<10000;n++){
s="";
s=s+n;
flag=0;
for(int m=0;m< s.length();m++){
if(s.charAt(m)!=s.charAt(s.length()-m-1)){
flag=1;
}
}
if(flag==0){
System.out.println(s+" 是回文数");
}
}

鸡兔同笼问题

2009-05-10T03:36:00.000-07:00

这个问题，是我国古代著名趣题之一。大约在1500年前，《孙子算经》中就记载了这个有趣的问题。书中是这样叙述的：“今有鸡兔同笼，上有三十五头，下有九十四足，问鸡兔各几何？这四句话的意思是：有若干只鸡兔同在一个笼子里，从上面数，有35个头；从下面数，有94只脚。求笼中各有几只鸡和兔？
请用程序计算出来鸡和兔各多少只？

for(int j=0;j<=35;j++)
for(int i=0;i<=94/4;i++)
if(j*2+i*4==94 && i+j==35)
System.out.println("兔子："+i+" "+"鸡："+j);

ABCDE=4*EDCBA

2009-05-10T03:29:00.000-07:00

ABCDE=4*EDCBA;其中，A、B、C、D、E都是1-9中的数字。问这5个数字都是多少。

int a,b,c,d,e;
for(int i=10000;i<100000;i++){
a=i/10000;
b=(i-a*10000)/1000;
c=(i-a*10000-b*1000)/100;
d=(i-a*10000-b*1000-100*c)/10;
e=i%10;

int sum=40000*e+4000*d+400*c+40*b+4*a;

if(sum==i){
System.out.println(i);
}
}

结果：87912

马克思手稿中的数学题

2009-05-09T02:59:00.000-07:00

马克思手稿中有一道趣味数学问题：有30个人，其中有男人、女人和小孩，在一家饭馆吃饭花了50先令；每个男人花3先令，每个女人花2先令，每个小孩花1先令；问男人、女人和小孩各有几人？

设x,y,z分别代表男人、女人和小孩。按题目的要求，可得到下面的方程：
x+y+z=30 (1)
3x+2y+z=50 (2)
用方程程序求此不定方程的非负整数解，可先通过(2)-(1)式得：
2x+y=20 (3)
由(3)式可知，x变化范围是0~10

public class Main{
public static void main(String[] args){
int x,y,z;

for(x=0;x<=10;x++){
y=20-2*x;
z=30-x-y;

if(3*x+2*y+z==50){
System.out.println("男人数目为："+x+"女人数目为："+y+"小孩数目为："+z);
}
}
}
}

类加载器

2009-05-01T21:08:00.000-07:00

J2EE关于类加载的规范已经成为了J2EE的标准之一。　类加载是java语言提供的最强大的机制之一，但所有的编程人员都应该了解其工作机制，明白如何做才能让其满足我们的需要。这能有效节省我们的编码时间，从不断调试ClassNotFoundException的工作中解脱出来。

　　　类与数据　　

　　一个类代表要执行的代码，而数据则表示其相关状态。状态时常改变，而代码则不会。当我们将一个特定的状态与一个类相对应起来，也就意味着将一个类事例化。尽管相同的类对应的实例其状态千差万别，但其本质都对应着同一段代码。在 JAVA中，一个类通常有着一个.class文件，但也有例外。在JAVA的运行时环境中（Java runtime），每一个类都有一个以第一类(first-class)的Java对象所表现出现的代码，其是java.lang.Class的实例。我们编译一个JAVA文件，编译器都会嵌入一个public, static, final修饰的类型为java.lang.Class，名称为class的域变量在其字节码文件中。因为使用了public修饰，我们可以采用如下的形式对其访问：

java.lang.Class klass = Myclass.class;

　　一旦一个类被载入JVM中，同一个类就不会被再次载入了（切记，同一个类）。这里存在一个问题就是什么是“同一个类”？正如一个对象有一个具体的状态，即标识，一个对象始终和其代码(类)相关联。同理，载入JVM的类也有一个具体的标识，我们接下来看。　　

　　在JAVA中，一个类用其完全匹配类名(fully qualified class name)作为标识，这里指的完全匹配类名包括包名和类名。但在JVM中一个类用其全名和一个加载类ClassLoader的实例作为唯一标识。因此，如果一个名为Pg的包中，有一个名为Cl的类，被类加载器KlassLoader的一个实例kl1加载，Cl的实例，即C1.class在JVM中表示为 (Cl, Pg, kl1)。这意味着两个类加载器的实例(Cl, Pg, kl1) 和 (Cl, Pg, kl2)是不同的，被它们所加载的类也因此完全不同，互不兼容的。那么在JVM中到底有多少种类加载器的实例？下一节我们揭示答案。　　

　　类加载器　　

　　在JVM中，每一个类都被java.lang.ClassLoader的一些实例来加载.类ClassLoader是在包中java.lang里，开发者可以自由地继承它并添加自己的功能来加载类。　　

　　无论何时我们键入java MyMainClass来开始运行一个新的JVM，“引导类加载器(bootstrap class loader)”负责将一些关键的Java类，如java.lang.Object和其他一些运行时代码先加载进内存中。运行时的类在JRE\lib \rt.jar包文件中。因为这属于系统底层执行动作，我们无法在JAVA文档中找到引导类加载器的工作细节。基于同样的原因，引导类加载器的行为在各 JVM之间也是大相径庭。　　

　　同理，如果我们按照如下方式：

log(java.lang.String.class.getClassLoader());

　　来获取java的核心运行时类的加载器，就会得到null。　　

　　接下来介绍java的扩展类加载器。扩展库提供比java运行代码更多的特性，我们可以把扩展库保存在由java.ext.dirs属性提供的路径中。　　

　　(注：java.ext.dirs属性指的是系统属性下的一个key，所有的系统属性可以通过System.getProperties()方法获得。在编者的系统中，java.ext.dirs的value是” C:\Program Files\Java\jdk1.5.0_04\jre\lib\ext”。下面将要谈到的如java.class.path也同属系统属性的一个 key。)

类ExtClassLoader专门用来加载所有java.ext.dirs下的.jar文件。开发者可以通过把自己的.jar文件或库文件加入到扩展目录的classpath，使其可以被扩展类加载器读取。　　

　　从开发者的角度，第三种同样也是最重要的一种类加载器是AppClassLoader。这种类加载器用来读取所有的对应在java.class.path系统属性的路径下的类。　　

　　Sun的java指南中，文章“理解扩展类加载”（Understanding Extension Class Loading）对以上三个类加载器路径有更详尽的解释，这是其他几个JDK中的类加载器

　　●java.net.URLClassLoader
　　●java.security.SecureClassLoader
　　●java.rmi.server.RMIClassLoader
　　●sun.applet.AppletClassLoader

　　java.lang.Thread，包含了public ClassLoader getContextClassLoader()方法，这一方法返回针对一具体线程的上下文环境类加载器。此类加载器由线程的创建者提供，以供此线程中运行的代码在需要加载类或资源时使用。如果此加载器未被建立，缺省是其父线程的上下文类加载器。原始的类加载器一般由读取应用程序的类加载器建立。

类加载器如何工作？　　

　　除了引导类加载器，所有的类加载器都有一个父类加载器，不仅如此，所有的类加载器也都是java.lang.ClassLoader类型。以上两种类加载器是不同的，而且对于开发者自订制的类加载器的正常运行也至关重要。最重要的方面是正确设置父类加载器。任何类加载器，其父类加载器是加载该类加载器的类加载器实例。（类加载器本身也是一个类）　

　　使用loadClass()方法可以从类加载器中获得该类。我们可以通过java.lang.ClassLoader的源代码来了解该方法工作的细节，如下：

protected synchronized Class loadClass
　　(String name, boolean resolve)
　　throws ClassNotFoundException{
　　// First check if the class is already loaded
　　Class c = findLoadedClass(name);
　　if (c == null) {
　　try {
　　if (parent != null) {
　　c = parent.loadClass(name, false);
　　} else {
　　c = findBootstrapClass0(name);
　　}
　　} catch (ClassNotFoundException e) {
　　// If still not found, then invoke
　　// findClass to find the class.
　　c = findClass(name);
　　}
　　}
　　if (resolve) {
　　resolveClass(c);
　　}
　　return c;}
　　
　　我们可以使用ClassLoader的两种构造方法来设置父类加载器：
　　
　　public class MyClassLoader extends ClassLoader{
　　public MyClassLoader(){
　　super(MyClassLoader.class.getClassLoader());
　　}}
　　
　　或
　　
　　public class MyClassLoader extends ClassLoader{
　　public MyClassLoader(){
　　super(getClass().getClassLoader());
　　}}

　　第一种方式较为常用，因为通常不建议在构造方法里调用getClass()方法，因为对象的初始化只是在构造方法的出口处才完全完成。因此，如果父类加载器被正确建立，当要示从一个类加载器的实例获得一个类时，如果它不能找到这个类，它应该首先去访问其父类。如果父类不能找到它(即其父类也不能找不这个类，等等)，而且如果findBootstrapClass0()方法也失败了，则调用findClass()方法。findClass()方法的缺省实现会抛出ClassNotFoundException，当它们继承 java.lang.ClassLoader来订制类加载器时开发者需要实现这个方法。findClass()的缺省实现方式如下：

protected Class findClass(String name)
　　throws ClassNotFoundException {
　　throw new ClassNotFoundException(name);
　　}

　　在findClass()方法内部，类加载器需要获取任意来源的字节码。来源可以是文件系统，URL，数据库，可以产生字节码的另一个应用程序，及其他类似的可以产生java规范的字节码的来源。你甚至可以使用BCEL (Byte Code Engineering Library：字节码工程库)，它提供了运行时创建类的捷径。BCEL已经被成功地使用在以下方面：编译器，优化器，混淆器，代码产生器及其他分析工具。一旦字节码被检索，此方法就会调用defineClass()方法，此行为对不同的类加载实例是有差异的。因此，如果两个类加载实例从同一个来源定义一个类，所定义的结果是不同的。　　

　　JAVA语言规范（Java language specification）详细解释了JAVA执行引擎中的类或接口的加载（loading），链接（linking）或初始化（initialization）过程。　　

　　图一显示了一个主类称为MyMainClass的应用程序。依照之前的阐述，MyMainClass.class会被AppClassLoader加载。 MyMainClass创建了两个类加载器的实例：CustomClassLoader1 和 CustomClassLoader2,他们可以从某数据源（比如网络）获取名为Target的字节码。这表示类Target的类定义不在应用程序类路径或扩展类路径。在这种情况下，如果MyMainClass想要用自定义的类加载器加载Target类，CustomClassLoader1和 CustomClassLoader2会分别独立地加载并定义Target.class类。这在java中有重要的意义。如果Target类有一些静态的初始化代码，并且假设我们只希望这些代码在JVM中只执行一次，而这些代码在我们目前的步骤中会执行两次——分别被不同的 CustomClassLoaders加载并执行。如果类Target被两个CustomClassLoaders加载并创建两个实例Target1和 Target2，如图一显示，它们不是类型兼容的。换句话说，在JVM中无法执行以下代码：

　　Target target3 = (Target) target2;　　

　　以上代码会抛出一个ClassCastException。这是因为JVM把他们视为分别不同的类，因为他们被不同的类加载器所定义。这种情况当我们不是使用两个不同的类加载器CustomClassLoader1 和 CustomClassLoader2，而是使用同一个类加载器CustomClassLoader的不同实例时，也会出现同样的错误。这些会在本文后边用具体代码说明。

　　图1. 在同一个JVM中多个类加载器加载同一个目标类　　

　　关于类加载、定义和链接的更多解释，请参考Andreas Schaefer的"Inside Class Loaders."

为什么我们需要我们自己的类加载器

　　原因之一为开发者写自己的类加载器来控制JVM中的类加载行为，java中的类靠其包名和类名来标识，对于实现了java.io.Serializable接口的类，serialVersionUID扮演了一个标识类版本的重要角色。这个唯一标识是一个类名、接口名、成员方法及属性等组成的一个64位的哈希字段，而且也没有其他快捷的方式来标识一个类的版本。严格说来，如果以上的都匹配，那么则属于同一个类。

　　但是让我们思考如下情况：我们需要开发一个通用的执行引擎。可以执行实现某一特定接口的任何任务。当任务被提交到这个引擎，首先需要加载这个任务的代码。假设不同的客户对此引擎提交了不同的任务，凑巧，这些所有的任务都有一个相同的类名和包名。现在面临的问题就是这个引擎是否可以针对不同的用户所提交的信息而做出不同的反应。这一情况在下文的参考一节有可供下载的代码样例，samepath 和 differentversions，这两个目录分别演示了这一概念。

　　图2 显示了文件目录结构，有三个子目录samepath, differentversions, 和 differentversionspush，里边是例子：

　　图2. 文件夹结构组织示例　　

　　在samepath 中，类version.Version保存在v1和v2两个子目录里，两个类具有同样的类名和包名，唯一不同的是下边这行：

public void fx(){
　　log("this = " + this + ";
　　Version.fx(1).");
　　}

　　V1中，日志记录中有Version.fx(1)，而在v2中则是Version.fx(2)。把这个两个存在细微不同的类放在一个classpath下，然后运行Test类：　

set CLASSPATH=.;%CURRENT_ROOT%\v1;%CURRENT_ROOT%\v2
　　%JAVA_HOME%\bin\java Test

类的加载与查看

2009-05-01T20:44:00.000-07:00

即使有一个类并对它一无所知，但其实它本身就包括了许多信息，Java在需要使用到某个类时才会将类加载，并在JVM中以一个java.lang.Class的实例存在。从Class实例开始，可以获得类的许多信息。

1. Java在真正需要使用一个类时才会加以加载，而不是在程序启动时就加载。所谓真正需要通常指的是要使用指定的类生成对象时（或是用户指定要加载类时：Class.forName()、loadClass()）；声明并不导致类加载。

2.默认在类第一次被加载时会运行静态区域块

3. Class.forName(String name)（静态方法）实现动态加载类

4.static Class forName(String name,boolean initialize,ClassLoader loader)将initialize设置为false时,在加载类时并不会立即运行静态区块，而会在应用类建立对象时才运行静态区块。

5. Class对象表示所加载的类，取得Class对象之后，就可以取得与类相关联的信息

eg：
package 反射;
import java.lang.reflect.*;
public class SimpleClassViewer {

/**
* @param args
*/
public static void main(String[] arg) {
// TODO Auto-generated method stub
String args[]=new String [1];
args[0]="输入输出.CharArrayReaderWriterDemo";
try{
Class c=Class.forName(args[0]);
//取得包代表对象
Package p=c.getPackage();
System.out.printf("package %s;%n",p.getName());
//取得类型修饰，像class、interface
int m=c.getModifiers();
System.out.print(Modifier.toString(m)+" ");
//if is interface
if(Modifier.isInterface(m)){
System.out.print("interface ");
}
else{
System.out.print("class ");
}

System.out.println(c.getName()+" {");

Field[] fields=c.getDeclaredFields();
for(Field field:fields){
//显示权限修饰
System.out.print("\t"+Modifier.toString(field.getModifiers()));
//显示类型名称
System.out.print(" "+field.getType().getName()+" ");
//显示域成员名称
System.out.println(field.getName()+" ");
}

//取得声明的构造函数代表对象
Constructor[] constructors=c.getDeclaredConstructors();
//显示修饰权限
for(Constructor constructor:constructors){
System.out.print("\t"+Modifier.toString(constructor.getModifiers()));
//显示构造函数名称
System.out.println(" "+constructor.getName()+"();");
}

//取得声明的方法成员代表对象
Method[] methods=c.getDeclaredMethods();
for(Method method:methods){
//显示权限修饰
System.out.print("\t"+Modifier.toString(method.getModifiers()));
//显示放回类型名称
System.out.print(" "+method.getReturnType().getName()+" ");
//显示方法名称
System.out.println(method.getName()+"();");
}

System.out.println("}");
}

catch(ArrayIndexOutOfBoundsException e){
System.out.println("没有指定类");
}
catch(ClassNotFoundException e){
System.out.println("找不到指定类");
}

}

}

《潜伏》在办公室

2009-05-01T06:28:00.000-07:00

《潜伏》并不是间谍片，而是一部不可多得的职场教程。余则成的经历，有绝对的现实意义，他用亲身体验，教导我们如何在险恶的职场生存。
而现今的职场，比余则成面临的环境更糟糕，我们都是在狂涛骇浪里潜伏的小人物。

所以，研究专家“余则成”是怎么说，怎么做的吧。

1、办公室里只有两种人，主角和龙套。
在《潜伏》里，每个角色都有个性。只龙套非但没性格而且还专业送死。

职场上也一样，想要过的轻松，不想往上爬，那就只能做一辈子的龙套。
作龙套的坏处就是：送死你先去，功劳全没有，裁员先考虑。
现在的职场绝不是养懒人的地方，你要比别人生存的好，就唯有当主角，让别人去做龙套。
你不能踩着别人肩膀，就只能做他人垫背。

2、每个人都要有大志，就算要毁灭世界也可以。
胸怀大志是做主角的首要条件。
譬如余则成的信仰，站长的贪钱，马奎和陆桥山要当副站长，李涯为了党国事业，这些都是大志，而有理想存在才能为此奋斗。

在职场上，你若没有一个奋斗目标，就不可能进取的往上爬，到最后只能沦为龙套，成为别人的牺牲品。
所以不管毁灭世界，还是成为第一首富，你都必须心存志向，以此为目标。

3、别被理想忽悠，理想是需要的，但不是别人的理想，而是你自己的。
当提起大志时，有人会想到企业目标，想到企业文化，想到老板慷慨激昂的演说。
忘了那些吧，老板的理想只是老板的，而职场上，你是独立的。要保持清醒头脑，不能被轻易忽悠。

《潜伏》里，不管站长还是戴笠，甚至是余则成自己都会提到党国的事业。而实际上，他们心里都清楚的很，一切都该以自己为先，自己的大志才是可奋斗的目标。
不管别人有什么理想，要牢牢记住自己的大志，这才是立命之根本。

4、如果真的没大志，那就为钱奋斗。
《潜伏》里，站长说过一句话。每个人都有解甲归田的时候，如果不是为了钱，谁要当这个官呢。
所以赚钱是人最主要的追求。职场上很危险的局面，就是老板用理想笼络人，想让人不拿钱白干活。
但真的肯不要钱干活，那你就是没价值的，既然没价值，还有什么存在的必要呢？
金钱是唯一衡量你价值的东西。你真的一无所求的话，那就为赚钱而奋斗。

5、你可以不聪明，但不可以不小心。
《潜伏》里似乎每个人都聪明，其实翠平也很聪明，可为什么她就状况不断，最后还暴露身份。
就因为她不够小心。

职场与此一样，你可以不聪明，但不可以不小心。
不聪明的人，最多笨拙一些，事情做的差一些。而在职场上，这不是很大的罪过。

但不小心就随时会触犯到别人的利益，犯下得罪人这个职场大忌。
到那时，穿小鞋都不晓得是为什么穿的。
管牢嘴，能风花雪月的时候就少议论同事，能说人好话时就别说坏话。
这就是余则成的生存之道。

6、你说的每句话，老板都会知道。所以要好好想想该说什么，不该说什么。
别奢望你私下说的话老板就听不到。老板能知道一切，这是真理。
就像余则成给左蓝写信，自以为夹在书里没人知道，而实际上，他落下的每个文字，每句话都有人注意。

在职场上完全相同，只要你不是一个人自言自语，就得担心谈话对象会把话传出去。
而经验告诉我们，每一句对公司的议论，最后都会传到老板耳朵里。
所以你跟任何人说话时，都要好好想想，该说什么，不该说什么。
不该说的绝对不能说，可说可不说的也闭嘴。

7、偶尔对老板交心是必要的，但要有的放矢。
余则成和站长关系亦师亦友，可谓是站长的铁杆亲信，两人之间时不时有促膝长谈。

记住，促膝长谈是种手段，而不是真的让你什么都说。偶尔的交心，说些无关紧要的私己话，能让老板觉着你贴心。
而事实上，从没一个上司会对你真的交心。
切忌一热泪盈眶，就把心窝子都交出去。
被出卖的，永远是交心的那个。

8、不管什么时候，装傻总是最不易犯错。
在《潜伏》里，余则成看起来傻傻的。当别人问起一些紧要问题时，都会装傻，罔顾左右而言它。
这实在是很高明的生存术。

金庸也曾经说过，他年迈耳背后，该听见的话就能听见，不该听见的话就听不见。
当有人要你当面表态站队，要你选择事情的方向，不管你怎么选都是错的。
那么装傻就是最好的选择，这是没选择时最不易犯错的方法。

别担心装傻的样子很拙劣，即使每个人都看出你在装傻，可他们依旧拿你没办法。
真正倒霉的是那些明确表态的人，有这些龙套牺牲，怎么也轮不到你。

9、把自己当成最聪明的人，往往是最笨的。
在刚开始时，余则成向左蓝隐瞒自己是军统特务，向吕宗芳隐瞒左蓝是激进分子。余则成觉得自己能掌控大局，可实际上，他才是对方棋盘上的棋子。
左蓝和吕宗芳早就决定把他发展成共产党了。

在职场上，总把自己当最聪明的人，一定是做龙套的命。
真正聪明的高手，是大智若愚，该精明时精明，不该精明时装傻。

10、一定要有靠山，但比靠山还可靠的，是让自己有价值。
余则成向来是有靠山的人，一开始的吕宗芳，后来的站长，甚至是戴笠。正是这些靠山的存在，才让余则成多次转危为安，不引人怀疑。
但比靠山更重要的，是余则成本身的价值。
如果没有军统背景，吕宗芳绝不会拉拢他。如果没有立下大功，戴笠也不会青眼相加。如果他不能帮站长弄钱，也不可能获得庇护。

所以在职场中，和上司们搞好关系是一门必须的功课，为自己找好靠山很重要。
而比此更重要的，是让自己有足够的价值，以致于每个上司都必须拉拢你。

11、你是上司的人，上司却不一定是你的人，这层意思一定要明白。
当一个上司对你说，你是他的人时，心里一定要清楚，上司并不是你的人。
你是他的，他是他自己的。

在潜伏里，马奎曾经是毛人凤的侍卫，按说有此大靠山该有恃无恐才对。但马奎一出事情，毛人凤立刻就躲了。
当你的事情与上司的利益有冲突时，他们会毫不犹豫的出卖你。

无论何时都要记住，你是你自己的，只有你才能对自己负责。
别相信上司故作亲近的话，那随时都会是陷阱。

12、上司说他对你很放心，事实可能正好相反。
站长经常对余则成说，我对你很放心。可事实上，站长对余则成的试探调查从没停过。
如果上司真的对你放心，他根本不用经常提及。

真正的信任，是通过行动表现的。当上司愿意把害人的事情，把职场斗争的事情和你一起做，那才是信任的表现。
而上司口头说对你放心，则反而要当心了，很可能你做了什么，让上司产生你不忠的怀疑。

13、站在上司立场上想问题，站在自己立场上办事情。
当上司相信你，让你做一些事情时，心里必须要有本帐，别傻兮兮的什么都做。
你要站在上司立场上去考虑问题，了解上司为什么要做，能达到什么目的。然后再以自己的立场抉择，有些做，有些推脱。

就算是象余则成这样看似对站长忠心耿耿的人，也不是什么都会做的。
选择符合自己利益的事情去做，不符合利益的想法推搪。
用做了的事情取悦上司，而不做的事情则让上司知道，你已经完全尽力了。

14、上司突然垮台，不要惊慌，独自完成任务，然后借此再找到新的靠山。
《潜伏》里，余则成和吕宗芳被派去南京刺杀叛徒。而吕宗芳突然牺牲，余则成并没有慌张，反而独立完成任务，成为军统大功臣，完成了事业转折。

在职场里，经常发生上司突然垮台的事情。
如果你不幸遇见，千万别惊慌，独自完成手上的工作，而且要做的漂亮精彩。
而这就是你将来安身立命的资本，你可以借此找到新的靠山。

还是那句话，必须要让自己有价值，这比有人罩着你还重要。

15、做事做的好，干活干到老。
余则成并非总是聪明的，他与党组织相比就是弱者。余则成不懂得“做事做的好，干活干到老”这个道理，所以他从一开始做潜伏工作，一直到大陆解放后还必须做下去。
甚至与翠平生离死别，没有得到个人最佳结局。

“做事做的好，干活干到老”和“让自己有价值”这两句话间并没有矛盾。

价值是体现在关键处，是一个至关重要的地方才要突然爆发的。而无关痛痒时，尤其是做些没功劳只有苦劳的活，别做太好。

永远干得好，就会一直干下去。若让人觉得，你只有做庸碌工作的才能，就算干到累死，你也没有爬上去的那一天。

16、一定要有缺点。
在职场，一定要有缺点。即使象余则成这样，也并非完美，他会故意暴露一些缺点给人看，譬如感情，譬如贪财等。

一个完美而毫无缺点的人，为遭人嫉恨，会被人敬而远之。如果连上司都对你敬而远之，那职场之路就危险了。
所以聪明人会故意暴露些缺点，尤其是无关痛痒的缺点，让上司以为他能拿捏住你，那才是最安全的境地。

但缺点绝不可致命，却不能是你真正的短处，只可以是风花雪月时谈起的余兴节目，和人套近乎有余，想以此要挟则没门。

17、高你半级的人，往往是最危险的，同级的是天然敌人。
如果已经有一官半职，那对这句一定感同身受。
象余则成那样，比他高半级的马奎、陆桥山甚至李涯都十分危险，处处拿他当假想敌。

因为高你半级的人会有危机感，怕你随时都可能与他们平起平坐，所以有机会他们就会打击你。而不管高半级还是一级，都是上司，他们给你穿小鞋就危险万分了。
而同级的人是必然的敌人，只要你们的上司不是傻瓜，就一定会挑拨手下争斗。
这是中国五千年来的帝王术，是国粹。

18、十句里要有九句真话，这样说一句假话才有人信。
这是《潜伏》里很明显的情景。余则成说话并不总是假的，反倒有九句是真话。正是这样，他才能得到站长的信任，以致于连去台湾都要带着他。

职场中，九真一假也是最佳法则。一个满嘴跑火车的人是得不到上司信任的，只有忠心耿耿，几乎不说谎的人，才能够在最关键的时刻骗到所有人。

你要当老实人，老实人才能取信于人，没有别人的信任就没有关键时的谎言。
说谎只需要在最最关键的时刻，能少说一句就少说一句。
狼来了的故事，大家都应该听过。

19、把每个慌话都当成性命攸关，这样说谎就不会内疚。
职场上很关键的难关，就是怎么过自己心理关口。有些人天生不会说谎，一说谎就内疚。
这时候，就需要想起你的大志了。当一个人有志向，有理想，有信仰的时候，他就可以做任何事情。

余则成为了完成任务说过谎，杀过人，也做过很多坏事。这完全因为他有信仰在支撑，所以并不会内疚。
而你也要记住，每个谎言都可能是性命攸关，如果过不了自己的心，就可能实现不了自己的理想。

如果这么想了，你还会内疚么？

20、每个人都站在恶的那一面，因为各人有各人的善。
最后讲一句关于理想的道理。每个人都有自己的理想，而有利于自己理想的则是善，不利于别人理想的则是恶。
因人们各有各的立场，有不同的需求。所以在别人眼里，你必然站在恶的那面。
你永远都是自己的善，别人的恶。

但怎么样才是真正的大善，怎么样才是大恶呢？
为实现理想说一句谎，这是恶，但不是大恶。
而如果你的理想是毁灭世界，那才是大恶。
譬如你以事业红火，同事幸福为理想，那么就算为这个理想做了坏事，也不过小恶。
行大善而为小恶，历来被圣人们不齿。
可圣人自己也这么做。如此的圣人可以从孔子、孟子、王阳明一直排到更近更近。
儒教里有知行合一的法门，就是要你明白，只要理想大善，便可无所不为。

然而，
你必须真的确信自己的志向是善的。
就像余则成一样善。

Java书籍推荐

2009-04-29T23:02:00.000-07:00

Microsoft's Kumo

2009-04-29T06:46:00.000-07:00

Microsoft has reportedly put up a clock in one of its buildings with a 40-day countdown to the launch of its next-generation search engine, code-named Kumo.

Enthusiast site LiveSide noted on Sunday that a reader on Neowin, another enthusiast site, said that Microsoft had a TV in one of its search buildings with the countdown clock.

The software maker has been testing its search engine internally since last month, but has not said exactly when the service would launch. The countdown appears to roughly coincide with a speech from newly minted online boss Qi Lu, who is slated to speak at the SMX Advanced event on June 3. The timing also seems to coincide with reports that Microsoft plans a big ad campaign for its search engine starting this summer.

Microsoft declined to comment on the clock or its plans for Kumo.

Although Microsoft is testing the search engine under the Kumo name, executives have said that is just one of several names the company is considering.

The stakes for Microsoft are high. The software maker has remained a distant third in the search market behind Google and Yahoo, a position that makes it tough for the company to get the scale it needs to make money in the business. Even inside its own walls, Microsoft has struggled to get the use of its search engine where it would like.

Early screenshots of Kumo, seen by CNET News, show that the revamped search engine focuses on a couple of areas, including an attempt to break down a search query into a couple more detailed options. When searching, say, for the term "Audi," Kumo breaks things down into an initial result with facts such as price and fuel economy pulled out in bold, followed by general Web results, then results by category, such as Audi parts, used Audis, and Audi accessories.

（最新整理）国内网页设计网站网址大全【转】

2009-04-28T06:55:00.000-07:00

一、网页设计类

1. 蓝色理想 http://www.blueidea.com
2. 网页设计师联盟 http://www.68design.net
3. 网页设计大本营 http://www.code-123.com
4. 我爱设计网 http://www.52design.com
5. 视觉中国 http://www.chinavisual.com
6. 设计在线 http://www.dolcn.com
7. 网易学院 http://tech.163.com/school
8. 天极设计在线 http://art.yesky.com

二、图象处理类

1. 设计中国(中国PHOTOSHOP联盟) http://www.chinaddu.com
2. 图像谷 http://www.pstxg.com

三、动画设计类

1. 闪客帝国　http://www.flashempire.com
2. 闪吧 http://www.flash8.net
3. 闪盟在线 http://www.flashsun.com

四、网页素材类

1. 桌面城市 http://www.deskcity.com
2. 素材精品屋　http://www.sucaiw.com
3. 站酷(ZCOOL) http://www.zcool.com.cn
4. E库素材 http://www.iecool.com
5. 中国站长素材 http://sc.chinaz.com

五、程序开发类

1. CSDN开发者网络 http://www.csdn.net
2. MSDN 中文网站 http://msdn.microsoft.com/zh-cn/default.aspx
3. 动网先锋 http://www.cndw.com
4. 编程中国 http://www.bc-cn.net

六：网站源码类

1. 代码中国 http://download.csdn.net
2. 天新网源码下载 http://www.21tx.com/src
3. 源码之家 http://www.mycodes.net
4. 站长下载 http://down.chinaz.com

[转]国内WEB设计资源、教程、素材、站长资讯交流类网站汇集

以下排列不分先后

**************************************

WEB设计资源（素材、代码、特效类）：

**************************************

http://www.zcool.com.cn

站酷(ZCOOL),素材分享与设计交流,为您提供矢量素材,psd,png,gif,icon,psd分层素材,酷站等素材资源……

http://sc.chinaz.com/

素材图片下载网页模板图标下载酷站欣赏 QQ表情矢量素材音效下载桌面壁纸网页素材素材下载-中国站长站

http://sc.52design.com/

52design.com 素材、模板素材、矢量素材、flash源码素材、专业素材网

http://bolm.cn/

卜咯米Web设计交流社区是Web设计爱好者的家园，这里提供了精彩实用的Web设计相关教程和资源…

http://www.momii8.com/

末米吧提供丰富的背景图片、墙纸资源素材，并提供在线的演示功能，^0^设计师的好帮手！~

http://www.sccnn.com/

素材中国，关于各类设计素材的收集下载

http://www.lanrentuku.com/

懒人图库专注于提供网页素材下载，其内容涵盖网页素材、设计图库，小图片、网页背景、导航菜单、矢量图等，让任何一个网页设计师都能找到自己想要的素材！

http://www.ivsky.com/

天堂图库-专注的素材图片库，提供风景图片、生活图片、设计素材、商务图片、建筑园林图片、装饰家居图片、人物图库、动物植物图片和精美壁纸等超过80000张的图片素材。

http://cssrain.cn/

(前端技术)–读者的进步速度远大于博客的进步速度。 - cssrain,兔子,peter,笨笨,痕,区区,清夜无雨,重生,Deeka,亦飞,没剑,蚂蚁…

http://www.jzpu.com/

建站铺是一个完全免费的源码论坛，这里拥有丰富的建站源码资源，欢迎您的光临！

http://www.wzsky.net/

中国优秀综合设计门户网站.提供平面设计,广告设计,插画,室内设计,包装等作品,还有技术文章教程,网页模板,网页制作,素材下载服务,为站长及设计师提供最新最全的设计资讯与学习教程。

**************************************

网站建设讨论（站长交流、综合、咨询等）：

**************************************

http://community.csdn.net/

CSDN社区中心

http://bbs.blueidea.com/

专业的设计与技术支持，为您提供网站设计与网络技术支持、商业网站开发。DREAM TEAM 系列软件的技术支持。

http://www.admin5.com/

站长信息,联盟信息,网络赚钱信息中心,站长故事,个人网站发展经验技巧大全。

http://www.chinaz.com/

中国站长网，为站长提供及时全面的站长资讯

http://www.jz123.cn/

中国建站为中国站长提供及时全面的站长资讯以及建站源码和建站资源

http://www.itcaogen.cn/

草根网—用心营造IT人脉平台欢迎光临草根网 (http://www.itcaogen.cn)。草根是一群乐于分享、交流的互联网从业人员！欢迎加入草根的大家庭。

http://www.iresearch.com.cn/html/Default.html

艾瑞市场咨询集团

http://www.techweb.com.cn/

TechWeb.com.cn - 操作比理念更重要

http://www.donews.com/

DoNews.COM - IT 社区媒体平台

http://www.im286.com

落伍者站长论坛

http://bbs.phpchina.com/

PHPchina，中国开源之路

http://www.51js.com/

无忧脚本 -//体验编写HTML代码的乐趣

**************************************

WEB教程及手册类（设计教程、网页编程等）：

**************************************

http://www.knowsky.com/

动态网站制作指南

http://www.itwis.com/

IT知道网

http://www.webjx.com/

网页教学网–中国网页设计,网页制作第一站

http://www.jcwcn.com/

中国教程网-中国教程网

http://www.52css.com/

CSS Web Design 我爱CSS-Web标准化 Div+css教程

http://edu.chinaz.com/

中国站长学院,ASP,PHP,JSP,XML,SQL,FLASH,CSS,ASP.NET

http://www.dw8.cn/

Dreamweaver暨Web技术站

http://www.div-css.com/

Web标准化

http://www.google.cn/support/webmasters/

网站管理员/站长帮助

**************************************

常用工具类（查询工具，统计工具）：

**************************************

http://tool.chinaz.com/

中国站长网，查询工具大全

http://www.webmasterhome.cn/

中国站长之家提供网站综合信息查询,搜索引擎收录查询,网站收录查询,百度收录查询,Google收录查询,PageRank查询,反向链接查询, PR查询,IP地址查询,站长工具站全心全意为站长服务链接。

http://www.linkhelper.cn/

友情链接批量检查工具，本工具可以批量查询友情链接在百度的收录情况，快速获知哪些友情链接在百度收录数量为0，同时能查询友情链接的PR、以及对方是否有链接本站，即时了解哪些友情链接私自撤下链接。

http://www.vdoing.com/

维度,维度统计,下一代流量统计

http://www.51.la/

我要啦免费统计

http://www.cnzz.com/

中国站长广告联盟 - 免费网站流量统计，商业媒体统计

http://tongji.cn.yahoo.com/

雅虎统计免费网站流量统计分析系统。

**************************************

酷站鉴赏类（设计类酷站）：

**************************************

http://www.sj63.com/

::设计路上::酷站收藏大全,酷站欣赏,韩国网站欣赏,欧美网站,国内网站欣赏,设计欣赏，网页设计,网站建设,平面设计,韩国矢量素材下载

http://www.yi2.net/

依儿酷站,网站设计欣赏,网页设计,优秀网站欣赏,个人网站欣赏

http://main.68design.net/cool/

酷站-网页设计师加油站

http://www.webshu.net/cool/

叶子树-酷站欣赏

http://bolm.cn/special/cssgallery/

DIV+CSS设计酷站网址大全

http://www.3lian.com/cool/

酷站欣赏 -国内外酷站欣赏

http://www.kecola.com/

可酷啦—酷站欣赏|设计素材，精彩网站齐分享

http://www.zcool.com.cn/coolsite/index.html

酷站欣赏 - 站酷(ZCOOL)-素材分享与设计交流

继续收集中，大家有好的请补充。
原文链接

字符流

2009-04-26T22:22:00.000-07:00

Reader & Writer

支持Unicode标准字符集（字节流只支持ISO-Latin-1 8-bit）。在处理数据时，会根据系统默认的字符编码来进行字符转换，Reader & Writer 是抽象类，在进行文本文件的字符读写时真正会使用其子类
例：BIG5 &ASCII
package 输入输出;
import java.io.*;
public class ReaderDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String arg="test.txt";
try{
PushbackInputStream pushbackInputStream=
new PushbackInputStream(new FileInputStream(arg));
byte[] array=new byte[2];
ByteArrayInputStream byteArrayInputStream=new ByteArrayInputStream(array);
//reader会从已读的位数组中取出数据
InputStreamReader reader=new InputStreamReader(byteArrayInputStream);

int tmp=0;
int count=0;

while((count=pushbackInputStream.read(array))!=-1){
//两个字节转换为整数
tmp=(short)((array[0]<<8)|(array[1] tmp="tmp&0xffff;">=0xA440 && tmp<0xffff){
System.out.println("BIG5:"+(char)reader.read());
//重置ArrayInputStream的读取光标
//下次reader才会重新读取数据
byteArrayInputStream.reset();
}
else{
//将第二个字节推回流
pushbackInputStream.unread(array, 1, 1);
//显示ASCII范围的字符
System.out.println("ASCII:"+(char)array[0]);
}
}
pushbackInputStream.close();
}
catch(IOException e){
e.printStackTrace();
}

}

}

InputStreamReader　＆　OutputStreamWriter

分别为Reader和Writer的子类
对InputStream和OutputStream进行字符处理
例：文件复制
package 输入输出;
import java.io.*;
public class StreamReaderWriterDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String arg="test2.txt";
try{
InputStreamReader inputStreamReader=
new InputStreamReader(
new FileInputStream(arg));

OutputStreamWriter outputStreamWriter=
new OutputStreamWriter(
new FileOutputStream("backup_"+arg));

int ch=0;
while((ch=inputStreamReader.read())!=-1){
System.out.print((char)ch);
outputStreamWriter.write(ch);
}
System.out.println();

inputStreamReader.close();
outputStreamWriter.close();
}
catch(IOException e){
e.printStackTrace();
}

}

}

FileReader & FileWriter

存取的是文本文件
字符的转换会根据系统默认的编码
（若要指定编码，使用InputStreamReader & OutputStreamWriter）
例：
package 输入输出;
import java.io.*;
public class FileReaderWriterDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String arg="test.txt";
try{
FileReader fileReader=new FileReader(arg);
FileWriter fileWriter=new FileWriter(arg+".txt");
int in=0;
char[] wlnChar={'\r','\n'};
while((in=fileReader.read())!=-1){
if(in=='\n'){
//写入"\r\n"
fileWriter.write(wlnChar);
}
else
fileWriter.write(in);
}

fileReader.close();
fileWriter.close();
}
catch(IOException e){
e.printStackTrace();
}

}

}

BufferedReader & BufferedWriter

个拥有8192字符的缓冲区
例：
package 输入输出;
import java.io.*;
public class BufferedReaderWriterDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String arg="test.txt";
try{
BufferedReader bufReader=new BufferedReader(
new InputStreamReader(System.in));
BufferedWriter bufWriter=new BufferedWriter(
new FileWriter(arg));

String input=null;

//每读一行进行写入动作
while(!(input=bufReader.readLine()).equals("quit")){
bufWriter.write(input);
//newLine（）方法写入与操作系统相依的换行字符
bufWriter.newLine();
}

bufReader.close();
bufWriter.close();
}
catch(IOException e){
e.printStackTrace();
}

}

}

PrintWriter

例：
package 输入输出;
import java.io.*;
public class StreamWriterDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String arg="test.txt";
try{
//"简体中文"四个字的GB2312编码
byte[] sim={
(byte)0xbc,(byte)0xf2,
(byte)0xcc,(byte)0xe5,
(byte)0xd6,(byte)0xd0,
(byte)0xce,(byte)0xc4
};
//数组作为流来源
ByteArrayInputStream byteArrayInputStream=new ByteArrayInputStream(sim);
InputStreamReader inputStreamReader=new InputStreamReader(byteArrayInputStream,"GB2312");

//PrintWriter接受Writer实例作为变量
PrintWriter printWriter=
new PrintWriter(
new OutputStreamWriter(
new FileOutputStream(arg),"GB2312"));

int in=0;

printWriter.print("PrintWriter:");
//写入数组内容
while((in=inputStreamReader.read())!=-1){
printWriter.print((char)in);
}
printWriter.println();

printWriter.close();
byteArrayInputStream.reset();
//PrintStream接受OutputStream实例作为变量
PrintStream printStream=new PrintStream(
new FileOutputStream(arg,true),true,"GB2312");

printStream.print("PrintStream: ");
//写入数组内容
while((in=inputStreamReader.read())!=-1){
printStream.print((char)in);
}
printStream.println();

inputStreamReader.close();
printStream.close();
}
catch(IOException e){
e.printStackTrace();
}

}

}

CharArrayReader & CharArrayWriter

将位数组作为流入来源和输出目的
例：
package 输入输出;
import java.io.*;
import java.util.*;
public class CharArrayReaderWriterDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String arg="test.txt";
try{
File file=new File(arg);
BufferedReader bufInputReader=
new BufferedReader(
new FileReader(file));
//将文件读入字符数组
CharArrayWriter charArrayWriter=new CharArrayWriter();
char[] array=new char[1];
while(bufInputReader.read(array)!=-1){
charArrayWriter.write(array);
}
charArrayWriter.close();
bufInputReader.close();

//显示字符数组内容
array=charArrayWriter.toCharArray();
for(int i=0;i< array.length;i++)
System.out.print(array[i]+" ");
System.out.println();

//让用户输入位置与修改内容
Scanner scanner=new Scanner(System.in);

System.out.print("输入修改位置：");
int pos=scanner.nextInt();
System.out.print("输入修改字符：");
char ch=scanner.next().charAt(0);
array[pos-1]=ch;
//将字符数组内容存回文件
CharArrayReader charArrayReader=new CharArrayReader(array);
BufferedWriter bufWriter=
new BufferedWriter(
new FileWriter(file));
char[] tmp=new char[1];
while(charArrayReader.read(tmp)!=-1){
bufWriter.write(tmp);
}

charArrayReader.close();
bufWriter.flush();
bufWriter.close();
}
catch(IOException e){
e.printStackTrace();
}

}

}

二级语法190

2009-04-26T08:24:00.000-07:00

1　体言の｜たあげく（に）最后，结果是~~~ 往往用于不好的结果
例：いろいろ考えたあげく、学校をやめることにした（经过多方面考虑最后决定退学）。
長い苦労のあげく、とうとう死んでしまった。（长期辛劳最后终于死了）
2体言の｜用言連体形＋あまり　因过于~~~ 往往用于造成不好的结果
例：嬉しさのあまり、彼は泣いた（他因过于高兴而流下了眼泪）。
3である｜用言連体形＋以上（は）既然~~~就~~~
　例：約束した以上はまもらなければならない（既然约好了就得守约）
　　　学生である以上、よく勉強すべきだ（既然是学生就应该好好学习）。
4　～～～一方（では）～～～一方面~~~另一方面~~~
例：情熱も大切である一方、冷静（れいせい）な判断（はんだん）も必要です（热情很重要，另一方面冷静的判断也很需要）。
5用言連体形＋一方だ一直~~~，越来越~~
例：人口は増える一方だ（人口一直在增加）。
　　これからは寒くなる一方だ（今后将会越来越冷了）。
6体言の｜用言連体形＋うえに　而且，又
例：道に迷った上に雨に降られた（他迷了路，而且又被雨淋了）。
　　彼女は美人で、そのうえやさしい（他即漂亮又温柔）。
7体言の＋うえで（は）　在~~~方面
例：健康の上では別に問題はない（在健康方面没有什么问题）。
8体言の｜たうえで　~~~之后
例：詳しいことはお目にかかった上で、またご相談いたしましょう（详细情况等见了面再商量吧）。
9たうえは　既然~~~就~~~
例：こうなったうえはしかたがない（事情既然到了这种地步就没有办法了）。
10　うちに趁~~~ （趁着现在的状态未变~~~）
例：熱いうちに、召し上がってください（请趁热吃）。
11動詞未然形＋う｜ようではないか（じゃないか）让我们一起~~~吧（向大家发出呼吁号召）
例：もう一度よく考えてみようではありませんか（让我们一起再好好考虑一下吧）。
　　お茶でも飲もうか（让我们一起去喝点茶什么的吧）。
12動詞連用形＋得る（うる）｜得ない（えない）可能，会|不可能，不会
例：それはあり得ることだ（那是可能有的事）。
　　そんなことはあり得ない（那种是不可能有）。
13名詞の｜用言連体形＋おかげで（おかげだ）托~~的福，多亏（用于好的结果）よい結果の理由
例：傘を借りたおかげで、雨に濡れずにすんだ（多亏借了把伞才没被雨淋着）。
　　あの人のおかげで、私も合格した（托他的福我也及格了）。
14～～～恐れがある（おそれがある）恐怕~~，有~~~的可能|危险
例：努力しなかったら、落第する恐れがある（如果不用功的话，恐怕会考不上）。
15用言連体形＋かぎり只要~~~就~~~
例：私が生きている限りは、あなたに苦労はさせません（只要我活着就不让你受苦）。
16用言連体形＋かぎりでは在~~~范围内，据~~~所~~~
例：われわれの知っているかぎりでは、其の製品は国内でしか生産していない（据我所知，那种产品只在国内生产）。
17動詞連用形＋かける　①刚~~（表示动作刚刚开始）；②还没~~~完（表示动作进行到中途）③“就要~~~”表示动作即将开始。
例：①この肉は腐りかけているようだ（这种肉好像已经开始腐烂了）
②仕事をやりかけのまま、出かけたらしい（好像工作还没做完就出去了）。
③火が消えかけている（火就要灭了）
18動詞連用形がたい（難い）难~~~ 表示第一人称的感觉
例：今度の体験は忘れがたいものだ（这次体验真是难忘）
19名詞｜動詞連用形＋がち容易，常常一般用于不好或者消极的场合
例：その病気になってから、私は忘れがちになった（得了那场病之后我变得容易忘事了）。
20～～～かと思うと｜思ったら　　～～～思うと｜思ったら　以为是~~~却~~；刚~~~就
表示刚完成前项，紧接着进行或出现后项。（三P241）
例：故障かと思ったら、停電だった（我以为发生了故障原来是停电了）。
家の子は困ったものだ。学校から帰ってきたかと思うと、すぐ遊びに出ていってしまうんだから（我家的孩子真让人为难，刚从学校回来就

出去玩了）。
21～～～か～～ないかのうちに　刚要~~~就~~~
例：ドアをノックするかしないかのうちに、内側からドアが開かれた（刚象敲门，就有人从里边把门打开了）。
22動詞連用形＋かねる难以表示说话人对该事实的实现难以容忍或者认为有困难而加以拒绝
例：こんな重大な事は私一人では決めかねます（如此重大的事我一个人难以决定）。
23動詞連用形＋かねない　不见得不，也有可能一般用于不好的事情　　（四.P124）
例：あんなにスピードを出しては事故も起こしかねない（开得那么快，有可能会出事的）。
24動詞終止形｜名詞?形容動詞である＋かのようだ。好像，宛如，简直就像
例：水を飲むかのように、田中さんはコップを口に当てた（田中把杯子放在嘴边好像要喝水似的）。
　　禅は日本文化の代表であるかのように考えられている（禅就好像被看作日本文化的代表似的）。
25～～から～～にかけて从~~~到~~~ 用于时间和空间上
例：6月から7月にかけて雨がちの天気が続きます（从6月到7月持续阴雨天气）。
　　今朝、東北地方から関東地方にかけて、弱い地震がありました（今天早晨从东北地区到关东地区发生了微弱的地震）。
26体言からいうと｜からいえば｜からいって从~~~来说，从~~~方面考虑
例：人口から言えば、東京は今千二百万人ぐらいでしょう（从人口来说，东京恐怕有1千2百万人左右）。
　　我が家の収入からいって、学費のかかる私立大学に行くのは無理です（从我们家地说如考虑，读不起昂贵的私立大学）。
27体言からして从~~~来看；从~~~来说
例：実験の結果からして、成功までまだ遠いだろう（从实验的结果来看离成功大概还很遥远）。
　　名前からしておもしろい（从名字来说很有意思）。
28体言からすると｜からすれば以~~~来看。根据
例：この値段からすれば、これは本物のダイヤモンドではないだろう（以价格来看这部可能是真正的钻石）。
　　現場の状況からすると、犯人は窓から侵入したようだ（从现场来看，罪犯象是破窗而入）。
29用言終止形からといって｜からとて｜からって虽说~~~但~~~；尽管~~~也~~~，不能因为~~~就~~~
例：金持ちだからといって。幸せとはかぎらない（虽说有钱，但未必幸福）。
　　給料が安いからと言って、いいかげんな仕事をしてはいけない（不能因为工资低就工作马虎，不负责人|尽管工资低，但也不能工作马虎

不负责任）。
30名詞である｜動詞終止形＋からには（からは）既然~~~就~~~
例：学生であるからには、勉強をまず第一にしなければなりません（既然是学生就必须把学习放在第一位）。
　　日本に来たからには、日本の習慣に従います（既然来到了日本就要遵从日本的习惯）。
　　旅行に行くからには、何でも見ないと損だと思う（既然要去旅行，若什么也不看，呢就不合算了）。
31体言から見ると｜から見れば｜から見て｜から見ても从~~~方面来看
例：あの人の成績から見ると、大学受験はとても無理です（从他的成绩来看报考大学事态勉强了）。
　　彼女は、女の私から見ても、女らしく魅力がある（从我们女人的角度来看，我也觉得她很有女性魅力）。
32動詞｜助動詞連体形＋かわりに　虽~~~但~~~；同时
例：中村さんは遅刻もしないかわりに、仕事もあまりしない（中村虽然不迟到但也不怎么干工作）。
　　「終身雇用制について、どう思いますか。」「いい所もあるかわりに、悪い所もあります。」（你对终身雇佣是怎么看的？有好的一面

同时也有不足之处）
33名詞の｜動詞連体形＋かわりに　代替，代理　　表示补偿报答代替等，这个句型的前后两项必须是有同等价值的可以交换的。　（三P280

）
例：日本語を教えてもらうかわりに中国語を教えてあげましょう（你教我日语我来教你汉语吧）。
　　山田先生の代わりに、内山先生がこのクラスの受け持ち先生になった（内山先生代替上田先生担当这个班的班主任）。
34体言＋気味（ぎみ）有点有些（表示身心的感受感触等）
例：風邪気味で学校を休ませていただきます（因我有点感冒，请允许我请假）。
35きり｜きりだ从~~~以后就再也没|一直没~~~
例：朝出かけたきりまだ帰らない（从早上出去以后就再也没回来）。
張先生とは去年お会いしたきりです（去年根张老师见过一次面，之后就在也没见过）。
36動詞連用形＋切る｜切れる ~~~完（表示完结完成），完全|很~~~（表示达到极限）　
“切る”は他動詞です。“切れる”自動詞です。
例：読みきる（读完）。
疲れきっている（疲乏至极）。
　　人民は政府を信頼しきっている（人民完全信赖政府）。
本当に間違いだと言い切れますか（能断言真是错了吗？）。
37名詞の｜活用語連体形＋くせに明明~~~却~~~ 尽管~~~可是~~~。
“くせに”比“のに”含有更强的责怪和蔑视语气。一般用于伙伴之间的会话，不用于郑重谈话和书面语。后句内容假如不需明言可以省略。

　　（四P353）
例：子供のくせに、大人のような口調で話している（明明是个孩子却用大人的口吻说话）。
　　返事をすぐくれると約束したくせに、三ヶ月たってもくらない（说好马上给答复的，可是三个月都过去了，还没有答复）。
38用言連体形＋くらい｜ぐらい｜くらいだ｜ぐらいだ表示程度
例：この問題は子供でもできるくらい簡単です（这个问题简单的连小孩子都会）。
　　周りがうるさくて、声が聞こえないぐらいだ（周围吵的连说话声都听不清）。
39体言｜形容詞語幹｜形容動詞語幹｜動詞連用形＋げ～～～ ~~~的样子，好像~~
表示某种神情样子情形感觉。
例：希望のものが手に入り、満足げに帰っていった（的到了想要的东西，心满意足的回去了）。
　　彼女はとても仲の良い友達に死なれてから、いつも悲しげな顔をしている。（她自从最好的朋友去世以后，总是神情悲伤）
　　用ありげに近づく（像有事的样子走了进来）。
40こそ接在需要强调地词下面加强其语义和语气。 “才是”，“才能”
例：苦しい時にこそ。其の人の実力が試しされます（只有在艰苦的时候才能看出一个人的能力）。
　　太陽こそはあらゆる生命の源泉なのである（太阳才是一切生命的真正源泉）。
41～～～ことか别提有多~~~了。
例：先生のやさしい一言がどれほど嬉しかったことか（老师得一句亲切关怀，曾令我多么高兴啊）。
42用言連体形＋ことから　“因为”“从~~~来看”“由此” 表示判断
例：だれも英語が分からないことから、少しは分かる私が通訳をすることになった
（因为谁多不会英语，所以就由多少懂一点的我来做翻译。）。
たくさんの人が集まっていることから、何か事件が起こったと感じた。
（从许多人聚集在一起来看，感到发生了什么事故）
カモメが翼を動かさないで飛ぶことから、グライダーを考え出した。
（有人从海鸥不拍打翅膀就能飞翔中受到启发，由此是基础了滑翔机）
43 用言連体形現在式＋ことだ应该，最好
例：やはり自分でやることだ（最好还是自己做）。
　　健康になりたいなら、毎日運動することだ（要想身体健康就应该|要每天运动）。
44 ～～～ことだから　因为~~~一定~~~
例：「田中さんが病気らしいよ」“山田好像病了”
　　「元気な彼のことだから、すぐ治るでしょう」“因为他一向身体还好，所以很快就会痊愈吧”
45用言連体形＋ことなく不~~~
例：彼は朝早くから夜遅くまで、休むことなく活動しつづけた。
（他从清早起来就没休息一直忙到深夜）
46用言連体形＋ことに｜ことには　“令人~~~的是~~”
多接“驚く?困る?不思議?残念?嬉しい”等的词
例：残念なことに、君は一緒に行けないのだ。（遗憾的事，你不能一起去）
　　嬉しいことに（令人高兴的是）
　　驚いたことに?彼は10歳で作曲を始めたのだという。
（令人吃惊的是据说他10岁就开始作曲了）。
47用言連体形＋ことになっている｜こととなっている “按规定”
表示客观规定的存续。
例：日本に来た留学生は、最初の三ヶ月はアルバイトはできないことになっている。
“按规定来日留学生在最初的三个月不能打工”
48動詞連体形＋ことはない不必~~~
例：今度のテストは簡単ですから、心配することはないよ（这次测验很简单，不必担心）。
49体言の｜動詞連体形＋際｜際に｜際は ~~~时。~~~之际
例：お別れの際に申し上げたいことがあります（在此非别之际，有话和你讲）。
　　これは田中先生が国へ帰る際に私にくれた中日大辞典だ。
（这是田中老师回国时给我的《中日大辞典》）。
50～～～最中に｜最中だ “正在~~~的时候”“正在~~~中”
例：授業の最中にポケットベルが鳴って、皆びっくりした。
（正在上课的时候呼机响了，大家吓了一跳）。
雨が降っている最中に（正在下雨的时候）。
51～～～さえ｜でさえ　副助詞です、体言?副詞?助詞?活用語連体形に付きます。“でさえ”可作为一个固定的提示性副词使用，相当于“で

も”但语气更重。
例：平仮名さえ書けない（连平假名都不会写）。
　　温厚なあの人でさえ怒った（就连温文尔雅的他也发怒了）。
自分の名前さえ書けない（甚至连自己的名字都不会写）
52体言｜形容詞連用形｜断定助動詞で＋さえあれば　只要~~~就~~~　
例：これさえあれば、ほかには何にも要りません（只要有了这个，别的就什么也不需要了）。
　　品がよくさえあれば、どんどん売れる（只要东西好，就能畅销）。
　　金属でさえあればいい（只要使金属就行）。
53 動詞連用形さえすれば　只要~~~就~~~
例：あの二人は会いさえすれば、きっとけんかだ（那俩人，只要见面就吵架）。
54 体言さえ＋用言仮定形ば只要~~~就~~~
例：あなたさえ側にいてくれれば、私は満足です（只要有你在我身边，我就知足了）。
　　天気さえよければ、旅行に行く（只要天气好就去旅游）。
　　体が丈夫でさえあればよい（只要身体健康就好）。
55動詞未然形＋ざるを得ない｜ざるをえない不得不~~~
例：生活のためには、いやな仕事でも引き受けざるを得ない（为了生活，即使是讨厌的工作也不能不干）。
57名詞｜動詞終止形＋しかない只有；只能；只好
例：今日、百円しかないから、映画を見に行くことはできません。
（今天只有100日元，所以不能不看电影了）。
　　誰も助けてくれないから、もう一人で頑張るしかない（没人帮我，我只能以个人奋斗）。
　　暇がないから、断るしかない（因为没有时间所以只好拒绝了）。
58動詞連用形＋次第（しだい）一~~~就（立即）~~~
例：向こうに着き次第、電話をかけます（我一到那边就打电话）。
59　名詞｜動詞連用形＋次第だ｜次第で｜次第では全凭，要看~~~而定
例：世間に難事はなく、ただ心がけ次第だ（世上无难事，只怕有心人）。
　　行くかどうかは、お天気次第です（去不去要看天气情况而定）。
地獄（じごく）の沙汰（さた）も金次第だ（有钱能使鬼推磨）。
　　今忙しいが、その仕事、条件次第では引き受けないこともない
（现在我很忙，但是只要条件合适，也并不是不能接受那份工作）
60 ～～上｜上は｜上も在~~~上
例：制度上不可能だ（在制度上是不可能的|从规定来说是不可能的）
　　「いじめ」が教育上の大問題になっているのは日本だけではないらしい。
（“欺负”成为教育上的一大问题，好像不只日本如此）
61動詞未然形＋ずにはいられない｜ないにはいられない “不能不”“怎能不”
表示动作的主体在心情上不能不~~~
例：私はそれを聞くたびに、彼のことを思い出さずにはいられないのである。
（每当我听到那件事就不能不想起他来）
62体言の｜用言連体形＋せいだ｜せいで因为，是因为（用于不好的结果）
例：お前のせいで、僕はひどい目にあったのよ（都是因为你我才倒了大霉）。
　　私は薄着（うすぎ）をしているせいでしょうか少し寒気（さむけ）がしますね。
（我感到有点冷，可能是因为穿少了吧。）
63体言の｜用言連体形＋せいか也许是因为~~~（的缘故）吧（用于不好的结果）
例：覚えが悪いせいか、なかなか思い出せない（也许是因为记性不好吧，我怎么也想不起来了）。
64　体言｜用言連体形＋だけあって　不愧是
例：イタリアで修業しただけあって、彼らの料理はなかなかうまい。
（他不愧是在意大利学习过，意大利菜很拿手）
65体言｜用言連体形＋だけに正因为~~~所以
例：値段が高いだけに物もいいです（正因为价格高，所以东西也好）。
66動詞連体形＋だけの “足够的”，“所有的” 表示程度
例：あるだけの金は全部使い果たした（所有的钱都用完了）。
　　一年食べられるだけの食糧は貯えてある（たくわえてある）。
（储备这足够吃一年的粮食）
　　できるだけ努力する（尽量努力）。
67たとえ～～～体言｜用言連用形＋ても（でも）即使~~~也~~~
例：たとえ親が反対しても彼女と結婚する（即使是父母反对，我也要和她结婚）。
68～～～たところ～～～　①～～～結果～～～连接两个并存的事项，表示后项是前项的结果，前项是后项的契机。相当于“たら”的部分用

法。②“可是”“却”后项往往是与自己的意愿相反的事情③“刚~~”
例：組長に相談したところ、彼は大賛成した（我与组长商量了一下，结果他也非常赞成）。
　　わざわざ行ったところ、留守でした。（我特意去了，可是他却不在家）
　　帰ってきたところだ。（刚回来）
69連体詞その｜動詞過去式た＋とたん（とたんに） “刚一~~~就”
表示就在那一瞬间发生了什么什么事情
例：バスを降りたとたん、転んで倒れた（刚下公共汽车就跌到了）。
　　立ち上がったとたんに頭をぶつけた（刚一站起来就碰了头）
70体言の｜動詞連体形＋たび（たびに）“每次~~都”
例：この写真を見るたびに、なくなった友達のことを思い出す。
（每次看到这张照片我都回想起去世的朋友）。
71名詞だらけ　　“满，净，全”
例：家中（いえじゅう）ゴミだらけだ（家中满是垃圾）。
間違いだらけの作文（净是错误的作文|错误连篇的作文）。埃（ほこり）
だらけ（净是灰尘）。怪我をして血だらけになった（受了伤，浑身是血）。
72名詞の｜動詞終止形＋ついでに　　“顺便”
例：散歩のついでに手紙を出してきた（去散步顺便把信寄出去了）。
スーパーへ行くついでに、あの雑誌を買ってきてください。
（去超市时请顺便把那本杂志买回来）。
73～～っけ ①表示询问确认已经遗忘了的事情
②表示回忆起某件事，特别用来表示怀念过去的某件事。（三P262）
例：あの人は誰だっけ。（那个人是谁来着？）
　　ああ、いけない、今日の午後、会議があったっけ。すっかり忘れていた。
（啊，糟了，今天下午有个会，我忘的干干净净了）
　　学生時代、よくあの喫茶店で一緒に飲んだっけ。
（学生时代我们常常一起在拿加咖啡店喝咖啡）
74動詞連用形っこない　“决不会~~”“根本不会~~”
例：そんなことは子供にできっこない。（那种事情小孩子根本不会做）
75動詞連用形＋つつ　“一边~~一边”“一面~~一面” 是文章用語。
例：歩きつつ新聞を読む（一边走，一边看报纸）
76動詞連用形＋つつも｜つつ　虽然~~但是是文章用語
例：体に悪いと知りつつも、タバコを吸う。（虽然知道对身体不好，可还是吸烟）
77　動詞、助動詞連用形＋つつある “正在~~” 表示正在进行
例：彼女の考え方は変わりつつある。他的想法正在发生变化。
78　～～っぽい　“好~~ ”“容易~~” 表示具有某种气质
例：部長は怒りっぽい性格だから、気をつけて話しなさい。
　　忘れっぽい
79 動詞連用形＋て以来（ていらい）自~~~以来
例：入社して以来、一日休んだことがない。（自进公司以来一天也没休息过）
80　～～てからでないと～～ない｜～～てからでなければ～～ない
“没~~之前不~~” “如果不是~~~之后”
例：おいしいかどうかは食べてからでないと分からない。（是否好吃，没吃之前是不知道的）
6歳になってからでなければ、小学校に入学できません。（6岁之前不能进入小学读书）
81用言連用形＋てしょうがない “~~得不得了”“~~得没办法”
例：一人の生活は寂しくてしょうがない。（一个人的生活寂寞的不得了）
　　うちのおふくろ、うるさくてしょうがない。（我老妈唠唠叨叨的，都快把人烦死了）
82用言連体形｜形容動詞語幹＋てたまらない
“~~~得不得了”“~~得受不了” 表示程度严重。
例：胃が痛くてたまらない。（胃疼得不得了）
　　母の病気が心配でたまらない。（非常惦记母亲的病）
83 ～～ということだ。①“据说~~” 接在简体句后面，表示传闻。这种表达方式直接引用某特定人物的话的感觉很强。文章中常用「とのこ

とだ」　　（三P126）②“就是说~~”“意思是~~”=という意味だ
例：社長は今日はご出勤にはならないということです。（据说经理今天不上班）
　　石油の価格は近いうちにあがるとのことです。（据说石油价格近期会上涨）
　　指輪を返したのは、つまり私と結婚しないということだ。（把戒指还给我也就是说不想和我结婚）
84　～～～というと｜といえば｜といったら～～ “提起”“说起” 表示提起话题
例：外国語を習うには、どうすればいいかというと、まずよく外国語を話すことです．
（要说如何学外语，我认为首先要经常用外语说话）
　　紅葉（もみじ）といえば日光（にっこう）。（说起红叶，还是日光的好。）
85　～～～というものだ。这才真正是~~~
例：やれやれ、これで助かったというものだ（哎呀，可算得救了）。
　　試験に成功したことは誠におめでたい話で、まったく努力した甲斐があったということだ。（试验成功这实在是可喜的事，真是没有白

努力）。
86 ～～というものではない｜というものでもない “并不是~~”“也并不是~~”
例：仕事が大事だからといって、仕事さえしていればいいというものではない
（虽说工作中要，但也并不是只做工作就行。）
　　親が頭がいいから、子供も必ず頭がいいというものではない
（并不是因为父母聪明，孩子就一定聪明）
87　～～～というより与其说~~~
例：この料理は日本風というより、中華風なんじゃないの。
（这个菜与其说是日本风味，不如说更接近中国风味）
88　～～～といっても “虽然说~~~”“说是~~但~~”
例：日本語ができるといっても、小説が読めるほどではありません。
（虽然说是会日语也没有达到看懂小说的程度）
　　昔と言っても、そう昔のことではないが、こんなことがあった。
（说是从前，其实也不算太遥远，曾有这么一件事。）
89　体言の｜動詞連体形＋とおり “正如~~”“按照~~~”
例：昨日は天気予報のとおり、雨だった。（正如天气预报所说，昨天下了雨）
　代表団は予定どおり、東京に到着した。（代表团按照预定计划抵达了东京）
90 用言連体形｜体言＋どころか　“别说~~就连~~~也~~”“不仅不~~~反而~~”
例：漢字どころか、平仮名も書けない（别说汉子，就连平假名也不会写）。
各类法律都制定出来了，但是事端不仅没有减少反而再增加。
91 91体言｜用言連体形＋どころではない｜どころじゃない
“岂止”“远非”“哪能”（三P374）
例：海は冷たかったどころじゃありません。まるで氷のようでした。
（海水岂止是冷，简直就像冰）
　　そんなに忙しいのに、何を言っているのですか。今はそれどころじゃないよ。
（这样忙，你在说什么呀！现在不是这种时候）
　　「給料が安いんだってね。月、十二万円ぐらい？」
（说工资低，一个月有12万日元左右吧）
　　「十二万どころじゃないよ。」“哪由12万”
92　动词进行时+ところに “正当~~” 强调的是时间点
例：私が先生と相談しているところに、友達が尋ねてきました。
93　動詞連体形｜動詞ている＋ところへ　正当~~时，强调的是“ちょうどその時”
例：風呂に入っているところへ、電話がかかってきた。（郑洗澡时，来了电话）
　　出かけようとしているところへお客さんが来ました。（刚要出门时，来了客人）
　　店へ入ったところへ、彼女がやって来た。（我刚走进铺子里，她来了。）
94 ～～～ところを　①用言連体形＋ところを “本应~~可是~~”表示转折 ②動詞連体形｜動詞連用形ているところを “正在~~~的时候~~~

而” 强调的是在这个过程范围中
例：お忙しいところをお見送りいただき、どうもありがとうございます。
（在您很忙的时候特意来送我，谢谢您）
　　勉強しているところを写真に撮られた。（正在学习的时候被照了相）
　　二人で行けたすむところをなんで無愛想なおれへ口へかけたのだろう。
（两个人去不就行了吗？何必来找我这个不讨人喜欢的呢。）
95　～～～としたら｜とすれば “假如~~”“假设~~”
例：もし、ここに1億円あるとしたら、どうする。
（要是|假如这儿有一万日元，你打算怎么办）
　　一時間に5千ダース生産できるとすれば、8時間でいくら生産できるか。
（架设一小时能生产5千打的话，8小时能生产多少？）
96　用言終止形＋としても　即使~~~也~~
例：買うとしても、一番安いのしか買えない。（即使买，也只能买最便宜的。）
97　名詞として｜としては “作为~~~”
例：私は留学生として日本にやってきました。（我作为留学生来到了日本）
　　私個人としては、そのことに反対だ。（作为我个人我反对那件事）
98　体言｜用言終止形＋とともに　“和~~~一起”“随着~~~”
例：父と共に帰りました。（和父亲一起回去了）
　　年をとると共に、体が弱ってきたようだ。（随着年龄的增长，身体似乎也衰弱了）
99 動詞未然形＋ないことには　“如果不~~~”
例：努力しないことには、成功するはずがない。（如果不努力的话就不可能成功）
100　用言未然形＋ないことはない｜ないこともない “也并不是不~~~”“并非不~~~”
例：映画が見たくないこともないけど、忙しくて、時間がないんだ。
（也并不是不想看电影，只是太忙，没有时间。）
101　用言未然形＋ないではいられない　“不能不~~”“不由得~~”
表示动作的主体在心情上不能不|不由得~~~
例：それを聞いたら、心配しないではいられなくなりますよ。（一听这话我不能不担心啊）
　　悲しさのあまり彼女は泣かないではいられなかった。
（她因过于悲伤不由得哭了|情不自禁得哭了）
102 動詞?助動詞連用形｜形容詞終止形｜名詞?形容動詞語幹?副詞＋ながら
“虽然~~却~~” 表示转折
例：中国人でありながら、中国の歴史を全く知らない。
（虽然是中国人却一点也不了解中国的历史）
　　注意していながら、間違えてまいりました。（虽然注意了但还是出了差错）
　　彼の助言は少ないながら、的確だ。（他的劝言虽然没有几句，但却很适当）
　　このカメラが小型ながら、よく写る。（这个相机虽小却很好用）
103　～～～なんか “なんか”是“など的口语形式
例：テレビなんか見たくありません。（电视之类我可不想看）
　　あの店では、薬のほかにジュースなんか売っている。
（那家商店除了卖药之外，还卖果汁等东西。）
104　～～～なんて “~~~什么的”“~~~之类” （表示出意外轻视）
例：勉強なんていやだ。（我讨厌学习）
　　私は田中なんて学生は知りません。（我可不认识叫什么田中的学生）
　　よく考えもしないで分からないなんていうのはいけないことだ。
（不好好考虑一下就说什么不知道这可不好）
105　体言｜動詞連体形＋にあたって（にあたり）“当~~~之时”
例：開会にあたり、一言ご挨拶申し上げます。（在开会之际，我来讲几句|请允许我讲几句）
　　大学を卒業するに当たって、お世話になった先生方に記念品を贈ることにした。
（当大学毕业时，决定向关怀我们的老师们赠送纪念品）
106 体言＋において｜においては｜においても｜における “在~~~”
表示动作作用进行的场所场合范围。是书面语，在口语中一般用“で”（四P103）　　
例：1964年のオリンピックは東京において行われた。
（1964年的奥林匹克运动会是在东京举行的）
　　それは日本社会においては、建前っていうもんだよ。（这个在日本社会里称之为原则）
　　このテープレコーダは価格も安いし、性能の点においても申し分がない。
（这个磁带录音机不仅价格便宜，在性能上也无可非议）
　　日本におけるマスコミは非常にすばらしいものだ（在日本大众传媒是非常发达的。）
107　体言に応じて “按照~~”“根据~~~”“随着~~~”
例：お客の注文に応じて作っている。（按照客人们的定购要求来制作）
　　収入に応じて支出を考えなければならない。（必须根据收入来考虑支出）
　　科学の発達に応じて多くの新しい語が生まれました。
（随着科学的发展出现了很多新词汇）
108　～～～にかかわらず “不论|不管~~~”
表示不受某种情况的约束。此时一般接在“一对反义词”|“体言のいかん”的后面。（四P238）
例：昼夜にかかわらず仕事を続けている。（无论白天还是黑夜都继续工作）
　　好む好まないにかかわらず、やらなければならない。（无论喜欢或不喜欢，都必须干）
　　難しいやさしいにかかわらず、一度やってみるつもりだ。
（无论难易如何，我都打算是一下）
　　天候のいかんにかかわらず、運動会を行う。（无论天体好坏，运动会都照常进行）
109　～～～にもかかわらず“尽管~~~但是~~~”“虽然~~~但是~~”　简体句（体言或形容動詞谓语句时用である）｜体言｜形容動詞語幹｜

活用語連体形＋にもかかわらず　（四P238）
例：彼はまだ三十五歳の若さだ、それにもかかわらず、大学教授になった。
　　（他还很年轻，只有30岁，尽管如此，已经是大学教授了。）
周りが静か（なの）にもかかわらず、いつもと違う場所なので、ちっとも眠れない。
（尽管周围很安静，可是因为换了个地方，所以一点也睡不着）
ひどい災害にもかかわらず豊作をかちとった。
（尽管遇到了严重的灾害。可是仍然获得了丰收）
110　～～～にかかわる　　“与~~~有关”“关系到~~~”“涉及到~~~”（四P169）
例：それは私の名誉にかかわる問題ですから、気にしないわけにはいかないでしょう。
（那个问题关系到我的名誉，我不可能不介意吧。）
　　交通だの住宅だの、国民の生活にかかわる問題はさきに解決しなければならない。
（交通啦，住房啦，和人民参或有关的问题要首先解决。）
　　今度の取引は工場が生きていけるかどうかにかかわるのだから、、努力するよりほかない。（这笔买卖关系倒工厂的存亡，所以只有努

力干好。）
111　～～～にかかわりなく｜にはかかわりなく “与~~~无关”；“不论~~都”
例：会社での地位にかかわりなく~~~（与在公司里的地位无关~~~）
　　国家はその大小にかかわりなく、すべて平等であるべきだ。
（国家不论大小都应一律平等）
112　体言＋に限って|に限り（にかぎって｜にかぎり） “只有~~”“偏偏~~”
例：その日に限って帰りが早かった。（只有那天回去得比较早）
　　今日に限り、黙りにくっている。（偏偏今天一句话也不说）
113 体言＋に限らず（にかぎらず）“不仅|不但~~而且~~”“不论~~都~~~” 表示不仅A如此，B也如此。都如此。
例：男性に限らず、女性もその歌手が好きだ。（不仅是男性，连女性也喜欢那个歌手）
　　何事に限らず、公明正大でなければならない。（不论什么事都必须光明正大）
114　体言＋にかけては｜かけても “在~~~方面”“论~~~的话”（多表示好的方面）
例：料理にかけては、彼の右に出る者はいない（论烹饪，没人能比得上他）
115　体言＋に代わって（にかわって）｜に代わり（にかわり） “代替~~”
例：会長に代わって挨拶する。（代替会长致词）
　　一同に代わってお礼を言う。（代表大家致谢）
116　体言＋に関して｜に関しては｜に関しても｜に関する “关于~~”“有关~~”
例：そのことに関しては、私は何にも知らない。（关于那件事，我一无所知。）
　　水害に関する情報。（有关水灾的消息。）
117 体言｜用言連体形＋に決まっている（にきまっている）“一定~~”“必定~~”
表示强烈的断定或确信无疑的推测。
例：あのチームが勝つに決まっている。（那个对一定赢）
　　生きているものはいつか死ぬに決まっている。（活着的东西总有一天会死的）
118　～～～に比べて “与~~~~相比”“比起~~来~~”
例：若者に比べて、頭の回転が遅い。（比起年轻人来，思维迟钝。）
119　～～～に加えて｜に加え “加上~~”
例：人件費（じんけんひ）の高騰（こうとう）に加え（くわえ）円高（えんだか）が打撃（だげき）となって、倒産（とうさん）した。（

人工费暴涨，加上日元汇率上升的打击，破产了）。
120　体言＋にこたえる｜にこたえて｜にこたえ ①“符合~~”“响应~~”“应~~”表示不辜负某种希望要求或某种强烈的感受。②“深感~~

”表示强烈的打击影响感应
例：国民の期待に応える政策だ。（符合国民要求的政策。）
招きに応えて出席する。（应邀出席。）
　　寒さが体に応える。（严寒彻骨。）
121　体言＋際して “在~~~之际”“当~~~的时候”
例：卒業に際して、一言お祝いを申し上げます。（在大家毕业之际，我说几句仅表祝贺）
122　～～～に先立って｜に先立ち｜に先立つ “先于~~~”“在~~~前”
例：出発に先立って開幕式がある。（出发前有开幕仪式。）
123　動詞終止形＋にしたがって “随着~~~”
例：国が豊かになるにしたがって、私たちの生活も豊かになった。
（随着国家的富强，我们的生活也富裕起来了。）　
124　～～～にしても｜にしたら｜にすれば“即使~~也~~”“就~~~来说”“如果作为~~”
例：あまりかからないにしても、10万円ぐらいはかかりでしょう。
（即使花得不多，也需要10万日元左右吧。）
あの人の体にしたら～～～（就他的身体来说~~）
　　彼を仲間にすればいいだろう。（拉他入伙总可以吧。）
125　体言｜用言連体形＋にしては “作为~~~”“按~~~来说”表示后项提出的事实与前项设定的标准不相吻合。
例：歌手にしては歌が下手だ。（作为歌手来说歌唱的不好。）
　　この辺りは都心にしては静かな所だ。（按市中心来说这一带是挺静的。）
126　体言｜用言終止形＋にしろ｜にせよ “即使~~~也~~~”
例：忙しかったにしろ、電話を掛けるくらいの時間はあったろう。
“即使再忙，打个电话的时间总该有吧。”
127　体言｜用言連体形＋にすぎない “只不过是~~~”
例：それはただ口実（こうじつ）に過ぎない。（那只不过是借口。）
128　～～～に相違ない “一定~~”“肯定~~”
例：彼は国へ帰ったに相違ない。（他肯定回国了。）
129 体言＋に沿って｜に沿い｜に沿う｜に沿った “沿着~~~”“顺着~~~”“按照~~~”
例：この方針に沿って交渉する。（按照这个方针来交涉。）
130　体言＋に対して｜に対し｜に対しては｜に対しても｜に対する “对~~~”
例：目上の人に対しては、敬語を使うべきだ。（对长者应该是用敬语。）
131　体言｜用言終止形＋に違いない “肯定~~”“一定~~”
例：これは陳さんの忘れ物に違いない。（这肯定是小陈遗忘的东西。）
132　体言＋について “关于~~~”“就~~~”
例：料理について私は全然わかりません。（关于烹饪我是一窍不通。）
　　陳さんは日本の近代文学について卒業論文を書いています。
（小陈就日本近代文学些毕业论文。）
133　体言｜動詞連体形＋につき “因~~~”
例：病気につき、今日の会議に参加できません。（因病不能参加今天的会议。）
134　体言｜動詞終止形＋につけて｜につけては｜につけても “每逢|每当~~就~~”
例：梅が咲くにつけて、その花が好きだった母を思い出す。
（每当梅花开放时，我就想起喜欢梅花的母亲。）
135　動詞終止形＋につれて “随着~~~”“伴随~~”
（表示一方发生变化，另一方随之发生相当程度的变化）
例：月日が経つにつれて、いやなことは忘れてしまった。
（随着岁月的流失，不开心的事情渐渐忘却了。）
136　～～～にとって（は）　　“对~~~来说”「～～～を中心にして考えれば」的意思。
例：人間にとって一番大切なものは友情です。（对于人来说最重要的是友情。）
137　名詞｜動詞連体形＋に伴って “随着~~~”“伴随~~~”
例：自動車の数が増えるに伴って事故も多くなった。（随着汽车数量的增加，事故也增多了。）
138　体言＋に反して “违反~~`”“与~~~相反”
例：道徳に反する行為。（违反道德的行为）
　　太郎の不勉強に反して、次郎は勉強家だ。（与太郎的不爱学习相反，次郎很用功。）
139　体言｜動詞連体形＋にほかならない “无非是~~”“不外乎~~~”“正是~~”
例：今回の計画の失敗は推進委員会の責任にほかならない。
（这次计划的失败无非是推进委员会的责任。）
140　体言＋に基づいて｜に基づく “基于~~”“按照~~”“根据~~~”
例：法律に基づいて処理する。（按法律条文处理。）
141　体言＋によって｜による “由于~~~”“根据~~~”“因~~~的不同而~~~”“通过”
　　　体言＋によっては：强调的是个例。体言＋よって：讲述的是一般情况。（四P171）
　　　国によっては豚肉を食べないといったこともあります（有的国家不吃肉）。个例
　　　国によって生活習慣も違います（国家不同生活习惯也不同）。一般情况
例：火事はタバコの不始末によるものです。（火灾是由于吸烟不注意引起的）
　　成績によって、クラスを分けます。（根据成绩来划分班级。）
　　習慣は国によって違います。（习惯因国家的不同而不同）
　　私はラジオによって英語を習います。（我通过收音机学习英语。）
142　体言＋にわたって｜にわたる｜にわたり “历经~~~”“（范围）涉及到~~~”
例：手術は10時間にわたって行われた。（手术进行了10个小时。）
　　10年間にわたる研究が成功した。（历经十年的研究终于成功了。）
143 体言＋ぬきで｜ぬきでは｜ぬきに｜ぬきには “排去~~~”“出去~~~”“不包括~~”
例：お世辞ぬきで、本当に日本語が上手だ。（不是吹捧你，你日语真棒。）
144　動詞連用形＋ぬく “~~~最后|到底”表示做到最后，（最後までやる）
例：昨日の宿題は多くて難しかったですが、最後までやりぬきました。
（昨天的作业又多又难，可是我坐到了最后。）
　　頑張りぬく。（坚持到底。）
145　体言の｜動詞過去式連体形＋すえ（に）“～～～結果”
例：いろいろ考えた末に、あの人と結婚することにした。
（经过多方考虑，最后决定和他结婚）
　　相談のすえ、春休みを四月十日に改めました。（商量结果将春假改为4月10日）
146　体言｜用言連体形＋のみならず “不仅~~~”
例：君のみならず、僕もそうだ。（不仅是你，我也一样。）
　　勉強が足りないのみならず、態度も悪い。（他不仅不够用功而且态度也不好。）
147　～～～のもとに｜もとで“在~~~之下”“在~~~条件下” 表示前提条件。
例：先生方のご協力のもとで、試験は順調に行われました。
（在老师们的帮助下，考试尽心的很顺利。）
148　～～～ば～～～ほど “越~~~越~~~”
例：読めば読むほど俳句のおもしろさが分かります。（越读越能体味出俳句的趣味。）
149　体言｜用言連体形＋ばかりか｜ばかりでなく　
“不用说~~~就连~~~”“不仅~~~而且~~~”
例：あの人は漢字ばかりか、平仮名も片仮名も書けない．
（他不用说汉子，就连平假名片假名都不会写。）
　　李さんは日本語が話せるばかりか、英語も上手だよ。
（小李不仅不说日语，英语也很好。）
　　肉ばかりでなく、野菜も食べなければ、健康によくありません。
（不仅不吃肉，连蔬菜也不吃的话，不利于健康。）
150 用言連体形＋ばかりに “正因为~~~才~~~”“只因~~才~~~”
表示因为~~~而引起的不尽如人意的结果，讲话人常有遗憾后悔的心情。
例：医者であるばかりに、日曜日でも働かなければならない。
（只因为是医生，所以才在星期天也必须工作。）
151　体言＋はともかく｜はともかくとして “~~~暂且不谈”“~~~先不管”
例：ほかの人はともかく、君にだけは僕の気持ちを分ってもらいたい。
（别人暂且不谈，我只求你来理解我的心情。）
152　体言＋はもとより｜はもちろん “不用说~~”“当然~~”表示前项程度较轻，自不待言，后项也不在话下。“～～～はもちろん”主观

性较强，可用于口语书面语。“～～～はもとより”多用于书面语。
例：彼女は英語はもとより、フランス語もできろ。（不用说英语，他连法语也会说。）
153　動詞?形容詞の基本形｜形容動詞の連体形＋反面（半面）“另一方面”多用于对同一事物所具有的两个不同侧面的叙述。
例：輸送に便利な反面、時間がかかる。（运输方便，但花费时间。）
　　一定（いってい）の利益（りえき）が見込める（みこめる）反面、大きな損失を招く恐れもある。（虽然估计会有一定的利益，但另一

方面也担心会蒙受巨大的损失。）
154　動詞基本形｜サ変動詞語幹す＋べきだ｜べきではない。“应该”｜“ 不应该”多用于讲话人强调自己的主张建议。它强调的是个人的

意见。
例：バスの中では、若者は年寄りに席を譲るべきだ。（在公共汽车里，年轻人应该给老年人让座。）
　　親に対して、こんな失礼なことを言うべきではない。（不该对父母说这种无理的话。）
155　体言の｜用言連体形＋ほか（は）ない “只有”“只好”
例：どうもすみませんというほかはない。（只有说声对不起。）
　　あきらめるほかない。（只好死心。）
156　体言｜用言終止形＋ほど表示状态的程度。“到了~~~的地步”“~~~得~~”
例：新聞が読めないほど暗くなった。（暗的不能看报）。
　　寂しくて泣きたいほどだ．（寂寞的简直想哭。）
157　～～～ほど～～～ない　“不比~~~”“比~~~不~~” 表示否定比较。
例：今年は去年ほど暑くない。（今年不比去年热。）
158　体言｜用言終止形＋ほど “越~~~越~~~”
例：年を取るほど、物覚えが悪くなる。（年纪越大，记忆力越差。）
159　まい　是“否定推量助動詞”，表示①否定の推量＝“ないだろう” “恐怕不~~”②否定の意志＝“う｜ようとする” 五段動詞?助動

詞ますの終止形｜ほかの動詞の未然形＋まい
例：この様子では、明日も晴れるまい。（照这个样子，明天恐怕也不会晴。）
　　タバコはもう吸うまい。（我决心不再抽烟了。）
～～～まいか表示否定推测的疑问或反问。
帰国したのではあるまいか。（他不是回国了吧。|他不是回国了吗？）
～～～う｜ようか～～～まいか　“是~~~呢，还是不~~~呢”
帰ろうか帰るまいかと考える。（考虑是回去呢，还是不会去呢。）
160　体言＋向きだ｜向きに｜向きの “适合~~~的” 表示客观事物适合什么。
例：子供向きの番組“适合儿童看的节目。”
　　この料理は日本人向きだ。（这个菜是适合日本人口味的。）
161　体言＋向けだ｜向けに｜向けの “面向~~~” 表示主观能动以什么为对象干某事
例：若者向けに服装をデザインする。（面向年轻人设计服装。）
　　留学生向けに雑誌を編集する。（面向留学生编辑杂志。）
162　体言も＋用言仮定形ば｜たら＋体言も（～～～も～～～ば｜たら～～～も）“即~~~又”
例：お金もなければ、暇もない。（即没钱，有没时间。）
163　体言＋もかまわず “不管~~~”“不理睬~~”“不介意~~”
例：人目もかまわずキスしている。（旁若无人的接吻。）
　　所もかまわず大きい声を出す人だ。（是个不分场所大声嚷嚷的人。）
164　活用語終止形＋もの　“もの”：終助詞、以抱怨或不满的口气说明或辩解某种原因理由。多为女性或儿童使用，口语中也做“もん”
例：だって知らなかったもの。（可我不知道嘛！）
　　私の言ったこと聞かないもの。（我说的也不听啊。）
165　用言連体形＋ものがある　“有~~~的东西”“有~~~的成分”
例：彼の音楽の才能にはすばらしいものがある。（他的音乐才能有很了不起的地方。）
166　活用語連体形＋ものか “哪能|岂能|怎能~~~呢？” 男子也可用“もんか” 表示强烈的反问。（三P125）
例：一組に負けるものか。（岂能输给一班呢！）
167　動詞?活用語連体形＋ものだ｜ものではない。“应该”“理应”“自然”｜“不该”“不要”（三P214）表示一般的社会伦理习惯和必

然的结果。否定表示：对违反道理常识习惯的事给予以告诫或劝说。
例：年を取ると目が悪くなるものだ。（年纪大了，眼睛自然就不好使用了。）
　　人のお宅へ伺う時は、電話をしてから行くものだ。
（到别人家拜访时，应该先打电话然后再去。）
いくらうまくても、そんなにたくさん食べるものではない
一度太ってしまうと、そう簡単にやせられるものではない。
人の悪口を言うもんじゃない。
168　用言連体形＋ものだから｜ものですから　表示主观强调原因理由，往往带有辩解的语气。与もので意义相同，但是比它更强调主观认定

的原因。ものだから在口语中也可以讲成もんだから。（相关内容见三P215 四P348）
例：出がけにお客さんがきたものだから（是因为除去的时候来了客人）。
　　雨がひどいものだから、どうしても出られない（是因为雨太大，怎么也出不了门）。
もので表示确定顺接条件，多用于解释说明（甚至辩白）产生某项结果的原因，有比ので语气更强烈的感觉。后项是既成事实，有时也讲成も

んで。
　　昨夜遅くまで起きていたもので、朝寝坊してしまいました（是因为昨晚睡得太晚了，所以才睡早觉了）。
　　あまり天気がいいもので?どこかへ出かけたくなった（是因为天气太好了，所以我想起什么起放玩玩）。
区别：名詞の＋ことだから：前项或明或暗的点明该名词具有的特征，后项多是根据前项做出的判断推测，前项多是表示人物的有关名词，后

项多“きっと”“どうせ”等呼应。可以翻译为“因为|既然~~~~”，例子见第44条。用言連体形＋ものだから：则是主观强调原因理由，往往

带有辩解的语气，后项是既成事实。
169　活用語連体形＋ものの　“虽然~~~但是~~~”“虽说~~~可是~~~” 表示承认前项是事实，即“それはほんとうだ”但后项却是与前项不

相符的事实。常有“とは思うものの”“とはいうものの”
例：材料を買ったものの、作り方が分からない。
　　この本を読んだことがあるとはいうものの、何十年も前のことなので、詳しい内容ははっきり覚えていない。
170　～～～ものなら “如果~~就~~”　推量助動詞う｜よう、可能動詞、助動詞の連体形＋ものなら
“ものなら”，有两种用法
1 　“可能動詞?助動詞の連体形+ものなら”　“万一|假如~~~就~~~”　「假定一种不能实现的事实」万一，假如。例如：①一人で行けるも

のなら、行っててみなさい（你一个人能去的话，你就去一下吧）。②そんなことでいいものなら、誰にでも出来ます（如果那样就行的话，

谁都会做）。③そんなにたくさん食べるものなら食べてごらん（如果你能吃那么多，那你就吃吃看）。
2　 “う｜よう +ものなら” 「假定一种将导致坏结果的事实」如果````可```前面的“う｜よう”即是意志形。例如：①そんなことをしよ

うのもなら、大変だ。（要是干那种事，可了不得）。②嘘をつこうものなら、ただではおかない（如果你要说谎的话，我可轻饶不了你）。

③私に黙って勝手なことをしようものなら、決して許しませんよ（要是背着我随便搞的话，我可决不答应）。
171　～～～やら～～～やら “~~~啦~~~啦” 表示并列列举两个以上的事物，含有暗示其它的语气。
例：損をしているのやら、得をしているのやら、一向に分かりません（什么赔啦赚了，一点也不知道）。
お花やらお茶やら習う（学习话道啦茶道了等）。
172　動詞連用形＋ようがない｜ようもない “无法~~”“不能~~~”
例：こんなに壊れては直しようがない（坏成这样子，没法修了）。
　　言いようもないほど美しい（无法形容的美）。
　　どうしようもない（毫无办法）。
173　活用語連体形＋ように　“ように”は比況助動詞“ようだ”の“連用形”です。表示目的，“为了~~”“以便~~~”
例：汽車に間に合うように、早めに出かけた（为了赶上火车，提前出门了）。
　　遅刻しないように気をつけてください（请注意不要迟到）。
　　風をよく通るように、もっと窓を開けなさい（请把窗子开的大一点，以便好好透透风）。
174　用言連体形＋わけはない｜わけがない “不会~~~”“不可能~~~” 表示从道理情理商认为某件事是不可能的。
例：帝国主義の本質は変わるわけはない（帝国主义的本质是不可能改变的）
175　用言連体形＋わけだ　“当然”“自然” （三P192）表示某事项的成立理所当然，是某种原因导致的自然而然的结果。使句子含有是这

么一种情况这么一种道理的语气。可不必翻译出来。
例：それなら、起こるわけだ。（那样的话当然要生气）
“わけ”と“はず”の区別：
わけ：对某种已经实现的事实所做的解释和判断
はず：在某种根据的基础上所做的推理
例如：彼女は日本に10年もいたから、日本語が上手なわけだ
（她在日本呆了10多年，日语当然好。）
　　　彼女は二本に10年もいたから、日本語が上手なはずだ。
（她在日本已经呆了10多年，日语应该好）
176　～～～わけではない｜わけでもない “并非”“并不是”
例：彼一人が悪いというわけではない（并不是他一个人不好）。
177　～～～わけにはいかない｜わけにもいかない “不能~~`”　
例：いくらいやでも、やめるわけにはいかない（无论怎么讨厌也不能辞去不干）。　
　　いくら痩せたくても、何にもたべないわけにはいかない（无论怎么想减肥也不能什么也不吃）。
178　体言の｜用言連体形＋わりに（は） “虽然~~但是~~”表示比较的程度，转折关系。表示从前项内容考虑，后项内容出人意料不搭配。
例：この酒は値段のわりにおいしい（这酒不贵却好喝）。
　　日本は狭いわりに、人口が多い（日本岁让国土狭小，但是人口众多）。
　　区别：体言｜用言連体形＋にしては　第125条。在语气上“～～にしては”比“～～～にわりに”更强烈。接続方法も違います。
179　体言＋を体言として｜とする｜とした “把~~~作为”“把~~~当作”
例：社会奉仕を目的とする団体（以服务社会为目的的团体）
　　田中さんをリーダーとするサークルを作った（成立了以田中为领导的小组）。
180　体言＋をきっかけに｜きっかけとして｜きっかけにして “以~~~为契机”
例：これをきっかけにして話を始めた（以次为契机说了起来）。
　　両学をきっかけとして、彼女と別れた（以留学为契机，与女友分手了）。
181　体言を機会に｜機会として｜機械にして　“以~~~为機会|开端” “趁着~~~”
例：これを機会にいつまでもご交際をお願いします（希望我们以次为开端永远交往下去）。
　　株価の暴落を機械として恐慌が起きた（以股票暴跌为起点，发生了恐慌）。
182　体言をこめて　“充满~~”“满怀~~~”
例：心をこめて～～～（真心的~~~）
　　愛をこめて見つめる（充满爱意的注视）
183　～～～体言＋を中心に｜中心として｜中心にして “以~~~~为中心”
例：あの子を中心にしてまとまった。（以那孩子为中心团结起来了）
　　城を中心にして町を造った（以城堡为中心建立了城市）。
184　体言を通して “通过~~~”
例：日本人はさまざまな共同点を通して、強い集団意識で結ばれている。
（日本人通过各种共同点以强有力的集团意识结合在一起）
　　現象を通して本質をつかむ（透过现象抓住本质）。
185　体言＋を通じて　“通过|利用~~”“在整个~~~期间|范围内”
例：ラジオやテレビを通じて知らせる（通过收音机电视通知）。
兄を通じてお願いしたこと（通过哥哥拜托您的那件事）。
　　南の国は一年を通じて暖かい。（南部国家一年到头都很温暖）
　　この仕事は彼の一生を通じてもっとも困難な仕事だった
（这工作是他一生中最艰难的工作）。
テレビは全国を通じて放送されている。（电视面向全国播放）
186　体言｜用言終止形＋を問わず｜は問わず “不问~~”“不管~~”“不论~~”表示后项不受前项情况条件性质等的限制。
例：国はその大小を問わず一律に平等でなければならないと主張しているのである
　　（我们主张国家不论大小一律平等）
　　この試合には、年齢を問わず、出れでも出られます。
（这次比赛不问年龄，这都可以参加）
187　体言＋を抜きにして｜を抜きしてしは｜は抜きにして “省去~~~”“不~~”
例：冗談は抜きにして、本当のことはどうなんですか（不开玩笑了，究竟是怎么回事啊？）。
　　説明を抜きにして、すぐ討論に入ります（不作说明马上进入讨论）。
188　体言＋をはじめ｜はじめとする “以~~~为首”
例：石川教授をはじめとする研究チーム（以石川教授为首的研究小组）
　　社長を始めとして、社員全員が式に出席しました
（以社长为首，全体职员都出席了会议）。
189　体言＋をめぐって｜めぐる “围绕着~~~”
例：国際結婚をめぐる問題が多い（围绕着国际婚姻的问题很多）。
190　体言＋をもとに｜をもとにして “以~~~为根据”“以~~为基础”
例：20年前の事件をもとにして、小説を書きました（以20年前的时间为根据写了篇小说）。
　　この記事は二人の学者の対談をもとにして書かれたものです
（这篇报道是以两位学者的谈话为基础写成的）。

位流

2009-04-26T06:53:00.000-07:00

InputStream & OutputStream

InputStream是所有表示位输入流的类的父类，它是一个抽象类，继承它的子类需要重新定义其中所定义的抽象方法。InputStream是从装置来源地读取数据的抽象表示
例如System中的标准输入流in对象就是一个InputStream类型的实例。在Java程序开始之后，in流对象就会开启
同理OutputStream & 对应的out对象

例：in对象的read（）方法一次读取一个字节的数据，读入的数据以int类型返回。所以在使用out对象将数据显示出来时，就是10进制方式
package 输入输出;
import java.io.*;
public class StreamDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try{
System.out.print("输入字符:");
System.out.println("输入字符十进制表示："+System.in.read());
}
catch(IOException e){
e.printStackTrace();
}

}

}
运行结果：
输入字符:A
输入字符十进制表示：65

FileInputStream & FileOutputStream

当建立一个FileInputStream 或FileOutputStream的实例时，必须指定文件位置及文件名称，实例被建立时文件的流就会开启；而不是用流时必须关闭文件流，以释放与流相依的系统资源，完成文件读/写的动作
FileInputStream可以使用read（）方法一次读入一个字节，并以int类型返回，或者是使用read（）方法时读入至一个byte数组（缓冲区）
例：复制文件
package 输入输出;
import java.io.*;
public class FileStreamDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] fs=new String[2];
fs[0]="D:\\日本語\\二级\\2级语法\\2级语法190.doc";
fs[1]="test.doc";
try{
byte[] buffer=new byte[1024];
//来源文件
FileInputStream fileInputStream=new FileInputStream(new File(fs[0]));
//目的文件
FileOutputStream fileOutputStream=new FileOutputStream(new File(fs[1]));
//available()可取得未读取的数据长度
System.out.println("复制的文件："+fileInputStream.available()+"字节");

while(true){
if(fileInputStream.available()<1024){
//剩余的数据比1024少，一位一位读出再写入目的文件
int remain=-1;
while((remain=fileInputStream.read())
!=-1){
fileOutputStream.write(remain);
}
break;
}
else{
//从来源文件读取数据至缓冲区
fileInputStream.read(buffer);
//将数组数据写入目的文件
fileOutputStream.write(buffer);
}
}
// 关闭流
fileInputStream.close();
fileOutputStream.close();
System.out.println("复制完成");
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("using:java FileStreamDemo src des");
e.printStackTrace();
}
catch(IOException e){
e.printStackTrace();
}

}

}

FileOutputStream默认会以新建文件的方式来开启流。
如果指定的文件名称已经存在，则原文件会被覆盖
以附加的模式来写入文件：
FileOutputStream fileOutputStream=new FileOutputStream（string，true）；

BufferedInputStream & BufferedOutputStream

为InputStream&OutputStream对象增加缓冲区
构建BufferedInputStream实例时，需要给定一个InputStream类型的实例，实现BufferedInputStream时实际上最后是实现InputStream实例
so do BufferedOutputStream
BufferedInputStream的数据成员buf是一个位数组，默认为2048字节
BufferedOutputStream的数据成员buf是一个位数组，默认为512字节。当使用write（）方法写入数据时，实际上会先将数据写至buf中，当buf已满时才会实现给定的OutputStream对象的write（）方法，将buf数据写至目的地
例：使用BufferedInputStream & BufferedOutputStream实现文件复制
package 输入输出;
import java.io.*;
public class BufferdeStreamDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] arg=new String[2];
arg[0]="D:\\za\\code.txt";
arg[1]="test.txt";
try{
byte[] data=new byte[1];

File srcFile=new File(arg[0]);
File desFile=new File(arg[1]);

BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream(srcFile));
BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream(desFile));
System.out.println("复制文件："+srcFile.length()+"字节");
while(bufferedInputStream.read(data)!=-1){
bufferedOutputStream.write(data);
}
//将缓冲区中的数据全部写出
bufferedOutputStream.flush();
//关闭流
bufferedInputStream.close();
bufferedOutputStream.close();

System.out.println("复制完成");
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("using:java UseFileStream src des");
e.printStackTrace();
}
catch(IOException e){
e.printStackTrace();
}

}

}

DataInputStream&DataOutputStream

提供一些对Java基本数据类型写入的方法，在写入或读出基本数据类型时，就不用担心不同平台间数据大小不同的问题
例：Member类
package 输入输出;

public class Member {
private String name;
private int age;
public Member(){

}
public Member(String name,int age){
this.name=name;
this.age=age;
}

public void setName(String name){
this.name=name;
}

public void setAge(int age){
this.age=age;
}

public String getName(){
return name;
}

public int getAge(){
return age;
}

}

例：将Member类实例的成员数据写入文件中，并在读入文件数据后，将这些数据还原为Member对象
package 输入输出;
import java.io.*;
public class DataStreamDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Member[] members={
new Member("Justin",90),
new Member("momor",95),
new Member("Bush",88)
};

String[] arg=new String[2];
arg[0]="test.txt";
arg[1]="text.txt";

try{
DataOutputStream dataOutputStream=new DataOutputStream(new FileOutputStream(arg[0]));
for(Member member:members){
//写入UTF
dataOutputStream.writeUTF(member.getName());
//写入int数据
dataOutputStream.writeInt(member.getAge());
}
//读出所有数据至目的地
dataOutputStream.flush();
//关闭流
dataOutputStream.close();

DataInputStream dataInputStream=new DataInputStream(new FileInputStream(arg[0]));
//读出数据并还原为对象
for(int i=0;i<>
//读出UTF字符串
String name=dataInputStream.readUTF();
int score=dataInputStream.readInt();
members[i]=new Member(name,score);
}
//关闭流
dataInputStream.close();

//现实还原后的数据
for(Member member:members){
System.out.printf("%s\t%d%n", member.getName(),member.getAge());
}
}
catch(IOException e){
e.printStackTrace();
}
}

}

ObjectInputStream & ObjectOutputStream

如果要直接存储对象，定义该对象的类必须实现java.io.Serializable接口，尽管接口中没有规范任何必须实现的方法（一个标志）
例：User类
package 输入输出;
import java.io.Serializable;
public class User implements Serializable{
private static final long serialVersionUID=1l;

private String name;
private int number;

public User(){

}

public User(String name,int number){
this.name=name;
this.number=number;
}

public void setName(String name){
this.name=name;
}

public void setNumber(int number){
this.number=number;
}

public String getName(){
return name;
}

public int getNumber(){
return number;
}

}
注意到serialVersionUID，它代表了可序列化对象的版本，如果没有提供这个版本信息，则实现Serializable接口的类会自动依类名称、实现的接口、成员等来产生。如果是自动生成的，则下次更改User类，自动产生的serialVersionUID也会跟着变更，从文件读回对象时若两个对象的serialVersionUID不相同，就会丢出java.io.InvalidClassException。
在写入对象时用writeObject（）方法
读出对象时使用readObject（）方法，被读出的对象都是以Object的类型返回，所以必须将之转换为对象原来的类型，才能正确的实现被读回的对象
例：存储User对象至文件中，然后再将它读回并还原为User实例
package 输入输出;
import java.io.*;
import java.util.*;
public class ObjectStreamDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] arg=new String[2];
arg[0]="test.txt";
//arg[1]="test2.txt";
User[] users={
new User("cater",101),
new User("justin",102)
};
writeObjectToFile(users,arg[0]);
try{
//读取文件数据
users=readObjectsFromFile(arg[0]);
//显示读回的对象
for(User user:users){
System.out.printf("%s\t%d%n",user.getName(),user.getNumber());
}
System.out.println();
users=new User[2];
users[0]=new User("momor",103);
users[1]=new User("becky",104);

//附加新对象至文件
appendObjectsToFile(users,arg[0]);

//读取文件数据
users=readObjectsFromFile(arg[0]);
//显示读回对象
for(User user:users){
System.out.printf("%s\t%d%n", user.getName(),user.getNumber());
}
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("没有指定文件名");
}
catch(FileNotFoundException e){
e.printStackTrace();
}

}
public static void writeObjectToFile(Object[] objs,String filename){
File file=new File(filename);
try{
ObjectOutputStream objOutputStream=new ObjectOutputStream(new FileOutputStream(file));
for(Object obj:objs){
//将对象写入文件
objOutputStream.writeObject(obj);
}
//关闭流
objOutputStream.close();
}
catch(IOException e){
e.printStackTrace();
}

}

//将制定文件中的对象数据读回
public static User[] readObjectsFromFile(String filename)
throws FileNotFoundException
{
File file=new File(filename);
//如果文件不存在就丢出异常
if(!file.exists())throw new FileNotFoundException();
//使用List先存储读回的对象
List list=new ArrayList();

try{
FileInputStream fileInputStream=new FileInputStream(file);
ObjectInputStream objInputStream=new ObjectInputStream(fileInputStream);

while(fileInputStream.available()>0){
list.add((User)objInputStream.readObject());
}
objInputStream.close();
}
catch(ClassNotFoundException e){
e.printStackTrace();
}
catch(IOException e){
e.printStackTrace();
}

User[] users=new User[list.size()];
return list.toArray(users);
}

//将对象附加至指定的文件之后
public static void appendObjectsToFile(Object[] objs,String filename)
throws FileNotFoundException{
File file=new File(filename);
//如果文件不存在则丢出异常
if(!file.exists())throw new FileNotFoundException();

try{
ObjectOutputStream objOutputStream=new ObjectOutputStream(new FileOutputStream(file,true)){
//如果要附加对象至文件后
//必须重新定义这个方法
protected void writeStreamHeader()throws IOException{}
};

for(Object obj:objs){
//将对象写入文件
objOutputStream.writeObject(obj);
}
objOutputStream.close();
}
catch(IOException e){
e.printStackTrace();
}
}
}

注意：
在试图将对象附加至一个先前已写入对象的文件时，由于ObjectOutputStream在写入数据时，还会加上一个特别的流头（Stream Heade），所以在读取文件时会检查这个流头。如果一个文件中被多次附加对象，那么该文件中会有多个流头。这样读取检查时就会发现不一致，这会丢出java.io.StreamCorrupedException为了解决这个问题可以重新定义ObjectOutputStream的writeStreamHeader()方法，如果是以附加方式来写入对象，就不写入流头：
ObjectOutputStream objectOutputStream=new ObjectOutputStream（
new FileOutputStream（file，true））{
protected void writeStreamHeader()throws IOException{}
}；

SequenceInputStream

若将一个文件分割为数个文件，再将之组合还原为一个文件，SequenceInputStream是首选
SequenceInputStream可以被看做是数个InputStream对象的组合
当一个Input对象的内容读取完毕后，它会读取下一个InputStream对象直到所有的InputStream对象都读取完毕为止
例：将指定文件分割，也可以将分割后的文件还原为一个文件
package 输入输出;
import java.io.*;
import java.util.*;
public class SequenceStreamDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] arg=new String[3];
arg[0]="c";
arg[1]="2";
arg[2]="test.txt";

try{
//arg[0]指定分割（s）或连接（c）
switch(arg[0].charAt(0)){
case 's':
//arg[1]：每个分割文件的大小
int size=Integer.parseInt(arg[1]);
//arg[2]:指定要分割文件的名称
seperate(arg[2],size);
break;
case 'c':
//arg[1]指定要被组合的文件个数
int number=Integer.parseInt(arg[1]);
//arg[2]组合后的文件名
concatenate(arg[2],number);
break;
}

}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("using:java UseSequenceStream[-s/-c]"+
"(size/number) filename");
System.out.println("-s:分割文件\n-c:组合文件");
}
catch(IOException e){
e.printStackTrace();
}

}

//分割文件：
public static void seperate(String filename,int size)throws IOException{
FileInputStream fileInputStream=new FileInputStream(new File(filename));
BufferedInputStream bufInputStream=new BufferedInputStream(fileInputStream);
byte[] data=new byte[1];
int count=0;
//还原文件大小及指定分割的大小
//决定要分割为几个文件
if(fileInputStream.available()%size==0)
count=fileInputStream.available()/size;
else
count=fileInputStream.available()/size+1;

//开始进行分割
for(int i=0;i< num="0;" file="new" bufoutputstream="new" num="="> list=new ArrayList();

for(int i=0;i< file =" new"> iterator=list.iterator();
//SequenceInputStream需要一个Enumeration对象来构建
Enumeration enumation=new Enumeration(){
public boolean hasMoreElements(){
return iterator.hasNext();
}
public InputStream nextElement(){
return iterator.next();
}
};

//建立SequenceInputStream
//并使用BufferedInputStream
BufferedInputStream bufInputStream=new BufferedInputStream(
new SequenceInputStream(enumation),8192);

BufferedOutputStream bufOutputStream=
new BufferedOutputStream(
new FileOutputStream(filename),8192);

byte[] data=new byte[1];
//读取所有文件数据并写入目的文件
while(bufInputStream.read(data)!=-1){
bufOutputStream.write(data);
}

bufInputStream.close();
bufOutputStream.flush();
bufOutputStream.close();
System.out.println("组合"+number+"个文件 OK!" );
}

}

PrintStream

使用java.io.PrintStream可以自动进行字符转换的动作，默认会使用操作系统的编码来处理对应的字符转换动作
例：
package 输入输出;
import java.io.*;
public class PrintStreamDemo {

/**
* @param args
*/
public static void main(String[] args) throws FileNotFoundException{
// TODO Auto-generated method stub
PrintStream printStream = new PrintStream(new File("test2.txt"));
printStream.println(1);
printStream.close();
}

}

ByteArrayInputStream & ByteArrayOutputStream

ByteArrayInputStream & ByteArrayOutputStream 是将位数组当做流输入来源，输出目的地的类
例：打开一个有简单字符（ABCD……）的简单文本文件，在读取文件之后，指定文件中字符的位置来修改字符
package 输入输出;
import java.util.*;
import java.io.*;
public class ByteArrayStreamDemo {

public static void main(String[] args) {
String arg=new String("test2.txt");
// TODO Auto-generated method stub
try{
File file=new File(arg);
BufferedInputStream bufferedInputStream=
new BufferedInputStream(
new FileInputStream(file));
ByteArrayOutputStream arrayOutputStream=new ByteArrayOutputStream();
byte[] bytes=new byte[1];

//将文件内容写入位数组流
while(bufferedInputStream.read(bytes)!=-1){
arrayOutputStream.write(bytes);
}
arrayOutputStream.close();
bufferedInputStream.close();

//以字符方式显示位数组内容
bytes=arrayOutputStream.toByteArray();
for(int i=0;i< bytes.length;i++){
System.out.print((char)bytes[i]);
}
System.out.println();

//让用户输入位置与字符修改位数组内容
Scanner scanner=new Scanner(System.in);

System.out.print("输入修改位置：");
int pos=scanner.nextInt();
System.out.print("输入修改字符：");
//修改数组中对应的字符
bytes[pos-1]=(byte)scanner.next().charAt(0);
//将位数组内容存回文件
ByteArrayInputStream byteArrayInputStream=
new ByteArrayInputStream(bytes);
BufferedOutputStream bufOutputStream=
new BufferedOutputStream(new FileOutputStream(file));
byte[] tmp=new byte[1];
while(byteArrayInputStream.read(tmp)!=-1)
bufOutputStream.write(tmp);
byteArrayInputStream.close();
bufOutputStream.flush();
bufOutputStream.close();

}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("请指定文件名称");
}

catch(IOException e){
e.printStackTrace();
}

}

}
结果：
AAAAAAAAAAAAAAA
输入修改位置：1
输入修改字符：B
文件修改后：BAAAAAAAAAAAAAA

PushbackInputStream

拥有一个Pushback缓冲区，从PushbackInputStream读出数据后，只要Pushback缓冲区没有满。就可以使用unread（）将数据推回流的前端
例：区分ASCII & BIG5
（BIG5使用两个字符来表示一个中文字，而ASCII只是用一个字节来表示英文字符，
BIG5中文为了与ASCII兼容，低字节范围为0xA4~0xF9，高字节范围为0x40~0x7E以及0xA1~0xFE。存储时低字节先存，再存高字节，所以读取时只要读到字节是在0xA4~0xF9就表示它可能是一个中文字的前半数据）

例：

package 输入输出;
import java.io.*;
public class PushbackStreamDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String arg="test2.txt";
try{
PushbackInputStream pushbackInputStream=new PushbackInputStream(
new FileInputStream(arg));
byte[] array=new byte[2];
int tmp=0;
int count=0;
while((count=pushbackInputStream.read(array))!=-1){
//两个字节转换为整数
tmp=(short)((array[0]<<8)|(array[1]&0xff));
tmp=tmp&0xffff;
//判断是否为BIG5，如果是则显示BIG5中文字
if(tmp>=0xA440 && tmp<0xffff)
System.out.println("BIG5:"+new String(array));
else {
//将第二个字节推回流
pushbackInputStream.unread(array,1,1);
//显示ASCII范围的字符
System.out.println("ASCII:"+(char)array[0]);
}

}
pushbackInputStream.close();
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("请指定文件名称");
}
catch(IOException e){
e.printStackTrace();
}

}

}
运行结果：
ASCII:d
BIG5:亲
ASCII:e
BIG5:爱
ASCII:a
BIG5:滴
ASCII:r
BIG5:啊

File & RandomAccessFile

2009-04-26T05:42:00.000-07:00

不同的操作系统对于文件系统路径的设置各有差别
Windows的路径指定是使用UNC（Universal Naming Convention）路径名以\\表示硬盘根目录

一个File的实例被建立时，它就不能再被改变。
不管是文件还是目录，在Java中都是以File的实例来表示
例：指定查询某个目录下的所用文件与目录名称
package 输入输出;
import java.io.*;
import java.util.*;
public class FileDemo {

/**
* @param args
*/
public static void main(String[] arg) {
// TODO Auto-generated method stub
try{
String[] args=new String[1];
args[0]="D:\\日本語\\二级\\2级语法\\2级语法190.doc";
File file=new File(args[0]);
if(file.isFile()){
System.out.println(args[0]+"文件");
System.out.print(file.canRead()?"可读":"不可读");
System.out.print(file.canWrite()?"可写":"不可写");
System.out.println(file.length()+"字节");
}
else{
File[] files=file.listFiles();//listFiles():返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件。
ArrayList fileList=new ArrayList();
for(int i=0;i
if(files.clone()[i].isDirectory()){
System.out.println("["+files[i].getPath()+"]");
}
else {
fileList.add(files[i]);
}
}
for(File f:fileList){
System.out.println(f.toString());
}
System.out.println();
}
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("using: java FileDemo pathname");
}

RandomAccessFile类

文件存取通常是循序的，每在文件中存取一次，文件的读取位置就会相对于目前的位置前进一次
RandomAccessFile使用seek（）方法来指定文件存取的位置，指定的单位是字节
为了移动存取位置时的方便，通常在随机存取文件中会固定每一个数据的长度。Java中并没有直接的方法可以写入一个固定长度数据，所以在固定每一个长度方面必须自行设计
例：设计一个学生数据的类
package 输入输出;

public class Student {
private String name;
private int score;

public Student(){
setName("noname");
}
public Student(String name,int score){
setName(name);
this.score=score;
}
public void setName(String name){
StringBuilder builder=null;
if(name!=null){
builder=new StringBuilder(name);
}
else
builder=new StringBuilder(15);
builder.setLength(15);
this.name=builder.toString();
}
public void setScore(int score){
this.score=score;
}
public String getName(){
return name;
}
public int getScore(){
return score;
}
public static int size(){
return 34;
}
}

对于每个学生数据的实例再写入文件时，会固定以34字节的长度写入，也就是15个字符（30字节）+一个int整数的长度（4字节）。
例：使用RandomAccessFile来写入文件，并可随机指定一个所想读出的数据
package 输入输出;
import java.io.*;
import java.util.*;
public class RandomAccessFileDemo {

/**
* @param args
*/
public static void main(String[] args) {
String arg=new String("student.dat");
// TODO Auto-generated method stub
Student[] students={
new Student("Justin",90),
new Student("Momor",95),
new Student("Bush",88),
new Student("Caterpillar",84)
};

try{
File file=new File(arg);
RandomAccessFile randomAccessFile=new RandomAccessFile(file,"rw");
for(int i=0;i< students.length;i++){
randomAccessFile.writeChars(students[i].getName());
randomAccessFile.writeInt(students[i].getScore());
}
Scanner scanner=new Scanner(System.in);
System.out.println("读取第几个数据？");
int num=scanner.nextInt();

//使用seek()方法操作存取位置
randomAccessFile.seek((num-1)*Student.size());
Student student=new Student();
//使用对应的read方法读取数据
student.setName(readName(randomAccessFile));
student.setScore(randomAccessFile.readInt());

System.out.println("姓名："+student.getName());
System.out.println("分数："+student.getScore());

randomAccessFile.close();

}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("请指定文件名称");
}
catch(IOException e){
e.printStackTrace();
}

}

private static String readName(RandomAccessFile randomAccessfile)throws IOException{
char[] name=new char[15];
for(int i=0;i< name.length;i++)
name[i]=randomAccessfile.readChar();
//将空字符取代为空格符并返回
return new String(name).replace('\0', ' ');
}

}

79.21/250 points

2009-04-24T23:02:00.000-07:00

Problem Statement

***Note: Please keep programs under 7000 characters in length. Thank you

Class Name: HowEasy
Method Name: pointVal
Parameters: String
Returns: int

TopCoder has decided to automate the process of assigning problem difficulty
levels to problems. TopCoder developers have concluded that problem difficulty
is related only to the Average Word Length of Words in the problem statement:

If the Average Word Length is less than or equal to 3, the problem is a 250
point problem.
If the Average Word Length is equal to 4 or 5, the problem is a 500 point
problem.
If the Average Word Length is greater than or equal to 6, the problem is a 1000
point problem.

Definitions:
Token - a set of characters bound on either side by spaces, the beginning of
the input String parameter or the end of the input String parameter.
Word - a Token that contains only letters (a-z or A-Z) and may end with a
single period. A Word must have at least one letter.
Word Length - the number of letters in a Word. (NOTE: a period is NOT a letter)

The following are Words :
"ab", "ab."

The following are not Words :
"ab..", "a.b", ".ab", "a.b.", "a2b.", "."

Average Word Length - the sum of the Word Lengths of every Word in the problem
statement divided by the number of Words in the problem statement. The
division is integer division. If the number of Words is 0, the Average Word
Length is 0.

Implement a class HowEasy, which contains a method pointVal. The method takes
a String as a parameter that is the problem statement and returns an int that
is the point value of the problem (250, 500, or 1000). The problem statement
should be processed from left to right.

Here is the method signature (be sure your method is public):
int pointVal(String problemStatement);

problemStatement is a String containing between 1 and 50 letters, numbers,
spaces, or periods. TopCoder will ensure the input is valid.

Examples:

If problemStatement="This is a problem statement", the Average Word Length is
23/5=4, so the method should return 500.
If problemStatement="523hi.", there are no Words, so the Average Word Length is
0, and the method should return 250.
If problemStatement="Implement a class H5 which contains some method." the
Average Word Length is 38/7=5 and the method should return 500.
If problemStatement=" no9 . wor7ds he8re. hj.." the Average Word Length is 0,
and the method should return 250.
Definition

Class:
HowEasy
Method:
pointVal
Parameters:
String
Returns:
int
Method signature:
int pointVal(String param0)
(be sure your method is public)

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.

i submitted the 250-point problem for 79.21 points ==！
my answer:
import java.util.*;
public class HowEasy {
public int pointVal(String s){
int letters=0;
int periods=0;
int num=0;
int length=0;

StringTokenizer st = new StringTokenizer(s);
num=st.countTokens();
while( st.hasMoreElements() ){
String string=st.nextToken();
for(int i=0;i< string.length();i++){
if(Character.isDigit(string.charAt(i))){
num--;
letters=letters-i;
break;
}
else if(Character.isLetter(string.charAt(i))){
letters++;
}
else if(".".equals(string.charAt(i))){
periods++;
if(periods>1) {
num--;
break;
}
}

}
periods=0;
}

if(num!=0)length=letters/num;
return(length<=3 ? 250 : length<=5 ? 500:1000);

}
}

数字三角

2009-04-23T04:33:00.000-07:00

请思考如何输出如下三角阵
1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1
1 2 3 4 5 6 5 4 3 2 1
1 2 3 4 5 6 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1

package 第一周;

public class 数字三角阵 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++)
System.out.print(j+" ");
for(int j=i-1;j>0;j--)
System.out.print(j+" ");
System.out.println();
}

//----------------------------------------------
System.out.println();
//----------------------------------------------

for(int i=1;i<=9;i++){
for(int k=i;k<9*2-i;k++)
System.out.print(" ");
for(int j=1;j<=i;j++)
System.out.print(j+" ");
for(int j=i-1;j>0;j--)
System.out.print(j+" ");
System.out.println();
}
}
}

1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1
1 2 3 4 5 6 5 4 3 2 1
1 2 3 4 5 6 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1

1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1
1 2 3 4 5 6 5 4 3 2 1
1 2 3 4 5 6 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1

九九乘法表

2009-04-23T04:28:00.000-07:00

请观察下面的九九乘法表，归纳其规律再将其打印出来。
1*1=1
2*1=2_2*2=4
3*1=3_3*2=6_3*3=9
4*1=4_4*2=8_4*3=12 _4*4=16
5*1=5_5*2=10 5*3=15 5*4=20 5*5=25
6*1=6_6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7_7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8_8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9_9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

public class 九九乘法表 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++)
System.out.print(i+"*"+j+"="+i*j+"\t");
System.out.println();

}

// --------------------------------------------

System.out.println();

//----------------------------------

for(int i=9;i>=1;i--){
for(int j=1;j<=i;j++)
System.out.print(j+"*"+i+"="+i*j+"\t");
System.out.println();
}

//------------------------------------------

System.out.println();

//-----------------------------------------

for(int i=1;i<=9;i++){
for(int n=0;n<9-i;n++){
System.out.print(" ");
}

for(int j=1;j<=i;j++)
System.out.print(j+"*"+i+"="+i*j+" ");
System.out.println();
}

}

}

1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*4=4 2*4=8 3*4=12 4*4=16
1*3=3 2*3=6 3*3=9
1*2=2 2*2=4
1*1=1

1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

水仙花数

2009-04-23T04:23:00.000-07:00

所谓水仙花数是指一个三位数，其各位数字立方和等于该数本身，例如153是水仙花数，因为153=1*1*1+5*5*5+3*3*3.请编程求出所有的水仙花数

public class ShuiXianHua{
public static void main(String[] args){
for(int n=100;n<1000;n++){
int a=n/100;// 取得百位
int b=(n-a*100)/10;// 取得十位
int c=n % 10;// 取得个位

if(n==(a*a*a+b*b*b+c*c*c)){
System.out.println(n+"是水仙花数");
}
}
}
}

输出：
153是水仙花数
370是水仙花数
371是水仙花数
407是水仙花数

枚举类型

2009-04-23T03:47:00.000-07:00

例：
package 枚举类型;

public enum Action {
TURN_LEFT,
TURN_RIGHT,
SHOOT
}

枚举类型本质上是个类，所以编译完成后会产生一个Action.class文件
（内嵌类）

使用实例：
package 枚举类型;

public class EnumDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}

public static void doAction(Action action){
switch(action){
case TURN_LEFT:
System.out.println("向左转");
break;
case TURN_RIGHT:
System.out.println("向右转");
break;
case SHOOT:
System.out.println("射击");
break;

}
}

}

当使用enum定义枚举类型时，实际上所定义出来的类型是继承自java.lang.Enum类，而每个被枚举的成员其实就是定义的枚举类型的一个实例，他们都被默认为final。无法改变常数名称所设置的值，他们也是public static的成员。可以通过类名称直接使用它们
例：
package 枚举类型;

public class EnumDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}

public static void doAction(Action action){
switch(action){
case TURN_LEFT:
System.out.println("向左转");
break;
case TURN_RIGHT:
System.out.println("向右转");
break;
case SHOOT:
System.out.println("射击");
break;

}
}

}
运行结果：
TURN_LEFT
TURN_RIGHT
SHOOT
例：
使用静态的valueOf（）方法——将指定的字符串尝试转换为枚举实例
compareTo（）方法——比较两个枚举对象在枚举时的顺序
package 枚举类型;

public class EnumCompareTo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
compareToAction(Action.valueOf(args[0]));

}
public static void compareToAction(Action inputAction){
System.out.println("输入："+inputAction);
for(Action action:Action.values()){
System.out.println(action.compareTo(inputAction));
}
}

}
例：
package 枚举类型;

public enum DetailAction {
TURN_LEFT,TURN_RIGHT,SHOOT;

public String getDescription(){
switch(this.ordinal()){
case 0:
return "向左转";
case 1:
return "向右转";
case 2:
return "射击";
default:
return null;
}
}

}
测试类：
package 枚举类型;

public class DetailActionDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
for(DetailAction action:DetailAction.values()){
System.out.printf("%s:%s%n",action,action.getDescription());
}

}

}
运行结果：
TURN_LEFT:向左转
TURN_RIGHT:向右转
SHOOT:射击

protected

2009-04-23T03:46:00.001-07:00

保护的意思是表示存取该成员是有条件限制的。当将类的成员声明为受保护的成员之后，继承的类就可以直接使用这些成员，但这些成员仍然受到保护，不同包的对象不可以直接调用使用protected成员。

接口

2009-04-23T03:44:00.001-07:00

当实现多个接口时，记得必须实现每一个接口中所定义的方法。由于实现了多个接口，所以要实现对象时，必要时必须做借口转换，这样程序才知道如何正确的实现对象。
假设someObject实现了ISomeInterface1与ISomeInterface2两个接口，则可以对对象进行接口转换与实现。

ISomeInterface1 obj1=(ISomeInterface1)someObject;
obj1.doSomeMethodOfISomeInterface1();

ISomeInterface2 obj2=(ISomeInterface2)someObject;
obj2.doSomeMethodOfISomeInterface2();

简单的说，每多实现一个接口，就要多遵循一个实现协议。

不同于一次只能继承一个父类，一个接口可以同时继承多个父接口。实现子接口的类必须将所有在父接口和子接口中定义的方法实现出来。

final

2009-04-23T03:43:00.000-07:00

声明变量时，表示该变量一旦设置之后，就不可以再改变该变量的值。

定义方法成员时，表示该方法成员再也无法被子类重写

在声明类时，则表示要终止被扩展，这个类不可以被其他类继承。

clone

2009-04-23T03:41:00.000-07:00

clone（）方法是有关如何复制对象本身的方法。可以重写复制方法。

public class Point implements Cloneable{
private int x;
private int y;

public Point(){}
public Point(int x,int y){
this.x=x;
this.y=y;
}

public void setX(int x){
this.x=x;
}
public void setY(int y){
this.y=y;
}

public int getX(){
return x;
}
public int getY(){
return y;
}

public Object clone() throws CloneNotSupportedException{
return super.clone();

}

}

public class CloneDemo {

public static void main(String[] args) throws CloneNotSupportedException{
Table table=new Table();
table.setCenter(new Point(2,3));
Point originalCenter = table.getCenter();

Table clonedTable = (Table)table.clone();
Point clonedCenter = clonedTable.getCenter();

System.out.printf("before:(%d,%d)\n",
originalCenter.getX(),originalCenter.getY());
System.out.printf("cloned:(%d,%d)\n",
clonedCenter.getX(),clonedCenter.getY());

clonedCenter.setX(10);
clonedCenter.setY(10);

System.out.printf("before:(%d,%d)\n",
originalCenter.getX(),originalCenter.getY());
System.out.printf("cloned:(%d,%d)\n",
clonedCenter.getX(),clonedCenter.getY());
}

}

匿名类

2009-04-23T03:32:00.000-07:00

在类中还可以再定义类，称之为内嵌类或嵌套类。

非静态的内嵌类可以分为3种：成员内嵌类、区域内嵌类、匿名内嵌类。

内嵌类的主要目的，就是对外部隐藏类的存在性。

成员内嵌类和区域内嵌类

使用内嵌类的好处：

1，内嵌类可以直接存取其所在类中的私用成员；

2，当某个Slave类完全只服务于一个Master类时，可以将之设置为内嵌类，这样使用Master类的人就不用知道Slave的存在。

3，像在“静态工厂”模式中，对调用静态方法的对象隐藏返回对象的实现细节或产生方式。

public class PointDemo {

private class Point{

private int x,y;

public Point(){

}

public void setPoint(int x,int y){

this.x=x;

this.y=y;

}

public int getX(){return x;}

public int getY(){return y;}

}

private Point[] points;

public PointDemo(int length){

points=new Point[length];

for(int i=0;i<points.length;i++){

points[i]=new Point();

points[i].setPoint(i*5, i*5);

}

public void showPoints(){

for(int i=0;i<points.length;i++){

System.out.printf("Point[%d]: x=%d,y=%d%n",i,points[i].getX(),points[i].getY());

}

程序中假设Point类只服务于PointDemo ，外界不必知道Point类的存在，只要知道如何实现PointDemo的实例就可以了。

public class PointShow {

public static void main(String[] args) {

PointDemo demo=new PointDemo(5);

demo.showPoints();

}

在文件管理方面，成员内嵌类在编译完成之后，所产生的文件名称为“外部类名称$内嵌类名称.class”所以编译后会产生两个文件：PointDemo.class 与 PointDemo$Point.class。

区域内嵌类的使用与成员内嵌类类似。区域内嵌类定义于一个方法中，类的可视范围与生成的对象仅限于给方法中。

内部类还可以被声明为static，不过由于是ststic，它不能存取外部类的方法，而必须通过外部类所生成的对象来进行调用。被声明为static的内部类，事实上也可以看作是另一种名称空间的管理方式

匿名内嵌类：

内嵌匿名类可以不声明类名称，而使用new直接产生一个对象，它们可以是继承某个类或实现某个接口，

package InnerClass;

public class AnonymousClassDemo {

public static void main(String[] args) {

Object obj=

new Object(){

public String toString(){

return "匿名类对象";

}

};

System.out.println(obj);

}

注意，如果要在内嵌匿名类中使用外部的区域变量，变量在声明时必须为final。

原因：区域变量并不是真正被拿来在内嵌匿名类中使用，区域变量被匿名类复制作为数据成员来使用。由于真正在匿名类中的区域变量是复制品，即使在内嵌匿名类中对区域变量做了修改，也不会影响区域变量。事实上也通不过编译器的检查。

在文件管理方面，内嵌匿名类在编译完成之后会产生“外部类名称$编号.class”，编号为：1、2、3……n，每个编号n的文件对应于第n个匿名类

EnumMap

2009-04-23T03:23:00.000-07:00

与单纯的使用HashMap的差别是：
EnumMap将根据枚举的顺序来维护对象的排列顺序
例1：
package 对象容器;
import java.util.*;

enum Action{TURN_LEFT,TURN_RIGHT,SHOOT}

public class EnumMapDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map map=new EnumMap(Action.class);

map.put(Action.TURN_LEFT, "向左转");
map.put(Action.TURN_RIGHT, "向右转");
map.put(Action.SHOOT, "射击");

for(Action action:Action.values())
System.out.println(map.get(action));

}

}
运行结果：
向左转
向右转
射击

例2：
package 对象容器;
import java.util.*;
public class EnumMapDemo2 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map map= new EnumMap(Action.class);

map.put(Action.TURN_LEFT, "向左转");
map.put(Action.TURN_RIGHT, "向右转");
map.put(Action.SHOOT, "射击");

for(String value:map.values())
System.out.println(value);

}

}
运行结果：
向左转
向右转
射击

TreeMap

2009-04-23T03:14:00.000-07:00

java.util.TreeMap实现Map接口 & java.util.SortedMap接口
SortedMap提供相关的方法能够有序的取出对应位置的对象
TreeSet是Java SE中唯一实现SortedMap接口的类，它使用红黑树结构来对加入的对象进行排序
例：
package 对象容器;
import java.util.*;
public class TreeMapDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Mapmap=new TreeMap();

map.put("justin", "justin的信息");
map.put("momor", "momor的信息");
map.put("caterpillar", "caterpillar的信息");

for(String value:map.values())
System.out.println(value);

}

}
运行结果：
caterpillar的信息
justin的信息
momor的信息

实现自定义的排列顺序：
package 对象容器;
import java.util.Comparator;
public class CustomComarator implements Comparator {
public int compare(T o1,T o2){
if(((T)o1).equals(o2))
return 0;
return ((Comparable) o1).compareTo((T) o2)*-1;
}

}

测试类：
package 对象容器;
import java.util.*;
public class TreeMapDemo2 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
CustomComarator comparator=new CustomComarator();
Map map=new TreeMap(comparator);

map.put("justin", "justin的信息");
map.put("momor", "momor的信息");
map.put("caterpillar", "caterpillar的信息");

for(String value:map.values())
System.out.println(value);

}

}
运行结果：
momor的信息
justin的信息
caterpillar的信息

HashMap

2009-04-23T01:40:00.000-07:00

Map类
实现java.util.Map接口的对象会将Key映射至Value（值：要存入Map容器的对象）
在将对象存入Map对象时，需要同时给定一个键，要取回对象时可以给定键，这样就可以取得与键对应的对象值
Map中的每一个键都是唯一的，不能有重复的键，Map拥有自己的排序机制

HashMap
实现了Map接口，HashMap在内部实现使用哈希法，能够在很短的时间内寻得键-值匹配
例：
package 对象容器;
import java.util.*;
public class HashMapDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map map=new HashMap();
String key1="caterpillar";
String key2="justin";
map.put(key1, "caterpiller的信息");
map.put(key2, "justin的信息");
System.out.println(map.get(key1));
System.out.println(map.get(key2));

}

}
运行结果：
caterpiller的信息
justin的信息
put（）方法将对象存入，必须同时指定键和值
取回对象时，使用get（）方法并指定键，返回的是对应于键的值

可以使用values（）方法返回一个实现Collection的对象，其中包括所有的值对象
package 对象容器;
import java.util.*;
public class HashMapDemo2 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Mapmap=new HashMap();

map.put("justin", "justin的信息");
map.put("momor", "momor的信息");
map.put("caterpillar", "caterpillar的信息");

Collection collection=map.values();
Iterator iterator=collection.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println();

for(String value:map.values()){
System.out.println(value);
}

}

}
运行结果：
justin的信息
momor的信息
caterpillar的信息

justin的信息
momor的信息
caterpillar的信息

总结：
只要是实现Collection接口的对象，都可以使用增强的for循环来迭代所有值

使用HashMap的子类java.util.LinkedHashMap 依照插入的顺序来排列
例：
package 对象容器;
import java.util.*;
public class LinkedHashMapDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map map=new LinkedHashMap();

map.put("justin", "justin的信息");
map.put("momor", "momor的信息");
map.put("caterpillar", "caterpillar的信息");

for(String value:map.values())
System.out.println(value);

}

}
运行结果：
justin的信息
momor的信息
caterpillar的信息

EnumSet

2009-04-22T07:37:00.000-07:00

可以指定枚举值来加入EnumSet中
使用of（）方法会返回一个EnumSet的实例，其中包括所指定的枚举值
也可以使用complementOf（）指定一个EnumSet的互补集
例：
package 对象容器;
import java.util.*;
enum FontConstant{Plain,Bold,Italic}
public class EnumSetDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
EnumSet enumSet=EnumSet.of(FontConstant.Plain,FontConstant.Bold);
showEnumSet(enumSet);
showEnumSet(EnumSet.complementOf(enumSet));//补齐

}

public static void showEnumSet(EnumSet enumSet){
for(FontConstant constant:enumSet){
System.out.println(constant);
}
System.out.println();
}

}
运行结果：
Plain
Bold

Italic

例：
package 对象容器;
import java.util.*;
//enum FontConstant{plain,Bold,Italic}
public class EnumSetDemo2 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
EnumSet enumSet=EnumSet.noneOf(FontConstant.class);
enumSet.add(FontConstant.Bold);
enumSet.add(FontConstant.Italic);
showEnumSet(enumSet);

}

public static void showEnumSet(EnumSet enumSet){
for(FontConstant constant:enumSet)
System.out.println(constant);
System.out.println();
}

}
运行结果：
Bold
Italic

LinkedHashSet

2009-04-22T07:32:00.000-07:00

LinkedHashSet是HashSet的子类
它在内部实现时使用哈希码进行排序，在迭代时行为像LinkedList
例：
package 对象容器;
import java.util.*;
public class LinkedHashSetDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Set set=new LinkedHashSet();
set.add("cate");
set.add("momor");
set.add("bush");

for(String name:set){
System.out.print(name+" ");
}
System.out.println();

}

}
运行结果：
cate momor bush

HashSet

2009-04-22T07:08:00.000-07:00

HashSet的排序规则是利用哈希法（Hash），所以加入HashSet容器的对象还必须从新定义hashCode（）方法
HashSet根据哈希码来确定对象在容器中存储的位置
在比较两个加入HashSet容器中的对象是否相同时，会先比较hashCode（）方法返回的值是否相同，如果相同再使用equals（）方法比较。
事实上在定义类时最好重新定义equals（）与hashCode（）方法
一个HashSet的简单例子：
package 对象容器;
import java.util.*;
public class HashSetDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Set set=new HashSet();
set.add("caterpillar");
set.add("momor");
set.add("bush");
set.add("momor");

Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();

set.remove("bush");
for(String name:set){
System.out.print(name+" ");
}
System.out.println();

}

}
运行结果：
momor bush caterpillar
momor caterpillar

注意：
1：对象都是唯一的，即使重复加入也只有一个
2：迭代容器中所有值时，其顺序与加入容器的顺序是不一样的，迭代时的顺序是HashSet排序后的顺序

TreeSet

2009-04-22T06:43:00.000-07:00

Set接口继承了Collection接口。
List容器中的对象允许重复，但Set中的对象都是唯一的
实现java.util.Set接口 & java.util.SortedSet接口
SortedSet提供相应的方法取出相应位置的对象
TreeSet是Java SE中唯一实现SortedSet接口的类，它使用红黑树结构来对加入的对象进行排列
例：
package 对象容器;
import java.util.*;
public class TreeSetDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Set set=new TreeSet();
set.add("justin");
set.add("caterpillar");
set.add("momor");

for(String name:set){
System.out.print(name+" ");
}
System.out.println();

}

}
运行结果：
caterpillar justin momor

TreeSet默认依字典顺序来排列String对象
自己定义排列方式：
1：定义一个实现java.util.Comparator的对象
2：实现接口中的compare（）方法
3：compare（）方法必须返回整数值
例：
package 对象容器;
import java.util.Comparator;
public class CustomComarator implements Comparator {
public int compare(T o1,T o2){
if(((T)o1).equals(o2))
return 0;
return ((Comparable) o1).compareTo((T) o2)*-1;//让排列顺序相反
}

}
测试类：
package 对象容器;
import java.util.*;
public class TreeSetDemo2 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Comparator comparator=new CustomComarator();
Set set=new TreeSet(comparator);
set.add("juatin");
set.add("caterpillar");
set.add("momor");

for(String name:set){
System.out.print(name+" ");
}
System.out.println();

}

}
运行结果：
momor juatin caterpillar

LinkedList

2009-04-22T06:04:00.000-07:00

java.util.LinkedList
适合于：经常做删除和插入动作
特定方法：
addFirst()
addLast()
getFirst()
getLast()
removeFirst()
removeLast()
例：使用LinkedList实现堆栈（First-In Last-Out）
package 对象容器;
import java.util.*;
public class StringStack {

/**
* @param args
*/

private LinkedList linkedList;

public StringStack(){
linkedList=new LinkedList();
}

public void push(String name){
linkedList.addFirst(name);
}

public String top(){
return linkedList.getFirst();
}

public String pop(){
return linkedList.removeFirst();
}

public boolean isEmpty(){
return linkedList.isEmpty();
}

}

测试类：
package 对象容器;
import java.util.*;
public class StringStackDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner=new Scanner(System.in);
StringStack stack=new StringStack();

System.out.println("输入名称（输入quit结束）");

while(true){
System.out.print("#");
String input=scanner.next();
if(input.equals("quit"))break;
stack.push(input);
}
//System.out.println(stack.top());
System.out.print("显示输入：");
while(!stack.isEmpty()){
System.out.print(stack.pop()+" ");
}

System.out.println();

}

}

运行结果：
输入名称（输入quit结束）
#aaaa
#bbbbbb
#cccccccc
#quit
显示输入：cccccccc bbbbbb aaaa

例：使用LinkedList实现队列（First-In First-Out）
package 对象容器;
import java.util.*;
public class StringQueue {
private LinkedList linkedList;
public StringQueue(){
linkedList = new LinkedList();
}
public void put(String name){
linkedList.addFirst(name);
}
public String get(){
return linkedList.removeLast();
}
public boolean isEmpty(){
return linkedList.isEmpty();
}

}
测试类：
package 对象容器;
import java.util.*;
public class StringQueueDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner=new Scanner(System.in);
StringQueue queue=new StringQueue();
System.out.println("输入名称（输入quit结束）");

while(true){
System.out.print("#");
String input=scanner.next();
if(input.equals("quit"))break;
queue.put(input);
}
System.out.print("显示输入：");
while(!queue.isEmpty()){
System.out.print(queue.get()+" ");
}
System.out.println();

}

}
运行结果：
输入名称（输入quit结束）
#a
#b
#c
#quit
显示输入：a b c

另：LinkedList实现了java.util.Queue接口
package 对象容器;
import java.util.*;
public class QueueDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner=new Scanner(System.in);
Queue queue=new LinkedList();

System.out.println("输入名称（输入quit结束）");
while(true){
System.out.print("#");
String input=scanner.next();
if(input.equals("quit"))break;
//offer():加入元素至队列中
queue.offer(input);
}

System.out.print("显示输入：");
String element=null;
//poll():取得并删除队列中的元素
//队列为空时返回null
while((element=queue.poll())!=null){
System.out.print(element+" ");
}
System.out.println();

}

}

ArrayList

2009-04-22T04:45:00.000-07:00

ArrayList实现了List接口
ArrayList使用数组结构实现List数据结构
优点：快速的随机取得对象
缺点：插入删除困难
一个使用ArrayList的例子：
package 对象容器;
import java.util.*;
public class ArrayListDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner=new Scanner(System.in);
List list=new ArrayList();
System.out.println("输入名称（使用quit结束）");

while(true){
System.out.print("#");
String input=scanner.next();
if(input.equals("quit")) break;
list.add(input);
}

System.out.print("显示输入：");
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+" ");
}

System.out.println();

}

}

add() :将一个对象加入ArrayList中
size() :返回当前ArrayList的长度
get() :返回指定索引处的对象
toArray() :将ArrayList中的对象转换成对象数组

运行结果：
输入名称（使用quit结束）
#ahhhhhhhhh
#wooooooooo
#eeeeeeeeee
#quit
显示输入：ahhhhhhhhh wooooooooo eeeeeeeeee

遍访容器方法：
①
for(int i=0;i < list.size();i++){
System.out.print(list.get(i)+" ");
}
②
Iterator iterator=list.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
③
for(String s:list){
System.out.print(s+" ");
}

Zero is Rethinking

Reminder about your invitation from Ying_er Lin

LinkedIn

一封程序员的爱情表白书

HP大中华区总裁孙振耀退休感言

repeat 南国的孩子

不是东北人，累死念不出来。

test blogger

test

韩信点兵

求一百以内的质数和

找出10000以内的所有回文数

鸡兔同笼问题

ABCDE=4*EDCBA

马克思手稿中的数学题

类加载器

类的加载与查看

《潜伏》在办公室

Java书籍推荐

Microsoft's Kumo

（最新整理）国内网页设计网站网址大全【转】

字符流

二级语法190

位流

File & RandomAccessFile

79.21/250 points

数字三角

九九乘法表

水仙花数

枚举类型

protected

接口

final

clone

匿名类

EnumMap

TreeMap

HashMap

EnumSet

LinkedHashSet

HashSet

TreeSet

LinkedList

ArrayList