BlogJava-都市淘沙者-文章分类-Java Basic/Lucene/开源资料

BeanComparator实现ArrayList复合排序[转]

都市淘沙者 — Thu, 10 Nov 2011 02:45:00 GMT

http://blog.csdn.net/ftlovexg/article/details/1583757

研究了几天,那时候就是认为要继承Comparable接口,重写CompareTo方法,结果走向了歧路.后来就搜啊搜,发现了点东西.自己又总结了下.需要的JAR包:commons.collections.jar

package test;

import java.util.Collections;
import java.util.Comparator;
import java.util.ArrayList;
import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections.ComparatorUtils;
import org.apache.commons.collections.comparators.ComparableComparator;
import org.apache.commons.collections.comparators.ComparatorChain;

public class CompareTipA  {
    private int  id;
    private String  name;
    private String age;

    public static void main(String []args) {
        ArrayList<Object> list = new ArrayList<Object>();
        list.add(new CompareTipA(1,"3","五"));
        list.add(new CompareTipA(1,"1","六"));
        list.add(new CompareTipA(1,"5","二"));
        list.add(new CompareTipA(1,"4","四"));
        list.add(new CompareTipA(4,"2","一"));

        Comparator mycmp = ComparableComparator.getInstance();
        mycmp = ComparatorUtils.nullLowComparator(mycmp);  //允许null
        mycmp = ComparatorUtils.reversedComparator(mycmp); //逆序

        ArrayList<Object> sortFields = new ArrayList<Object>();
        sortFields.add(new BeanComparator("id", mycmp));     //id逆序  (主)
        sortFields.add(new BeanComparator("name"));            //name正序 (副)
        ComparatorChain multiSort = new ComparatorChain(sortFields);
        Collections.sort(list,multiSort);

        for (int i =0;i<list.size();i++) {
            System.out.println(list.get(i));    //输出
        }
    }

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

    public int getId() {
        return this.id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }

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

//    public int compareTo(Object o) {
//        return this.comparator.compare(this, o);
//    }

    public String toString() {
        return "[id=" + this.id + ",name=" + this.name +",age=" + this.age +"]";
    }

    public String getAge() {
        return age;
    }

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

都市淘沙者 2011-11-10 10:45 发表评论

开源中最好的Web开发的资源

都市淘沙者 — Thu, 16 Jun 2011 23:58:00 GMT

文章来源：Best “must know” open sources to build the new Web。个人感觉这个收集贴收集成相当的全。

学习HTML 5编程和设计

★ HTML5 Rocks : Major Feature Groups 的学习 HTML5 的资源 (HTML5 演示, 教程 ). 源码
很不错的 HTML5 Dashboard – Mozilla，效果很炫。
WhatWG Developers, 一个清楚的 HTML5 技术规格说明书。
★ StackOverflow : 大名鼎鼎的技术问答式论坛。
★ Addyosmani, jQuery 和 JavaScript 文章教程
Sohtanaka, jQuery 和 JavaScript 文章和教程
★ Nettuts+ 是一个面对Web开发人员和设计人员的网站，提供各种技术教程和文章，覆盖 HTML, CSS, Javascript, CMS’s, PHP 和 Ruby on Rails.
Codrops, 教程和 web 资源
WebAppers, 最好的开源资源
Tutorialzine – PHP MySQL jQuery CSS 教程, 资源和赠品
Mozilla JavaScript guide
codes snippets, 作者自己收集的一些代码片段

服务器端的软件

★ Node.js 是服务器端的 JavaScript 环境，其使用了异步事件驱动模式。其让Node.js在很多互联网应用体系结构下获得非常不错的性能。源码和实时演示。
PhantomJS 也是一个服务器端的 JavaScript API的WebKit。其支持各种Web标准： DOM 处理, CSS 选择器, JSON, Canvas, 和 SVG
Lighttpd 一个轻量级的开源Web服务器。新闻，文档，benchmarks, bugs, 和 download. Lighttpd 支撑了几个非常著名的 Web 2.0 网站，如：YouTube, wikipedia 和 meebo.
NGinx, 性能巨高无比的轻量级的Web服务器。比Apache高多了。花了6年的时间，终于走到了1.0版。
Apache HTTP Server 是一个很流行的并支持多个流行的操作系统的Web服务器。
★ PHP 可能是最流行的服务器端的Web脚本动态处理语言。
当然，还有 Ruby, Python, Erlang, Perl, Java, .NET, Android, C++, Go, Fantom,CoffeeScript, D, …

PHP 框架和工具

★ WordPress 是一个基于博客系统的开源软件。参看《WordPress是怎么赢的？》
Drupal 是一个内容管理系统 (CMS).
Centurion 是一个新出现的开源 CMS ，一个灵然的 PHP5 Content Management Framework. 使用 Zend Framework, 其组件坚持通用，简单，清楚和可重用的设计原则。
phpBB 一个开源的论坛（国内的Discuz！更多）
★ SimplePie : 超快的，易用的, RSS 和 Atom feed PHP解析。
★ PHPthumb, PHP 图片处理库
★ PHPMailer 强大的全功能的PHP邮件库
PubSubHubbub协议，一个简单，开放， server-to-server 的 pubsub (publish/subscribe) 协议——Atom and RSS的扩展。
更多的请参看 – 20个你应该知道PHP库和 9个强大免费的PHP库

数据库

★ Apache CouchDB 是一个面向文档的数据库管理系统。它提供以JSON 作为数据格式的REST 接口来对其进行操作，并可以通过视图来操纵文档的组织和呈现。.源码.
MonoQL 是一个采用PHP+ExtJS开发的MySQL数据库管理工具。界面极像一个桌面应用程序，支持大部分常用的功能包括：表格设计，数据浏览/编辑，数据导入/导出和高级查询等。
MariaDB 是MySQL的一个分支，由MySQL 创始人Monty Widenius 所开发。GPL，用来对抗Oracle所有的MySQL的license的不测。自Oracle收购SUN以来，整个社区对于MySQL前途的担忧就没有停止过。
★ SQLite 不像常见的客户端/服务器结构范例，SQLite引擎不是个程序与之通信的独立进程，而是连接到程序中成为它的一个主要部分。所以主要的通信协议是在编程语言内的直接API调用。这在消耗总量、延迟时间和整体简单性上有积极的作用。整个数据库（定义、表、索引和数据本身）都在宿主主机上存储在一个单一的文件中。它的简单的设计是通过在开始一个事务的时候锁定整个数据文件而完成的。库实现了多数的SQL-92标准，包括事务，就是代表原子性、一致性、隔离性和持久性的（ACID），触发器和多数的复杂查询。不进行类型检查。你可以把字符串插入到整数列中。某些用户发现这是使数据库更加有用的创新，特别是与无类型的脚本语言一起使用的时候。其他用户认为这是主要的缺点。
SQL 在线设计编辑器，这一节的那个图片就是这个在线编辑器的样子了。一个画数据库图表的在线工具。很强大。

API 和在线数据

ProgrammableWeb, 最流行的Web Services 和 API 目录大全。
Google Data Protocol 一组Google服务的数据服务API。
Yahoo! Developer Network – APIs 和 Tools
Yahoo! Pipes 可视化在线编程工具，它是一个用于过滤、转换和聚合网页内容的服务。
★ The Yahoo! Query Language 一个很像 SQL的网页查询工具。

在线代码和媒体编辑器

★ CodeRun Studio一个基于JavaScript语言开发的跨平台的集成开发环境，它立足于云计算的设计思路，方便开发者在浏览器端便可以轻松开发、调试和部署网络应用程序。（参看《Coderun.com 在线开发IDE》）
Cloud9 IDE – 一个基于Node.JS构建的JavaScript程序开发Web IDE。它拥有一个非常快的文本编辑器支持为JS, HTML, CSS和这几种的混合代码进行着色显示。
★ jsFiddle – Javascript的在线运行展示框架，这个工具可以有效的帮助web前端开发人员来有效分享和演示前端效果，其简单而强大 (JavaScript, MooTools, jQuery, Prototype, YUI, Glow and Dojo, HTML, CSS)
Akshell，一种云服务，它使用服务端的JavaScript和在线的IDE帮助开发者进行快速应用程序开发。它还提供云托管，所以部署是即时的。
JSONeditor, 一个好用的JSON 编辑器
★ TinyMCE 一个轻量级的基于浏览器的所见即所得编辑器，支持目前流行的各种浏览器，由JavaScript写成。
Ext Designer 是一个桌面应用工具，帮助你快速开发基于ExtJS 的用户界面。
★ LucidChart，一款基于最新的html5技术的在线图表绘制软件，功能强大，速度快捷，运行此软件需要支持html5的浏览器。
Balsamiq Mockups, 产品设计师绘制线框图或产品原型界面的利器。
Color Scheme Designer 3 - 一个免费的线上调色工具
★ Pixlr, 是一个来自瑞典基于Flash的免费在线图片处理网站。除了操作介面和功能接近Photoshop，还是多语言版本，支持简体中文。（以前酷壳介绍过）
Aviary, 是一个基于HTML5 的在线图片处理工具，可以很容易的对图片进行后期处理。 Aviary API
Favicon Generator, 线上favicon(16×16)制作工具。

代码资源和版本控制

★ GitHub 是一个用于使用Git版本控制系统的项目的基于互联网的存取服务。
Git 是一个由Linus为了更好地管理linux内核开发而创立的分布式版本控制／软件配置管理软件。其巨快无比，高效，采用了分布式版本库的方式，不必服务器端软件支持，使源代码的发布和交流极其方便。
Google Code 谷歌公司官方的开发者网站，包含各种开发技术的API、开发工具、以及开发技术参考资料。
Google Libraries API Google 将优秀的 JavaScript 框架部署在其 CDN 上，在我们的网站上使用 Google Libraries API 可以加速 JavaScript 框架的加载速度。
Snipplr 一个开放的源代码技巧分享社区，号称Code 2.0。和一般的源码分享网站不同，它针对的并不是大型网站源码，而是一些编程的代码技巧。

JavaScript 桌面应用框架

★ jQuery 是一个快速、简单的JavaScript library，它简化了HTML 文件的traversing，事件处理、动画、Ajax 互动，从而方便了网页制作的快速发展。源码, API, API浏览, 很不错的文档.
★ 官方的 jQuery User Interface (UI) library (演示和文档). 源码,Themes Roller, Download.
YUI 2 — Yahoo! User Interface Library
Mootools, 一个超级轻量级的 web2.0 JavaScript framework
Prototype 提供面向对象的Javascript和AJAX
Dojo The Dojo Toolkit，一个强大的无法被打败的面向对象JavaScript框架。主要由三大模块组成：Core、Dijit、DojoX。Core提供 Ajax,events,packaging,CSS-based querying,animations,JSON等相关操作API。Dijit是一个可更换皮肤，基于模板的WEB UI控件库。DojoX包括一些创新/新颖的代码和控件：DateGrid，charts，离线应用，跨浏览器矢量绘图等。
★ Ext JS 4, 业内最强大的 JavaScript framework。
PHP.js, 一个开源的JavaScript 库，它尝试在JavaScript 中实现PHP 函数。在你的项目中导入PHP.JS 库，可以在静态页面使用你喜欢的PHP 函数。

JavaScript 移动和触摸框架

★ jQuery Mobile : 是 jQuery 在手机上和平板设备上的版本。jQuery Mobile 不仅会给主流移动平台带来jQuery核心库，而且会发布一个完整统一的jQuery移动UI框架。支持全球主流的移动平台。jQuery Mobile开发团队说：能开发这个项目，我们非常兴奋。移动Web太需要一个跨浏览器的框架，让开发人员开发出真正的移动Web网站。我们将尽全力去满足这样的需求。 Sources.
Zepto.js Zepto.js 是支持移动WebKit浏览器的JavaScript框架，具有与jQuery兼容的语法。2-5k的库，通过不错的API处理绝大多数的基本工作。 Sources.
MicroJS : Microjs网站应用列出了很多轻量的Javascript类库和框架，它们都很小，大部分小于5kb。这样你不需要因为只需要一个功能就要加载一个JS的框架。
★ PhoneGap :是一款开源的手机应用开发平台，它仅仅只用HTML和JavaScript语言就可以制作出能在多个移动设备上运行的应用。 Sources.
★ Sencha Touch Sencha Touch 是一个支持多种智能手机平台（iPhone, Android, 和BlackBerry）的 HTML5 框架。Sencha Touch可以让你的Web App看起来像Native App。美丽的用户界面组件和丰富的数据管理，全部基于最新的HTML5和CSS3的 WEB标准，全面兼容Android和Apple iOS设备。
JQtouch, 是一个jQuery 的插件，主要用于手机上的Webkit 浏览器上实现一些包括动画、列表导航、默认应用样式等各种常见UI效果的JavaScript 库。 Sources.
DHTMLX Touch 针对移动和触摸设备的JavaScript 框架。DHTMLX Touch基于HTML5，创建移动web应用。它不只是一组UI 小工具，而是一个完整的框架，可以针对移动和触摸设备创建跨平台的web应用。它兼容主流的web浏览器，用DHTMLX Touch创建的应用，可以在iPad、iPhone、Android智能手机等上面运行流畅。

jQuery 插件

Waypoints 是一个jQuery 用来实现捕获各种滚动事件的插件，例如实现无翻页的内容浏览，或者固定某个元素不让滚动等等。支持主流浏览器版本。
Lazy loader 插件可以实现图片的延迟加载，当网页比较长的时候，会先只加载用户视窗内的图片，视窗外的图片会等到你拖动滚动条至后面才加载，这样有效的避免了因图片过多而加载慢的弊端。
TweenJS : 一个简单和强大的 tweening / animation 的Javascript库。
Easings 类Css3的jQuery 动画插件
Spritely 这个插件可以创建出如flash一样的动画效果，比如：在页面上有一只飞动的小鸟，一个动态滚动的背景等。
File Upload, jQuery 文件上传插件4.4.1
Slideshow/Carousel 插件. Sources.
Supersized – 全屏式的背景/幻灯片插件
Masonry i一款非常酷的自动排版插件，这款jQuery工具可以根据网格来自动排列水平和垂直元素，超越原来的css. Sources.
jQuery 简单 Layout 演示，管理各种边栏式，可改变大小式的布局。
Flexigrid – jQuery 数据表插件
Isotope绝对是一个令人难以置信的jQuery插件，你可以用它来创建动态和智能布局。你可以隐藏和显示与过滤项目，重新排序和整理甚至更多。
Super Gestures jQuery 插件可以实现鼠标手势的功能。
MouseWheel 是由Brandon Aaron开发的jQuery插件，用于添加跨浏览器的鼠标滚轮支持。
AutoSuggest jQuery 插件可以让你添加一些自动完成的功能。
qTip 一个漂亮的jQuery 的工具提示插件，这个插件功能相当强大。
jQuery Charts and graphic 用来制作图表。
jQuery Tools– The missing UI library

其它 jQuery 资源

HTML5 视频播放器

★ Popcorn.js 是一个HTML5 Video框架，它提供了易于使用的API来同步交互式内容，让操作HTML5 Video元素的属性，方法和事件变得简单易用。 (来自Mozilla)
LeanBack Player HTML5视频播放器,没有依赖任何JavaScript框架。支持全屏播放，音量控制，在同一个页面中播放多个视频。 (来自Google)
Vid.ly 为你上传的视频提供转换功能，并且为转换后的视频创建一个短网址。通过Vid.ly，让你的视频可以在14种不同的浏览器和设备上播放，不需要再去考虑将要浏览视频的人使用什么设备了，以避免各各软件巨头之间的利益之争带来了不兼容，给用户带来了巨大的困扰，短网址让你可以通过Twitter、 Facebook等方式方便分享视频。Vid.ly还可以通过html代码嵌入到其他网页中。Vid.ly免费帐户空间为1GB，免费帐户也没有播放或浏览限制。

JavaScript 音频处理与可视化效果

★ 使用HTML5 和 Flash, SoundManager V2 只用单一API的提供了可靠，简单和强大的跨平台的音频处理。
DSP, JavaScript的声音Digital Signal Processing
The Radiolab Hyper Audio Player v1, 带给你 WNYC Radiolab, SoundCloud 和 Mozilla Drumbeat
jPlayer, 一个 jQuery HTML5 音频/ 视频库，功能齐全的API

JavaScript 图形和 3D

★ Processing.js是一个开放的编程语言，在不使用Flash或Java小程序的前提下, 可以实现程序图像、动画和互动的应用。其使用Web标准，无需任何插件。
★ Javascript 3D 引擎: ThreeJS 由 Mr Doob 开发，一个轻量级的 3D 引擎，不需要了解细节，傻瓜都能使用。这个引擎可以使用
Shader Toy, 一款使用WebGL的在线着色器编辑器(2D/3D). 基于在线的应用架构使您无需下载任何软件即可开始体验. Shader Toy包含大量实用着色器, 诸如光线追踪, 场景距离渲染, 球体, 隧道, 变形, 后期处理特效等.
PhiloGL, Sencha的PhiloGL是首个WebGL开发工具之一，提供了高水准的功能，来构建WebGL应用。Sencha创建了几个演示，来描述框架交互式3D虚拟化的能力，比如3D view of global temperature changes。
WebGL Inspector 你就Firebug等Web调试工具一样，这个是 WebGL的调试工具。
WebGL frameworks 由 Khronos Group 收集的一个WebGL框架列表。
EaselJS, 一个使用html5的canvas的 JavaScript 库. Sources.
JavaScript Game Frameworks 免费的JS游戏框架列表。另，可参看 JS游戏框架列表。
Raphaël是一个小型的JavaScript 库，用来简化在页面上显示向量图的工作。你可以用它在页面上绘制各种图表、并进行图片的剪切、旋转等操作。参看Javascript向量图Lib–Raphaël
jQuery SVG 插件让你可以了 SVG canvas 进行交互。
Google chart tools – 参看本站的使用Google API做统计图
Arbor.js, 是一个利用webworkers和jQuery创建的数据图形可视化JavaScript框架。它为图形组织和屏幕刷新处理提供了一个高效、力导向布局算法。

JavaScript 浏览器接口 (HTML5)

★ Modernizr – 是一个专为HTML5 和CSS3 开发的功能检测类库，可以根据浏览器对HTML5 和CSS3 的支持程度提供更加便捷的前端优化方案.Sources. 一个有用的列表 cross-browser Polyfills
HTML5Shiv : 该项目的目的是为了让IE 能识别HTML5 的元素。
Polyfills : 这个项目收集了一些代码片段其用Javascript支持不同的浏览器的特别功能，有些代码需要Flash。
YepNopeJS : 一个异步的条件式的加载器。Sources.
jQuery CSS3 Finalise : 是否厌倦了为每一个浏览器的CSS3属性加前缀？
★ Amplify.js :一套用于web应用数据管理和应用程序通讯的 jQuery 组件库。提供简单易用的API接口。Amplify的目标是通过为各种数据源提供一个统一的程序接口简化各种格式数据的数据处理。Amplify的存储组件使用 localStorage 和 sessionStorage标准处理客户端的存储信息，对一些老的浏览器支持可能有问题。Amplify’为jQuery的ajax方法request 增加了一些额外的特性。 Sources.
History.js 优美地支持了HTML5 History/State APIs
Socket.IO Web的socket编程。

JavaScript 工具

★ {{mustaches}} 小型的 JavaScript 模板引擎。
json:select(), CSS式的JSON选择器
HeadJS, 异步JavaScript装载。其最大特点就是不仅可以按顺序执行还可以并发装载载js。
JsDoc Toolkit是一款辅助工具，你只需要根据约定在JavaScript 代码中添加相应的注释，它就可以根据这些注释来自动生成API文档。
Responsive image, 一个试验性的项目，用来处理responsive layouts 式的图片。
UglifyJS是基于NodeJS的Javascript语法解析/压缩/格式化工具，它支持任何CommonJS模块系统的Javascript平台。
Dhteumeuleu, 交互式的 DOM 脚本和DHTML 的开源演示。
Backbone是一个前端 JS 代码 MVC 框架，被著名的 37signals 用来构建他们的移动客户端。它不可取代 Jquery，不可取代现有的Template 库。而是和这些结合起来构建复杂的 web 前端交互应用。如果项目涉及大量的 javascript 代码，实现很多复杂的前端交互功能，首先你会想到把数据和展示分离。使用 Jquery 的 selector 和 callback 可以轻松做到这点。但是对于富客户端的WEB应用大量代码的结构化组织非常必要。Backbone 就提供了 javascript 代码的组织的功能。Backbone 主要包括 models, collections, views 和 events, controller 。

客户端和模拟器

BrowserShot, 检查浏览器的兼容性，跨浏览器平器的测试
Test everything… 输入一个你想要测试的URL……
Android browser 模拟器
iPhone browser 模拟器
Opera browser 模拟器
★ Firebug 与 Firefox 集成，可以查看和调试你的Web页面。

CSS3 和字库

★ CSS3 Maker CCS3的生成器
容易地创建 CSS3 animations。 Sencha Animator 是一个桌面应用可以为WebKit浏览器和触摸式移动设备创建 CSS3 animations 。
CSSwarp – CSS 文本扭曲生成器
Gradient Editor, 一个强大的Photoshop式的CSS 渐变编译器。来自 ColorZilla
★ Google Web Fonts 通过Google Web Fonts API 可以浏览所有的字体
@font-face Kit Generator, 为Web转换字体
Typetester, 比较字体。
Media Queries. 一组 responsive web 设计。
Pattern TAP, UI组件。

Website (FULL) 模板

★ HTML5 Boilerplate 是一个HTML5 / CSS / js模板，是实现跨浏览器正常化、性能优化，稳定的可选功能如跨域Ajax和Flash的最佳实践。项目的开发商称之为技巧集合，目的是满足您开发一个跨浏览器，并且面向未来的网站的需求。 Sources.
HTML5 starter pack 是一个干净的和有组织的目录结构，其可适合很多项目，还有一些很常用的文件，以及简单的Photoshop设计模板。
★ Initializr 是一个HTML5 模板生成器，其可以帮你在15秒内创建一个HTML5的项目。
Animated Portfolio Gallery （教程）
Slick MobileApp Website 如果通过 jQuery 和 CSS 制作一个手机应用的网站。
RSS Reader 如果通过 jQuery Mobile 创建一个RSS Reader
★ Single Page Applications 使用jQuery的朋友们 (Backbone, Underscore, …)创建单一页面。
Google TV Optimized Templates, 传统电视已经开始和网路融合，但现阶段产业仍然正在摸索之中，为此将来的网页亦会有结构上的改变。Google TV Optimized Templates是一个用HTML/JavaScript制成的开源软体，一如其名是一个对Google TV作出了最佳化的的网页范本，其特色是以遥控器作为操作的前提，令使用者无需输入任何文字就可以进行控制。未来除了会有专用遥控器外，还会采用智能手机透过W-iFi控制Google TV的方法。Optimized Templates的界面中左方会展示分类，右方会显示该分类下的影片截图，影片播放、切换、全画面表示都可透过键盘上的方向键、Backspace或 Enter等键完成，方便今后的网站开发人员借镜。HTML5 版的模板使用了 Google TV UI library, jQuery 和 Closure 。

（全文完）

都市淘沙者 2011-06-17 07:58 发表评论

java中传输对象时候的问题（转）

都市淘沙者 — Tue, 17 May 2011 00:39:00 GMT

对于同一个socket，如果调用两次就会抛出StreamCorruptedException

如果你使用socket，并通过对象输入/输出流来处理的话，并且已经对某个socket调用了一次getInputStream时，但又需要把这个socket的相关信息作为参数传递给别的对象时，应注意：不用直接把socket传过去，应该把对应的ObjectInputStream或ObjectOutputStream对象传递过去。

调用getInputStream方法就会读取标示头信息。用缺省的serializetion的实现时,一个ObjectOutputStream的构造和一个ObjectInputStream的构造必须一一对应.ObjectOutputStream的构造函数会向输出流中写入一个标识头,而ObjectInputStream会首先读入这个标识头.因此,多次以追加方式向一个文件中写入object时,该文件将会包含多个标识头.所以用ObjectInputStream来deserialize这个ObjectOutputStream时,将产生StreamCorruptedException.

==============================

使用ObjectStream会出现的问题

1. ObjectInputStream与ObjectOutputStream的顺序问题
在网络通讯中，主机与客户端若使用ObjectInputStream与ObjectOutputStream建立对象通讯，必须注意声明此两个对象的顺序。
如：
主机端先建立ObjectInputStream后建立ObjectOutputStream，则对应地客户端要先建立ObjectOutputStream后建立ObjectInputStream，否则会造成两方互相等待数据而导致死锁。
原因是建立ObjectInputStream对象是需要先接收一定的header数据，接收到这些数据之前会处于阻塞状态。以下为JAVA API文档的说明
Creates an ObjectInputStream that reads from the specified InputStream.
A serialization stream header is read from the stream and verified.
This constructor will block until the corresponding ObjectOutputStream
has written and flushed the header.

故而为了防止这种死锁状态，通讯两方的ObjectInputStraem,ObjectOutputStream必须注意顺序对应使用。

2. ObjectInputStream接收到非ObjectOutputStream数据的问题
在使用ObjectInputStream与ObjectOutputStream对象通讯的通讯双方，假设客户端程序出现错误，发送了非ObjectOutputStream封装发送的数据（比如发送一个数字或字符串到主机），则主机端的ObjectInputStream接收到错误数据后不能自动纠正，会一直接收数据而处于阻塞状态，从而导致通讯失败。尚未找到解决方法。目前想的办法为写自己的ObjectStream类。

3. 解决版本问题
使用ObjectStream的时候会额外发送一个关于对象的序列号
static final long serialVersionUID = ....
手动加入此域则可避免版本差异导致的问题。
对象序列号的计算可用SDK的serialver计算。

======================================

ObjectInputStream ObjectOutputStream

ObjectOutputStream和ObjectInputStream

--ObjectOutputStream

ObjectInputStream 类恢复以前使用 ObjectOutputStream 类序列化后的基本类型数据和对象。

ObjectOutputStream 和 ObjectInputStream 分别利用 FileOutputStream 和 FileInputStream 能支持应用程序实现对象图象的稳定存储。

ObjectInputStream 可用于恢复以前序列化过的对象。另外其它一些情况也使用此类，诸如使用一个 Socket 在主机间传递对象时，

或在远程通讯系统中为实现参数和参变量的通讯而进行对象传递时。

ObjectInputStream 保证从流中创建的图象中的所有对象的类型与 Java 虚拟机中出现的类匹配。使用标准机制按需装载相应类。

只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流中读取。使用 readObject 方法从该流中

读取一个对象。 Java 的安全造型应该用于获取期望类型。在 Java 中, 串和数组都是对象且可当作是序列化过程中的对象。

读取时，它们需要转换为所需类型。

另外基类型也可使用 DataInput 中的正确方法从该流中读取。

对象的缺省逆序列化机制将每个域的内容恢复为它被写入时的值和类型。逆序列化过程中忽略申明为暂时的或静态的域。

对其它对象的引用促使那些对象必须从流中读取。使用引用共享机制正确地恢复对象的图象。逆序列化时总是分配新对象，

防止重写已存在的对象。

读取一个对象同运行一个新对象的构造子类似。为该对象分配的内存初始化为空(NULL)。为非序列化类调用无参构造子，

然后将序列化类的域从该流中恢复，恢复从最接近 java.lang.object 的序列化对象开始，到指定对象结束。

例如读取在示例中写入 ObjectOutputStream 中的流：

FileInputStream istream = new FileInputStream("t.tmp");
ObjectInputStream p = new ObjectInputStream(istream);
int i = p.readInt();
String today = (String)p.readObject();
Date date = (Date)p.readObject();
istream.close();

类通过实现 java.io.Serializable 或 java.io.Externalizable 接口来控制它们的序列化。

实现序列化接口可以使对象能保存和恢复它的完整状态，可以使类在写入流和从流中读取的期间内进行改进。

它自动地遍历对象间的引用，保存和恢复完整图象。在序列化和逆序列化处理过程中需要特定句柄的可序列化类，

必须实现如下这两个方法：

private void writeObject(java.io.ObjectOutputStream stream)
throws IOException;
private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException;

利用 writeObjectmethod 方法将一个特殊类的对象的状态写入某流后，相应的 readObject 方法将负责读取和恢复这些数据。

此方法不必关心状态是属于它的父类还是子类。从 ObjectInputStream 读取数据恢复单个域的状态，并将之赋给该对象的恰当域。

使用 DataInput 方法读取基本数据类型。

序列化操作对没有实现 java.io.Serializable 接口的对象，不读取或分配它的域值。非序列化对象的子类可以是序列化的。

在这种情况下，非序列化类必须有一个无参构造子，使它的域能使用此构造子完成初始化。在此情况下，

子类负责保存和恢复非序列化类的状态。通常情况父类的域是可存储的(公有的、包或保护的)，

或存在用于恢复它的状态的可使用的获取或设置方法。

ObjectInputStream 能获取逆序列化一个对象期间出现的任一异常，一旦出现异常，则放弃读过程。

实现外部接口可以使对象完全控制此对象序列化形式的内容和格式。

调用外部接口的方法：writeExternal 和 readExternal 保存和恢复对象状态。当一个类实现了这些方法时，

它们就能使用 ObjectOutput 和 ObjectInput 方法的所有方法写入或读取它们自己的状态。对象负责管理它出现的相应版本。

ObjectOutputStream

public class ObjectOutputStream
extends OutputStream
implements ObjectOutput, ObjectStreamConstants
类 ObjectOutputStream 将 Java 对象中的基本数据类型和图元写入到一个 OutputStream 对象中。可使用 ObjectInputStream 读取这些对象。

另外使用此流对应的文件能存储这些对象。如果该流是一个网络通讯流，则在另一台主机或另一个处理机上可重建这些对象。

只有支持 java.io.Serializable 接口的对象才能被写入该流。对每个可序列化的对象进行编码，包括相应类的名称和标记，

对象的属性和数组值，以及初始化对象时引用的任何其它对象等。

使用 writeObject 将一个对象写入该流。任一对象，包括串和数组，均采用 writeObject 方法被写入。

也能将多个对象或基类型对象写入此流。反过来，必须以这些对象被写入的相同类型和相同顺序，

从相应的 ObjectInputstream 流中读回这些对象。

基类型也可使用 DataOutput 中的正确方法写入此流。串对象也可使用 writeUTF 方法写入。

一个对象的缺省序列化机制将写入对象的类，类标记和所有的非暂时的和非静态的属性值。

其它对象(除暂时的或静态的属性)的引用也将促使以上这些对象被写入。使用共享机制，对单一对象的多次引用进行编码，

以至对象的图元能被存储为与它原来写入时有相同的形状。

例如写入一个对象，此对象能从 ObjectInputStream 中读出：

FileOutputStream ostream = new FileOutputStream("t.tmp");
ObjectOutputStream p = new ObjectOutputStream(ostream);
p.writeInt(12345);
p.writeObject("Today");
p.writeObject(new Date());
p.flush();
ostream.close();

在序列化处理过程中需要特定句柄的类，必须使用如下这些恰当的标记实现特定的方法：

private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException;
private void writeObject(java.io.ObjectOutputStream stream)
throws IOException

writeObject 方法负责写特定类的对象的状态，以使相应的 readObject 方法能存储它。

此方法不必关心写入对象的父类或子类的状态。使用 writeObject 方法或基本类型支持的 DataOutput

方法将每个域的状态保存到 ObjectOutputStream 中。

序列化操作不能输出没有实现 java.io.Serializable 接口的任一对象的域。非序列化对象的子类可以是序列化的。

在这种情况下，非序列化类必须有一个无参构造子，使它的域能被初始化。在此情况下，子类负责保存和恢复非序列化类的状态。

通常情况父类的域是可存储的(公有的、包或保护的)，或存在用于恢复它的状态的可使用的获取或设置方法。

实现抛出 NotSerializableException 异常的 writeObject 和 readObject 方法能阻止一个对象的序列化。

ObjectOutputStream 将获取这个异常，并放弃这个序列化过程。实现外部接口可以使对象完全控制此对象序列化形式的内容和格式。

调用外部接口的方法：writeExternal 和 readExternal 保存和恢复对象状态。当一个类实现了这些方法时，

它们就能使用 ObjectOutput 和 ObjectInput 方法的所有方法写入或读取它们自己的状态。对象负责管理它出现的相应版本。

import java.io.*;
import java.util.*;

public class Logon implements Serializable {

       private Date date = new Date();
       private String username;
       private transient String password;

       Logon(String name, String pwd) {
              username = name;
              password = pwd;
       }

       public String toString() {
              String pwd = (password == null) ? "(n/a)" : password;
              return "logon info: \n " + "username: " + username + "\n date: " + date + "\n password: " + pwd;
       }

       public static void main(String[] args) throws IOException, ClassNotFoundException {
              Logon a = new Logon("Morgan", "morgan83");
              System.out.println( "logon a = " + a);
              ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out"));
              o.writeObject(a);
              o.close();

              int seconds = 5;
              long t = System.currentTimeMillis() + seconds * 1000;
              while(System.currentTimeMillis() < t) ;

              ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon.out"));
              System.out.println( "Recovering object at " + new Date());
              a = (Logon)in.readObject();
              System.out.println("logon a = " + a);
       }
}

类Logon是一个记录登录信息的类，包括用户名和密码。首先它实现了接口Serializable，这就标志着它可以被序列化。

之后再main方法里ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out"));

新建一个对象输出流包装一个文件流，表示对象序列化的目的地是文件Logon.out。然后用方法writeObject开始写入。

想要还原的时候也很简单ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon.out"));

新建一个对象输入流以文件流Logon.out为参数，之后调用readObject方法就可以了。

都市淘沙者 2011-05-17 08:39 发表评论

Java Float类型减法运算时精度丢失问题

都市淘沙者 — Wed, 08 Dec 2010 02:02:00 GMT

package test1;

public class Test2 {

/**
* @param args
*/
public static void main(String[] args) {
   Float xx = 2.0f;
   Float yy = 1.8f;
   Float tt = xx - yy;
   System.out.println("tttttt-----" + tt);

}

}

果然输出结果是: tttttt-----0.20000005

再测试了几个float类型的减法，除了*.0这样的相减没有异议之外，都存在这个问题，就是说float在相减的时候精度丢失了。后来在网上找到一段解决这个问题的办法，记在这里：

package test1;

import java.math.BigDecimal;

public class Test2 {

/**
* @param args
*/
public static void main(String[] args) {
   Float xx = 2.2f;
   Float yy = 2.0f;
   Float tt = xx - yy;

   BigDecimal b1 = new BigDecimal(Float.toString(xx));
   BigDecimal b2 = new BigDecimal(Float.toString(yy));
   float ss = b1.subtract(b2).floatValue();
   System.out.println("ssss----" + ss);
   System.out.println("tttttt-----" + tt);
}
}
输出为:

ssss----0.2
tttttt-----0.20000005

这样一对比，差异就很明显了。

解决了问题，再找了一下为什么会产生这种差异：

网上有篇文章写得很详细，标题为《剖析float型的内存存储和精度丢失问题》，全文内容如下：

问题提出：12.0f-11.9f=0.10000038，"减不尽"为什么？

现在我们就详细剖析一下浮点型运算为什么会造成精度丢失？

1、小数的二进制表示问题

首先我们要搞清楚下面两个问题：

(1) 十进制整数如何转化为二进制数

算法很简单。举个例子，11表示成二进制数：

11/2=5 余 1

5/2=2 余 1

2/2=1 余 0

1/2=0 余 1

0结束 11二进制表示为(从下往上):1011

这里提一点：只要遇到除以后的结果为0了就结束了，大家想一想，所有的整数除以2是不是一定能够最终得到0。换句话说，所有的整数转变为二进制数的算法会不会无限循环下去呢？绝对不会，整数永远可以用二进制精确表示 ，但小数就不一定了。

(2) 十进制小数如何转化为二进制数

算法是乘以2直到没有了小数为止。举个例子，0.9表示成二进制数

0.9*2=1.8 取整数部分 1

0.8(1.8的小数部分)*2=1.6 取整数部分 1

0.6*2=1.2 取整数部分 1

0.2*2=0.4 取整数部分 0

0.4*2=0.8 取整数部分 0

0.8*2=1.6 取整数部分 1

0.6*2=1.2 取整数部分 0

......... 0.9二进制表示为(从上往下): 1100100100100......

注意：上面的计算过程循环了，也就是说*2永远不可能消灭小数部分，这样算法将无限下去。很显然，小数的二进制表示有时是不可能精确的 。其实道理很简单，十进制系统中能不能准确表示出1/3呢？同样二进制系统也无法准确表示1/10。这也就解释了为什么浮点型减法出现了"减不尽"的精度丢失问题。

2、 float型在内存中的存储

众所周知、 Java 的float型在内存中占4个字节。float的32个二进制位结构如下

float内存存储结构

4bytes 31 30 29----23 22----0

表示实数符号位指数符号位指数位有效数位

其中符号位1表示正，0表示负。有效位数位24位，其中一位是实数符号位。

将一个float型转化为内存存储格式的步骤为：

        （1）先将这个实数的绝对值化为二进制格式，注意实数的整数部分和小数部分的二进制方法在上面已经探讨过了。
     （2）将这个二进制格式实数的小数点左移或右移n位，直到小数点移动到第一个有效数字的右边。
     （3）从小数点右边第一位开始数出二十三位数字放入第22到第0位。
     （4）如果实数是正的，则在第31位放入“0”，否则放入“1”。
     （5）如果n 是左移得到的，说明指数是正的，第30位放入“1”。如果n是右移得到的或n=0，则第30位放入“0”。
     （6）如果n是左移得到的，则将n减去1后化为二进制，并在左边加“0”补足七位，放入第29到第23位。如果n是右移得到的或n=0，则将n化为二进制后在左边加“0”补足七位，再各位求反，再放入第29到第23位。

举例说明： 11.9的内存存储格式

(1) 将11.9化为二进制后大约是" 1011. 1110011001100110011001100..."。

(2) 将小数点左移三位到第一个有效位右侧： "1. 011 11100110011001100110 "。保证有效位数24位，右侧多余的截取（误差在这里产生了 ）。

(3) 这已经有了二十四位有效数字，将最左边一位“1”去掉，得到“ 011 11100110011001100110 ”共23bit。将它放入float存储结构的第22到第0位。

(4) 因为11.9是正数，因此在第31位实数符号位放入“0”。

(5) 由于我们把小数点左移，因此在第30位指数符号位放入“1”。

(6) 因为我们是把小数点左移3位，因此将3减去1得2，化为二进制，并补足7位得到0000010，放入第29到第23位。

最后表示11.9为： 0 1 0000010 011 11100110011001100110

           再举一个例子：0.2356的内存存储格式
      （1）将0.2356化为二进制后大约是0.00111100010100000100100000。
      （2）将小数点右移三位得到1.11100010100000100100000。
      （3）从小数点右边数出二十三位有效数字，即11100010100000100100000放
入第22到第0位。
      （4）由于0.2356是正的，所以在第31位放入“0”。
      （5）由于我们把小数点右移了，所以在第30位放入“0”。
      （6）因为小数点被右移了3位，所以将3化为二进制，在左边补“0”补足七
位，得到0000011，各位取反，得到1111100，放入第29到第23位。

最后表示0.2356为：0 0 1111100 11100010100000100100000

          将一个内存存储的float二进制格式转化为十进制的步骤：
     （1）将第22位到第0位的二进制数写出来，在最左边补一位“1”，得到二十四位有效数字。将小数点点在最左边那个“1”的右边。
     （2）取出第29到第23位所表示的值n。当30位是“0”时将n各位求反。当30位是“1”时将n增1。
     （3）将小数点左移n位（当30位是“0”时）或右移n位（当30位是“1”时），得到一个二进制表示的实数。
     （4）将这个二进制实数化为十进制，并根据第31位是“0”还是“1”加上正号或负号即可。

3、浮点型的减法运算

浮点加减运算过程比定点运算过程复杂。完成浮点加减运算的操作过程大体分为四步：
(1) 0操作数的检查；

如果判断两个需要加减的浮点数有一个为0，即可得知运算结果而没有必要再进行有序的一些列操作。

(2) 比较阶码（指数位）大小并完成对阶；

两浮点数进行加减，首先要看两数的 指数位 是否相同，即小数点位置是否对齐。若两数指数位相同，表示小数点是对齐的，就可以进行尾数的加减运算。反之，若两数阶码不同，表示小数点位置没有对齐，此时必须使两数的阶码相同，这个过程叫做对阶。

如何对阶(假设两浮点数的指数位为 E_x 和 E_y )：

通过尾数的移位以改变 E_x 或 E_y ，使之相等。由于浮点表示的数多是规格化的，尾数左移会引起最高有位的丢失，造成很大误差；而尾数右移虽引起最低有效位的丢失，但造成的误差较小，因此，对阶操作规定使尾数右移，尾数右移后使阶码作相应增加，其数值保持不变。很显然，一个增加后的阶码与另一个相等，所增加的阶码一定是小阶。因此在对阶时，总是使小阶向大阶看齐 ，即小阶的尾数向右移位 ( 相当于小数点左移 ) ，每右移一位，其阶码加 1 ，直到两数的阶码相等为止，右移的位数等于阶差 △ _E。
(3) 尾数（有效数位）进行加或减运算；

对阶完毕后就可有效数位求和。不论是加法运算还是减法运算，都按加法进行操作，其方法与定点加减运算完全一样。
(4) 结果规格化并进行舍入处理。

略

4、计算12.0f-11.9f

12.0f 的内存存储格式为： 0 1 0000010 10000000000000000000000

11.9f 的内存存储格式为: 0 1 0000010 011 11100110011001100110

可见两数的指数位完全相同，只要对有效数位进行减法即可。

12.0f-11.9f 结果： 0 1 0000010 00000011001100110011010

将结果还原为十进制为： 0.000 11001100110011010= 0.10000038

都市淘沙者 2010-12-08 10:02 发表评论

ConcurrentHashMap原理分析

都市淘沙者 — Tue, 07 Dec 2010 02:50:00 GMT

ConcurrentHashMap原理分析

一.Java并发基础

当一个对象或变量可以被多个线程共享的时候，就有可能使得程序的逻辑出现问题。
在一个对象中有一个变量i=0，有两个线程A，B都想对i加1，这个时候便有问题显现出来，关键就是对i加1的这个过程不是原子操作。要想对i进行递增，第一步就是获取i的值，当A获取i的值为0，在A将新的值写入A之前，B也获取了A的值0，然后A写入，i变成1，然后B也写入i，i这个时候依然是1.
当然java的内存模型没有上面这么简单，在Java Memory Model中，Memory分为两类，

main memory和working memory，main memory为所有线程共享，working memory中存放的是线程所需要的变量的拷贝（线程要对main memory中的内容进行操作的话，首先需要拷贝到自己的working memory，一般为了速度，working memory一般是在cpu的cache中的）。volatile的变量在被操作的时候不会产生working memory的拷贝，而是直接操作main memory，当然volatile虽然解决了变量的可见性问题，但没有解决变量操作的原子性的问题，这个还需要synchronized或者CAS相关操作配合进行。

多线程中几个重要的概念:

可见性

也就说假设一个对象中有一个变量i，那么i是保存在main memory中的，当某一个线程要操作i的时候，首先需要从main memory中将i 加载到这个线程的working memory中，这个时候working memory中就有了一个i的拷贝，这个时候此线程对i的修改都在其working memory中，直到其将i从working memory写回到main memory中，新的i的值才能被其他线程所读取。从某个意义上说，可见性保证了各个线程的working memory的数据的一致性。
可见性遵循下面一些规则：

当一个线程运行结束的时候，所有写的变量都会被flush回main memory中。
当一个线程第一次读取某个变量的时候，会从main memory中读取最新的。
volatile的变量会被立刻写到main memory中的，在jsr133中，对volatile的语义进行增强，后面会提到
当一个线程释放锁后，所有的变量的变化都会flush到main memory中，然后一个使用了这个相同的同步锁的进程，将会重新加载所有的使用到的变量，这样就保证了可见性。

原子性

还拿上面的例子来说，原子性就是当某一个线程修改i的值的时候，从取出i到将新的i的值写给i之间不能有其他线程对i进行任何操作。也就是说保证某个线程对i的操作是原子性的，这样就可以避免数据脏读。
通过锁机制或者CAS（Compare And Set 需要硬件CPU的支持）操作可以保证操作的原子性。

有序性

假设在main memory中存在两个变量i和j，初始值都为0，在某个线程A的代码中依次对i和j进行自增操作（i，j的操作不相互依赖），

1
2

i++;
j++;

由于，所以i,j修改操作的顺序可能会被重新排序。那么修改后的ij写到main memory中的时候，顺序可能就不是按照i，j的顺序了，这就是所谓的reordering，在单线程的情况下，当线程A运行结束的后i，j的值都加1了，在线程自己看来就好像是线程按照代码的顺序进行了运行（这些操作都是基于as-if- serial语义的），即使在实际运行过程中，i，j的自增可能被重新排序了，当然计算机也不能帮你乱排序，存在上下逻辑关联的运行顺序肯定还是不会变的。但是在多线程环境下，问题就不一样了，比如另一个线程B的代码如下

1
2
3

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

按照我们的思维方式，当j为1的时候那么i肯定也是1，因为代码中i在j之前就自增了，但实际的情况有可能当j为1的时候i还是为0。这就是 reordering产生的不好的后果，所以我们在某些时候为了避免这样的问题需要一些必要的策略，以保证多个线程一起工作的时候也存在一定的次序。 JMM提供了happens-before 的排序策略。这样我们可以得到多线程环境下的as-if-serial语义。
这里不对happens-before进行详细解释了,详细的请看这里http://www.ibm.com/developerworks/cn/java/j-jtp03304/，这里主要讲一下volatile在新的java内存模型下的变化，在jsr133之前，下面的代码可能会出现问题

1
2
3
4
5
6
7
8
9
10
11
12

Map configOptions;
char[] configText;
volatile boolean initialized = false;
// In Thread A
configOptions = new HashMap();
configText = readConfigFile(fileName);
processConfigOptions(configText, configOptions);
initialized = true;
// In Thread B
while (!initialized)
sleep();
// use configOptions

jsr133之前，虽然对 volatile 变量的读和写不能与对其他 volatile 变量的读和写一起重新排序，但是它们仍然可以与对 nonvolatile 变量的读写一起重新排序，所以上面的Thread A的操作，就可能initialized变成true的时候，而configOptions还没有被初始化，所以initialized先于 configOptions被线程B看到，就产生问题了。

JSR 133 Expert Group 决定让 volatile 读写不能与其他内存操作一起重新排序，新的内存模型下，如果当线程 A 写入 volatile 变量 V 而线程 B 读取 V 时，那么在写入 V 时，A 可见的所有变量值现在都可以保证对 B 是可见的。

结果就是作用更大的 volatile 语义，代价是访问 volatile 字段时会对性能产生更大的影响。这一点在ConcurrentHashMap中的统计某个segment元素个数的count变量中使用到了。

二.线程安全的HashMap

什么时候我们需要使用线程安全的hashmap呢，比如一个hashmap在运行的时候只有读操作，那么很明显不会有问题，但是当涉及到同时有改变也有读的时候，就要考虑线程安全问题了，在不考虑性能问题的时候，我们的解决方案有Hashtable或者 Collections.synchronizedMap(hashMap)，这两种方式基本都是对整个hash表结构做锁定操作的，这样在锁表的期间，别的线程就需要等待了，无疑性能不高。

三.ConcurrentHashMap实现原理

数据结构

ConcurrentHashMap的目标是实现支持高并发、高吞吐量的线程安全的HashMap。当然不能直接对整个hashtable加锁，所以在ConcurrentHashMap中，数据的组织结构和HashMap有所区别。

一个ConcurrentHashMap由多个segment组成，每一个segment都包含了一个HashEntry数组的hashtable，
每一个segment包含了对自己的hashtable的操作，比如get，put，replace等操作，这些操作发生的时候，对自己的 hashtable进行锁定。由于每一个segment写操作只锁定自己的hashtable，所以可能存在多个线程同时写的情况，性能无疑好于只有一个 hashtable锁定的情况。

源码分析

在ConcurrentHashMap的remove，put操作还是比较简单的，都是将remove或者put操作交给key所对应的segment去做的，所以当几个操作不在同一个segment的时候就可以并发的进行。

1
2
3
4

public V remove(Object key) {
int hash = hash(key.hashCode());
return segmentFor(hash).remove(key, hash, null);
}

而segment中的remove操作除了加锁之外和HashMap中的remove操作基本无异。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

/**
* Remove; match on key only if value null, else match both.
*/
V remove(Object key, int hash, Object value) {
lock();
try {
int c = count - 1;
HashEntry[] tab = table;
int index = hash & (tab.length - 1);
HashEntry first = tab[index];
HashEntry e = first;
while (e != null && (e.hash != hash || !key.equals(e.key)))
e = e.next;

V oldValue = null;
if (e != null) {
V v = e.value;
if (value == null || value.equals(v)) {
oldValue = v;
// All entries following removed node can stay
// in list, but all preceding ones need to be
// cloned.
++modCount;
HashEntry newFirst = e.next;
for (HashEntry p = first; p != e; p = p.next)
newFirst = new HashEntry(p.key, p.hash,
newFirst, p.value);
tab[index] = newFirst;
count = c; // write-volatile
}
}
return oldValue;
} finally {
unlock();
}
}

上面的代码中关于volatile类型的变量count值得一提，这里充分利用了Java 5中对volatile语义的增强，count = c的操作必须在modCount，table等操作的后面，这样才能保证这些变量操作的可见性。
Segment类继承于ReentrantLock，主要是为了使用ReentrantLock的锁，ReentrantLock的实现比
synchronized在多个线程争用下的总体开销小。
put操作和remove操作类似。

接下来我们来看下get操作。

1
2
3
4

public V get(Object key) {
int hash = hash(key.hashCode());
return segmentFor(hash).get(key, hash);
}

也是使用了对应的segment的get

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

V get(Object key, int hash) {
if (count != 0) { // read-volatile
HashEntry e = getFirst(hash);
while (e != null) {
if (e.hash == hash && key.equals(e.key)) {
V v = e.value;
if (v != null)
return v;
return readValueUnderLock(e); // recheck
}
e = e.next;
}
}
return null;
}

上面的代码中，一开始就对volatile变量count进行了读取比较，这个还是java5对volatile语义增强的作用，这样就可以获取变量的可见性。所以count != 0之后，我们可以认为对应的hashtable是最新的，当然由于读取的时候没有加锁，在get的过程中，可能会有更新。当发现根据key去找元素的时候，但发现找得的key对应的value为null，这个时候可能会有其他线程正在对这个元素进行写操作，所以需要在使用锁的情况下在读取一下 value，以确保最终的值。

其他相关涉及读取的操作也都类似。

都市淘沙者 2010-12-07 10:50 发表评论

http请求的详细过程【推荐】

都市淘沙者 — Tue, 01 Dec 2009 08:47:00 GMT

对于一个做程序开发的人员来说基础知识非常重要，而在工作中常常忽略掉这些基本功的熟练掌握，无意看到这篇文章，觉得不错，特来转载，由于原创地址不明，在此不作标注，希望作者能理解。
http://www.yuanma.org/data/2009/1009/article_3949.htm

一个http请求的详细过程

我们来看当我们在浏览器输入http://www.mycompany.com:8080/mydir/index.html,幕后所发生的一切。

首先http是一个应用层的协议，在这个层的协议，只是一种通讯规范，也就是因为双方要进行通讯，大家要事先约定一个规范。

1.连接当我们输入这样一个请求时，首先要建立一个socket连接，因为socket是通过ip和端口建立的，所以之前还有一个DNS解析过程，把www.mycompany.com变成ip，如果url里不包含端口号，则会使用该协议的默认端口号。

DNS的过程是这样的：首先我们知道我们本地的机器上在配置网络时都会填写DNS，这样本机就会把这个url发给这个配置的DNS服务器，如果能够找到相应的url则返回其ip，否则该DNS将继续将该解析请求发送给上级DNS，整个DNS可以看做是一个树状结构，该请求将一直发送到根直到得到结果。现在已经拥有了目标ip和端口号，这样我们就可以打开socket连接了。

2.请求连接成功建立后，开始向web服务器发送请求，这个请求一般是GET或POST命令（POST用于FORM参数的传递）。GET命令的格式为：　　GET 路径/文件名 HTTP/1.0
文件名指出所访问的文件，HTTP/1.0指出Web浏览器使用的HTTP版本。现在可以发送GET命令：

GET /mydir/index.html HTTP/1.0，

3.应答 web服务器收到这个请求，进行处理。从它的文档空间中搜索子目录mydir的文件index.html。如果找到该文件，Web服务器把该文件内容传送给相应的Web浏览器。

为了告知浏览器，，Web服务器首先传送一些HTTP头信息，然后传送具体内容（即HTTP体信息），HTTP头信息和HTTP体信息之间用一个空行分开。
常用的HTTP头信息有：
　　① HTTP 1.0 200 OK 　这是Web服务器应答的第一行，列出服务器正在运行的HTTP版本号和应答代码。代码"200 OK"表示请求完成。
　　② MIME_Version:1.0　它指示MIME类型的版本。
　　③ content_type:类型　这个头信息非常重要，它指示HTTP体信息的MIME类型。如：content_type:text/html指示传送的数据是HTML文档。
　　④ content_length:长度值　它指示HTTP体信息的长度（字节）。

4.关闭连接：当应答结束后，Web浏览器与Web服务器必须断开，以保证其它Web浏览器能够与Web服务器建立连接。

下面我们具体分析其中的数据包在网络中漫游的经历

在网络分层结构中，各层之间是严格单向依赖的。“服务”是描述各层之间关系的抽象概念，即网络中各层向紧邻上层提供的一组操作。下层是服务提供者，上层是请求服务的用户。服务的表现形式是原语（primitive），如系统调用或库函数。系统调用是操作系统内核向网络应用程序或高层协议提供的服务原语。网络中的n层总要向n+1层提供比n-1层更完备的服务，否则n层就没有存在的价值。

传输层实现的是“端到端”通信，引进网间进程通信概念，同时也要解决差错控制，流量控制，数据排序（报文排序），连接管理等问题，为此提供不同的服务方式。通常传输层的服务通过系统调用的方式提供，以socket的方式。对于客户端，要想建立一个socket连接，需要调用这样一些函数socket() bind() connect(),然后就可以通过send()进行数据发送。

现在看数据包在网络中的穿行过程：

应用层

首先我们可以看到在应用层，根据当前的需求和动作，结合应用层的协议，有我们确定发送的数据内容，我们把这些数据放到一个缓冲区内，然后形成了应用层的报文data。

传输层

这些数据通过传输层发送，比如tcp协议。所以它们会被送到传输层处理，在这里报文打上了传输头的包头，主要包含端口号，以及tcp的各种制信息，这些信息是直接得到的，因为接口中需要指定端口。这样就组成了tcp的数据传送单位segment。tcp是一种端到端的协议，利用这些信息，比如tcp首部中的序号确认序号，根据这些数字，发送的一方不断的进行发送等待确认，发送一个数据段后，会开启一个计数器，只有当收到确认后才会发送下一个，如果超过计数时间仍未收到确认则进行重发，在接受端如果收到错误数据，则将其丢弃，这将导致发送端超时重发。通过tcp协议，控制了数据包的发送序列的产生，不断的调整发送序列，实现流控和数据完整。

网络层

然后待发送的数据段送到网络层，在网络层被打包，这样封装上了网络层的包头，包头内部含有源及目的的ip地址，该层数据发送单位被称为packet。网络层开始负责将这样的数据包在网络上传输，如何穿过路由器，最终到达目的地址。在这里，根据目的ip地址，就需要查找下一跳路由的地址。首先在本机，要查找本机的路由表，在windows上运行route print就可以看到当前路由表内容，有如下几项：
Active Routes Default Route Persistent Route.

整个查找过程是这样的:
(1)根据目的地址，得到目的网络号，如果处在同一个内网，则可以直接发送。
(2)如果不是，则查询路由表，找到一个路由。
(3)如果找不到明确的路由，此时在路由表中还会有默认网关，也可称为缺省网关，IP用缺省的网关地址将一个数据传送给下一个指定的路由器，所以网关也可能是路由器，也可能只是内网向特定路由器传输数据的网关。
(4)路由器收到数据后，它再次为远程主机或网络查询路由，若还未找到路由，该数据包将发送到该路由器的缺省网关地址。而数据包中包含一个最大路由跳数，如果超过这个跳数，就会丢弃数据包，这样可以防止无限传递。路由器收到数据包后，只会查看网络层的包裹数据，目的ip。所以说它是工作在网络层，传输层的数据对它来说则是透明的。

如果上面这些步骤都没有成功，那么该数据报就不能被传送。如果不能传送的数据报来自本机，那么一般会向生成数据报的应用程序返回一个“主机不可达”或 “网络不可达”的错误。

以windows下主机的路由表为例，看路由的查找过程
======================================================================
Active Routes:
Network Destination            Netmask                      Gateway              Interface                  Metric
0.0.0.0                                 0.0.0.0                       192.168.1.2           192.168.1.101           10
127.0.0.0                             255.0.0.0                   127.0.0.1               127.0.0.1                   1
192.168.1.0                         255.255.255.0           192.168.1.101       192.168.1.101           10
192.168.1.101                     255.255.255.255       127.0.0.1               127.0.0.1                  10
192.168.1.255                     255.255.255.255       192.168.1.101       192.168.1.101           10
224.0.0.0                            240.0.0.0                   192.168.1.101       192.168.1.101           10
255.255.255.255                 255.255.255.255       192.168.1.101       192.168.1.101           1
Default Gateway:                192.168.1.2

Network Destination 目的网段
Netmask 子网掩码
Gateway 下一跳路由器入口的ip，路由器通过interface和gateway定义一调到下一个路由器的链路，通常情况下，interface和gateway是同一网段的。
Interface 到达该目的地的本路由器的出口ip（对于我们的个人pc来说，通常由机算机A的网卡，用该网卡的IP地址标识，当然一个pc也可以有多个网卡）。

网关这个概念，主要用于不同子网间的交互，当两个子网内主机A,B要进行通讯时，首先A要将数据发送到它的本地网关，然后网关再将数据发送给B所在的网关，然后网关再发送给B。
默认网关，当一个数据包的目的网段不在你的路由记录中，那么，你的路由器该把那个数据包发送到哪里！缺省路由的网关是由你的连接上的default gateway决定的，也就是我们通常在网络连接里配置的那个值。

通常interface和gateway处在一个子网内，对于路由器来说，因为可能具有不同的interface,当数据包到达时，根据Network Destination寻找匹配的条目，如果找到，interface则指明了应当从该路由器的那个接口出去，gateway则代表了那个子网的网关地址。

第一条 0.0.0.0 0.0.0.0 192.168.1.2 192.168.1.101 10
0.0.0.0代表了缺省路由。该路由记录的意思是：当我接收到一个数据包的目的网段不在我的路由记录中，我会将该数据包通过192.168.1.101这个接口发送到192.168.1.2这个地址，这个地址是下一个路由器的一个接口，这样这个数据包就可以交付给下一个路由器处理，与我无关。该路由记录的线路质量 10。当有多个条目匹配时，会选择具有较小Metric值的那个。

第三条 192.168.1.0 255.255.255.0 192.168.1.101 192.168.1.101 10
直联网段的路由记录：当路由器收到发往直联网段的数据包时该如何处理，这种情况，路由记录的interface和gateway是同一个。当我接收到一个数据包的目的网段是192.168.1.0时，我会将该数据包通过192.168.1.101这个接口直接发送出去，因为这个端口直接连接着192.168.1.0这个网段，该路由记录的线路质量 10 （因interface和gateway是同一个，表示数据包直接传送给目的地址，不需要再转给路由器）。

一般就分这两种情况，目的地址与当前路由器接口是否在同一子网。如果是则直接发送，不需再转给路由器，否则还需要转发给下一个路由器继续进行处理。

查找到下一跳ip地址后，还需要知道它的mac地址，这个地址要作为链路层数据装进链路层头部。这时需要arp协议，具体过程是这样的，查找arp缓冲，windows下运行arp -a可以查看当前arp缓冲内容。如果里面含有对应ip的mac地址，则直接返回。否则需要发生arp请求，该请求包含源的ip和mac地址，还有目的地的ip地址，在网内进行广播，所有的主机会检查自己的ip与该请求中的目的ip是否一样，如果刚好对应则返回自己的mac地址，同时将请求者的ip mac保存。这样就得到了目标ip的mac地址。

链路层

将mac地址及链路层控制信息加到数据包里，形成Frame，Frame在链路层协议下，完成了相邻的节点间的数据传输，完成连接建立，控制传输速度，数据完整。

物理层

物理线路则只负责该数据以bit为单位从主机传输到下一个目的地。

下一个目的地接受到数据后，从物理层得到数据然后经过逐层的解包到链路层到网络层，然后开始上述的处理，在经网络层链路层物理层将数据封装好继续传往下一个地址。

在上面的过程中，可以看到有一个路由表查询过程，而这个路由表的建立则依赖于路由算法。也就是说路由算法实际上只是用来路由器之间更新维护路由表，真正的数据传输过程并不执行这个算法，只查看路由表。这个概念也很重要，需要理解常用的路由算法。而整个tcp协议比较复杂，跟链路层的协议有些相似，其中有很重要的一些机制或者概念需要认真理解，比如编号与确认，流量控制，重发机制，发送接受窗口。

tcp/ip基本模型及概念

物理层

设备，中继器（repeater）,集线器（hub）。对于这一层来说，从一个端口收到数据，会转发到所有端口。

链路层

协议：SDLC（Synchronous Data Link Control）HDLC（High-level Data Link Control） ppp协议独立的链路设备中最常见的当属网卡，网桥也是链路产品。集线器MODEM的某些功能有人认为属于链路层，对此还有些争议认为属于物理层设备。除此之外，所有的交换机都需要工作在数据链路层，但仅工作在数据链路层的仅是二层交换机。其他像三层交换机、四层交换机和七层交换机虽然可对应工作在OSI的三层、四层和七层，但二层功能仍是它们基本的功能。

因为有了MAC地址表，所以才充分避免了冲突，因为交换机通过目的MAC地址知道应该把这个数据转发到哪个端口。而不会像HUB一样，会转发到所有滴端口。所以，交换机是可以划分冲突域滴。

网络层

四个主要的协议:
网际协议IP：负责在主机和网络之间寻址和路由数据包。
地址解析协议ARP：获得同一物理网络中的硬件主机地址。
网际控制消息协议ICMP：发送消息，并报告有关数据包的传送错误。
互联组管理协议IGMP：被IP主机拿来向本地多路广播路由器报告主机组成员。

该层设备有三层交换机，路由器。

传输层

两个重要协议 TCP 和 UDP 。

端口概念：TCP/UDP 使用 IP 地址标识网上主机，使用端口号来标识应用进程，即 TCP/UDP 用主机 IP 地址和为应用进程分配的端口号来标识应用进程。端口号是 16 位的无符号整数， TCP 的端口号和 UDP 的端口号是两个独立的序列。尽管相互独立，如果 TCP 和 UDP 同时提供某种知名服务，两个协议通常选择相同的端口号。这纯粹是为了使用方便，而不是协议本身的要求。利用端口号，一台主机上多个进程可以同时使用 TCP/UDP 提供的传输服务，并且这种通信是端到端的，它的数据由 IP 传递，但与 IP 数据报的传递路径无关。网络通信中用一个三元组可以在全局唯一标志一个应用进程：（协议，本地地址，本地端口号）。

也就是说tcp和udp可以使用相同的端口。

可以看到通过(协议,源端口，源ip，目的端口，目的ip)就可以用来完全标识一组网络连接。

应用层

基于tcp：Telnet FTP SMTP DNS HTTP
基于udp：RIP NTP（网落时间协议）和DNS （DNS也使用TCP）SNMP TFTP

参考文献：

读懂本机路由表 http://hi.baidu.com/thusness/blog/item/9c18e5bf33725f0818d81f52.html

Internet 传输层协议 http://www.cic.tsinghua.edu.cn/jdx/book6/3.htm

计算机网络谢希仁

都市淘沙者 2009-12-01 16:47 发表评论

既有鱼肉又有熊掌——ListOrderedMap

都市淘沙者 — Thu, 20 Aug 2009 10:22:00 GMT

要有序可以用List，要便于查找可以用Map，那既要有序又便于查找呢？

最近我就遇到了这样一个问题，Java没有给我们提供现成的类，我们完全可以自己开发个类继承List和Map（Java原来就有不可以同时继承List和Map的Bug，因此特意去看了下这个Bug的状态——Closed，呵呵，应该是很老的版本才有的问题，用新版本的朋友不用担心会遇到这个问题），但是完全没必要白花那个力气，因为Apache的Commons Collections的Jar包里已经为我们提供了一个相当完备的类来满足我们这样的要求完全是绰绰有余。因此我们现在要做的仅仅是引入Jar包，然后使用这个现成的好东西——ListOrderedMap就可以啦。

让我们来看看代码：

ListOrderedMap list = new ListOrderedMap();
for ( int i = 0 ; i < objs.length; i ++ ) {
list.put(objs[i].getId(), objs[i]);
}

初始化很简单吧，没有一点技术难度，往里边放数据和Map没一点区别，需要注意的是Map我们可以在初始化的时候加上类型，比如Map，但是ListOrderedMap不可以，就这么点差别，要记得哦。但是这个差别也是ListOrderedMap让人最不满意的地方，因为这说明他是类型不安全的。

接下来，看看我们都用到了ListOrderedMap的哪些方法：

int themeId = ((Obj) list.getValue( 0 )).getThemeId();
int index = list.indexOf(key);
if (index == list.size() - 1 ) {
obj = (Obj) list.getValue( 0 );
} else if (index != - 1 ) {
obj = (Obj) list.getValue(index + 1 );
}

getValue(int index)直接根据Index取得Value，当然也可以直接根据Index取得Key值，方法名可不是getKey(int index)，而是直接get(int index)就可以啦。接着我们想取到当前Key值后面一个Key值所对应的Value，首先用indexOf(Object key)取得Index，然后计算其后面的Index再根据此Index取值。如果想取得当前Key值后面一个Key值，则不必要先取Index，这么麻烦，ListOrderedMap里有直接的方法可以取得当前Key值的前一个Key值和后一Key值，分别是previousKey(Object key)方法和nextKey(Object key)方法，返回null值表示到头（或尾）了，或者没有找到和当前Key值匹配的Key值。个至于这边为什么要有If和Else if，原因很简单，和一般的索引一样，返回值是-1就表示没有找到。我们在这里做了一个循环，而且我的这个ListOrderedMap的数列是确保长度大于0的，所以我把index==list.size()-1的判断放在了前边，如果不能确定长度是否大于0，还是先判断返回值是否为-1为好。

话说多了容易糊涂，不如来个实例实在：

    /**
     * 根据用户账号查找其拥有的实时视频列表
     * @param account
     * @return
     */
    public List findVideoList(String account) {

        List videolist = new ArrayList();
        StringBuffer sqlsb = new StringBuffer("");
        sqlsb.append(" select username,videourl,cratedate from video v where v.customer_account ='");
        sqlsb.append(account);
        sqlsb.append("' ");
        try {
            videolist = jdbcTemplate.queryForList(sqlsb.toString());
        } catch (DataAccessException e) {
            return null;
        }
        return videolist;
    }

    //取list里面的每行纪录中的username，createdate
    private void getVideoList(String account){
        int i= 0;
        List list = videoService.findVideoList(account);
        if(list!=null && list.size()>0){
            for(i=0;i<list.size();i++){
                ListOrderedMap ob = (ListOrderedMap)list.get(i);
                if(ob!=null && ob.size()>0){
                    System.out.println(ob.getValue(0)+ob.getValue(2));
                }
            }
        }
    }

本文只简单介绍了ListOrderedMap的几种比较实用的方法，其他方法使用方法可以参考Apache网站上的相关API：http://commons.apache.org/collections/api-release/index.html

都市淘沙者 2009-08-20 18:22 发表评论

JAVA异常详解

都市淘沙者 — Fri, 06 Feb 2009 03:05:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ -->对于一个非常熟悉 C++ 异常处理模型的程序员来说，它几乎可以不经任何其它培训和学习，就可以完全接受和能够轻松地使用 Java 语言中的异常处理编程方法... 阅读全文

都市淘沙者 2009-02-06 11:05 发表评论

javaIO总结

都市淘沙者 — Thu, 05 Feb 2009 06:52:00 GMT

一． Input和Output
1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Input和Out stream）都包括两种类型：
1.1 以字节为导向的stream
以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：
1) input　stream：
1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
2) StringBufferInputStream：把一个String对象作为InputStream
3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
4) PipedInputStream：实现了pipe的概念，主要在线程中使用
5) SequenceInputStream：把多个InputStream合并为一个InputStream
2) Out　stream
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型：
1) Input　Stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应
2) Out　Stream
1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应

以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，字是在操作时的导向不同。如 CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。
1.3 两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。
2. stream添加属性
2.1 “为stream添加属性”的作用
运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。
如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和 FilterOutStream的子类，为FileOutStream添加我们所需要的功能。
2.2 FilterInputStream的各种类型
2.2.1 用于封装以字节为导向的InputStream
1) DataInputStream：从stream中读取基本类型（int、char等）数据。
2) BufferedInputStream：使用缓冲区
3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用于编译器开发
2.2.2 用于封装以字符为导向的InputStream
1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream
2) BufferedReader：与BufferedInputStream对应
3) LineNumberReader：与LineNumberInputStream对应
4) PushBackReader：与PushbackInputStream对应
2.3 FilterOutStream的各种类型
2.2.3 用于封装以字节为导向的OutputStream
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
2) BufferedOutStream：使用缓冲区
3) PrintStream：产生格式化输出
2.2.4 用于封装以字符为导向的OutputStream
1) BufferedWrite：与对应
2) PrintWrite：与对应
3. RandomAccessFile
1) 可通过RandomAccessFile对象完成对文件的读写操作
2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写
3) 可以直接跳到文件中指定的位置
4. I/O应用的一个例子

Java code

import java.io.*;

publicclass TestIO{

publicstaticvoid main(String[] args)

throws IOException{

//1.以行为单位从一个文件读取数据

BufferedReader in = 

new BufferedReader(

new FileReader("F:""nepalon""TestIO.java"));

String s, s2 =new String();

while((s = in.readLine()) !=null)

s2 += s +""n";

in.close();



//1b. 接收键盘的输入

BufferedReader stdin = 

new BufferedReader(

new InputStreamReader(System.in));

System.out.println("Enter a line:");

System.out.println(stdin.readLine());



//2. 从一个String对象中读取数据

StringReader in2 =new StringReader(s2);

int c;

while((c = in2.read()) !=-1)

System.out.println((char)c);

in2.close();



//3. 从内存取出格式化输入

try{

DataInputStream in3 = 

new DataInputStream(

new ByteArrayInputStream(s2.getBytes()));

while(true)

System.out.println((char)in3.readByte()); 

}

catch(EOFException e){

System.out.println("End of stream");

}



//4. 输出到文件

try{

BufferedReader in4 =

new BufferedReader(

new StringReader(s2));

PrintWriter out1 =

new PrintWriter(

new BufferedWriter(

new FileWriter("F:""nepalon"" TestIO.out")));

int lineCount =1;

while((s = in4.readLine()) !=null)

out1.println(lineCount+++"："+ s);

out1.close();

in4.close();

}

catch(EOFException ex){

System.out.println("End of stream");

}



//5. 数据的存储和恢复

try{

DataOutputStream out2 = 

new DataOutputStream(

new BufferedOutputStream(

new FileOutputStream("F:""nepalon"" Data.txt")));

out2.writeDouble(3.1415926);

out2.writeChars(""nThas was pi:writeChars"n");

out2.writeBytes("Thas was pi:writeByte"n");

out2.close();

DataInputStream in5 =

new DataInputStream(

new BufferedInputStream(

new FileInputStream("F:""nepalon"" Data.txt")));

BufferedReader in5br =

new BufferedReader(

new InputStreamReader(in5));

System.out.println(in5.readDouble());

System.out.println(in5br.readLine());

System.out.println(in5br.readLine());

}



catch(EOFException e){

System.out.println("End of stream");

}



//6. 通过RandomAccessFile操作文件

RandomAccessFile rf =

new RandomAccessFile("F:""nepalon"" rtest.dat", "rw");

for(int i=0; i<10; i++)

rf.writeDouble(i*1.414);

rf.close();



rf =new RandomAccessFile("F:""nepalon"" rtest.dat", "r");

for(int i=0; i<10; i++)

System.out.println("Value "+ i +"："+ rf.readDouble());

rf.close();



rf =new RandomAccessFile("F:""nepalon"" rtest.dat", "rw");

rf.seek(5*8);

rf.writeDouble(47.0001);

rf.close();



rf =new RandomAccessFile("F:""nepalon"" rtest.dat", "r");

for(int i=0; i<10; i++)

System.out.println("Value "+ i +"："+ rf.readDouble());

rf.close();

}

}

关于代码的解释（以区为单位）：
1区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。
2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。
4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，先把格式化后的信息输出到缓存中，再把缓存中的信息输出到文件中。
5区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文件中的数据读取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以为了正确显示。也要以基本类型的形式进行读取。
6区是通过RandomAccessFile类对文件进行操作。

都市淘沙者 2009-02-05 14:52 发表评论

j2ee的性能调优

都市淘沙者 — Sat, 23 Aug 2008 16:33:00 GMT

来源：中国IT实验室

摘要:我提倡使用最小化资源的方式做一次压力测试，排除大部分浅显的应用问题。最小资源的意思，即在pc环境，使用应用可以运行的最小资源状态下，进行压力测试和性能问题侦测的工作。

前面看到有人讲j2ee的性能调优，虽然这块不是自己的专长，但是猪养多了，也忍不住跳出来说几句。

虽然几乎每本讲性能调优的书籍开篇都会提，没必要的情况下就不要做调优，但是我个人还是认为，所有系统在上线前，都应该做一次基本的压力测试并对相关的性能问题进行检测，但是迫于资源压力，很多项目都无法做正规的压力测试，一直到系统上线出现问题，才倒回来找原因。而正规的压力测试，往往因为需要严格模拟生产环境，需要耗费大量的资源，各类专家配合解决问题，并不是那么轻松的可以做下来的。

而 j2ee应用的特点就是以复杂性来回避传统问题，所以任意一个j2ee的部署，相对于php那样的结构都是比较复杂的。系统一旦发生性能问题，必须在程序、数据库、应用服务器、jvm、操作系统几大块中交叉进行考虑，根据实际情况问题，问题的原因可能异常复杂。我们可以想象一个项目，从来不做UT不做 IT ，只做一次UAT，然后直接提交给用户上线以后，修补错误的困难度和成本。

经常看到一些调优的最后解决方案，可以肯定，几乎 80%以上都是一些低级的程序错误导致的，剩下的20%虽然可能是用硬件，os参数调整等等问题解决了，但是其中很大一块，归根到底也是程序的问题。而在我们回顾这些错误的时候可以很惊人的发现，大部分都是一些低级错误。

我提倡使用最小化资源的方式做一次压力测试，排除大部分浅显的应用问题。最小资源的意思，即在pc环境，使用应用可以运行的最小资源状态下，进行压力测试和性能问题侦测的工作。这种做法的优点如下。

1. 环境容易搭建，特别是不需要考虑大型硬件和网络条件等等，也回避了开发人员可能不熟悉unix和特定应用服务器等问题

2. 不需要特别的数据库，操作系统和应用服务器专家配合，开发人员自身即可完成。

3. 不需要特别的依赖os和应用服务器，jvm的监测工具。选择自己最熟悉的即可。

4. 开发人员在熟悉这种过程以后，再转到正式的生产环境工作时也更有经验，更容易解决问题。

对测试过程做一点简单介绍。

工具准备：

得益于开源技术的发展，大部分工具都可以免费获得，使用也比较简单。

1. jvm 监控：对jvm的运行状态进行分析，可以使用jvm自身带的特性输出日志，结合hp的jmeter profile进行分析。也可以使用jrockit自带的图形化工具mession control。

熟悉什么用什么，越简单越好，目的主要是观察内存堆的变化，线程资源变化，gc情况等。

2. 数据库监控工具：熟悉数据库的使用数据库自身的特性，不熟悉的可以使用第三方工具，主要目的是观察数据库的锁，连接数信息，对于db2我比较喜欢使用quest central。 oracle使用OEM或者自身的数据字典已经可以。

3. 应用服务器监控：主要目的是记录方法的调用情况和执行时间，找出频繁调用的方法和执行时间过长的方法。使用jprobe和jprofile都可以很轻松的做到。如果使用的应用服务器比较偏门，那么可以换一个支持这种检测工具的应用服务器。反正主要目的只是在找问题。

4. sql执行监控：跟踪找出执行时间过长的sql。我喜欢使用p6spy。

5. 压力工具： jmeter+badboy , 有条件的可以用loadrunner，和loadrunner近似的还有一个免费的开源产品。另外web 应用的话，也可以使用selenium这样的ff扩展来做。微软vs自带的也不错，反正是什么简单用什么。

6. 记录表格：对问题和资源配置的变更进行记录和对比。

我发现有些人做压力测试，只用压力工具来跑，不肯用各类proile工具来跟踪应用和数据库使用情况，加上经验又不足，结果测来测去都是瞎猜。

设置：

1. 数据库：如果未使用连接池，则尽可能的将数据库允许连接设置成最小数字，推荐是从1开始。如果使用连接池，则设置为1.

随着并发模拟数的增加也可以适当上调，但是一定要低于压力工具模拟的并发用户数。数据库环境尽可能接近生产环境，至少要有足够的测试数据。

2. 应用服务器：对jvm启动堆做最小化设置。比应用服务器要求的最低内存略高，保证应用可以正常启动即可。根据模拟用户数增加可以小步适当上调，但是以保证应用基本运行即可。千万别来大内存。

3. 压力模拟并发数，从1开始逐步往上加。一次加1，2个，上限不要太高，5-10个足以。

步骤

1. 按1用户1连接的方式进行检测

* 找出系统是否存在明显的资源泄露，比如数据库连接，如果存在泄露此种情况下服务器很容易就hold。

* 找出执行时间过长的java方法和sql。进行分析修改。

* 找出那些调用过多的方法和sql，对程序进行分析，看是否做了不必要的调用。这个问题尤其在使用了第三方包的情况下要小心，我曾经监测出某人写的东西一个方法间接的调用了数据库操作近200次。

有些人做测试喜欢从5以上的数字开始，实在不是什么好习惯，比较明显的问题都容易回避了。

2. 适当增加并发用户，尽可能不调整应用内存，对系统进行长时间的压力测试，比如2-4个小时。重点观察是否存在内存泄露问题。内存泄露的问题比较复杂，有时候还依赖于jvm和os，另外有些内存泄露只能在大并发的多线程环境下才会出现。但是这种测试可以排除掉一些明显的问题，主要是缓存和队列之类的东西。内存泄露一般jvm会有报错和相关的日志dump文件。

3. 逐步增加并发用户和连接数，观察是否存在sql锁和线程锁的问题。另外并发情况下也可能存在其他一些资源冲突，比如读写文件的情况等等。

线程情况可以使用监控工具观察，比如jrockit带的mc，也可以直接dump jvm 内存快照找工具分析。

4. 尽可能增加并发用户数，以当前应用能承担的上线进行长时间测试，比如半天到1天，观察是否会存在内存泄露，是否会存在线程资源消耗的问题。也需要检查一下数据库的连接数情况，看是否会一直持续增加，这说明连接池实现有问题，或者设置过大，也可能是jdbc的问题。

5. 其他：对jvm 可以使用sun和bea的都对比跑一下，两个实现情况大不同。 jr大并发支持好，所以可能jr上没问题，但是sun的就有问题了。

大部分的问题应该都可以在步骤1，2能得到暴露。在完成了这样的初步测试以后，正式的测试就省心不少了，如果客户有钱，性能不好也可以直接更新硬件了，省事又创造GDP。

都市淘沙者 2008-08-24 00:33 发表评论

利用HttpURLConnection连接servlet，发送接收xml包(转)

都市淘沙者 — Sat, 09 Aug 2008 14:41:00 GMT

都市淘沙者 2008-08-09 22:41 发表评论

HttpURLConnection常用处理方式

都市淘沙者 — Fri, 09 May 2008 05:25:00 GMT

摘要: /**//* * Classname : GameSoapProcessor * Create Date : 2008-5-7 */ package cn.... 阅读全文

都市淘沙者 2008-05-09 13:25 发表评论

Java分页

都市淘沙者 — Mon, 05 May 2008 14:18:00 GMT

定义两个vector，一个为储存查询所有记录的totalv,另一个储存当前页的记录currentpagev;
总的记录数：int totalsize = totalv.getsize();
每页显示的记录数：int countperpage;
总页数：int totalpagenum = totalsize/countperpage;
//如果总的记录数和每页记录数的余数大于零，
//那么总的页数为他们的整除结果加一
if (totalsize%countperpage > 0 ){
totalpagenum = totalsize/countperpage + 1;
}
当前的页数：pagenum；

for (int j = 0;j //分页，根据当前的页数和每页显示的记录数从totalv中取出记录
//往currentpagev中添加记录；
//如果当前记录在(当前页码-1)*每页显示记录数（包括等于）
//和当前页码*每页显示记录数（不包括等于）之间的时候；
//就属于该页的数据
if ( (j >= (pagenum - 1) * countperpage) && (j < pagenum * countperpage)) {
currentpagev.addelement(totalv.get(j));
}
//当currentpagev记录数等于每页显示记录数，
//停止往currentpagev中添加记录
if (currentpagev.size() == countperpage) {
break;
}
}
那么，当前页中显示的记录，就是currentpagev中的记录。

都市淘沙者 2008-05-05 22:18 发表评论

在java中理解“回调函数”

都市淘沙者 — Thu, 27 Mar 2008 09:40:00 GMT

所谓回调，就是客户程序C调用服务程序S中的某个函数A，然后S又在某个时候反过来调用C中的某个函数B，对于C来说，这个B便叫做回调函数。

一般说来，C不会自己调用B，C提供B的目的就是让S来调用它，而且是C不得不提供。由于S并不知道C提供的B叫甚名谁，所以S会约定B的接口规范（函数原型），然后由C提前通过S的一个函数R告诉S自己将要使用B函数，这个过程称为回调函数的注册，R称为注册函数。

下面举个通俗的例子：

某天，我打电话向你请教问题，当然是个难题，:)，你一时想不出解决方法，我又不能拿着电话在那里傻等，于是我们约定：等你想出办法后打手机通知我，这样，我就挂掉电话办其它事情去了。过了XX分钟，我的手机响了，你兴高采烈的说问题已经搞定，应该如此这般处理。故事到此结束。

这个例子说明了“异步+回调”的编程模式。其中，你后来打手机告诉我结果便是一个“回调”过程；我的手机号码必须在以前告诉你，这便是注册回调函数；我的手机号码应该有效并且手机能够接收到你的呼叫，这是回调函数必须符合接口规范。

如果你还不太清楚看看这段描述合和代码：

声明一个接口，另外一个类有方法里面有个参数以是这个接口类型的，而后在另外类中实现这个接口(java中多用的是匿名内部类)，而且以这个匿名的类生成的对象为参数传到上面提到类中，而后实现回调.......这种用法可以参考java里面常用到的数据库操作所用到的几个接口.....

注：匿名内部类的说明可以见 http://dev.csdn.net/author/CMTobby/339cbab3897f4106bed2fe2ecd75470a.html

//声明一个接口

public interface ICallBack(){

  void postExec();

}

    //另外一个类有方法里面有个参数以是这个接口类型的

public class FooBar..{

  private ICallBack callBack;

  public void setCallBack(ICallBack callBack){

    this.callBack=callBack;

  }

  public void doSth(){

     .

     callBack.postExec();

  }

  ..

}

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

回调的实现

public class Test{

   public static void main(String[] args){

     FooBar foo=new FooBar();

     foo.setCallBack(new ICallBack(){

        public void postExec(){System.out.println("method executed.");}

     });

   }

}

都市淘沙者 2008-03-27 17:40 发表评论

网络编程中的异步编程

都市淘沙者 — Thu, 27 Mar 2008 08:58:00 GMT

该文章对编写客户服务器应用的java程序员有所帮助,可以解决程序在对方出现故障的时候继续稳定运行.
　　目前java平台已经广泛应用于各类客户/服务器系统中，在实际编程中，往往需要网络的异步处理。比如客户程序，如果客户程序运行先于服务程序，则客户程序则需要在服务程序启动后再自动连接服务程序；在客户程序运行中如果服务程序中途停止，则也需要在不停止的条件下，等待服务程序运行并重新连接。下面提供了一类异步编程的方法。
网络异步应用涉及到如下几个关键点：
　　客户应用启动后，检测服务应用是否存在。如果不存在，则等待服务应用启动，同时不堵塞客户应用其他任务的执行。一旦服务应用启动，客户应用应该及时的与其建立连接。
　　客户应用和服务应用在数据通信中，服务应用异常退出后，客户应用应可以检测到服务应用的退出。同时客户应用自动清除该通信链路，回到初始状态，等待服务应用重新启动。
　　该网络异步编程首先涉及到一个定时器和定时器事件。该定时器用于不断的检测网络中客户应用和服务应用是否连通，同时在服务应用出现异常时中止数据通信，返回到初始状态。网络的故障可以通过网络方法的异常处理获知。
　　定时器包含在网络通信类中，使得使用该类的应用感知不到定时器的存在，而方便的处理网络信息。
该客户程序类如下结构：

/*
* Classname       : NetComm.java
* Create Date     : 5:04:00 PM
* Author          : Administrator
* Product Name    : tagApp

*/

package jdom;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;

public class NetComm implements ActionListener {

    javax.swing.Timer timer = new javax.swing.Timer(3000, this);

    Socket sock;

    private EventNotifier en;

    public static int net_state = 0;

    InetAddress ServerAddr;

    int ServerPort;

    public NetComm(InetAddress addr, int port) {
        ServerAddr = addr;
        ServerPort = port;
    }

    //初始化并创建socket连接
    public void NetComm_Init() {

        net_state = 1;
        try {
            sock = new Socket(ServerAddr, ServerPort);
        } catch (IOException e) {
            net_state = 0;
        }
        timer.start();
    }

    //创建socket连接
    public void NetComm_Data() {

        try {
            OutputStream outputstream = sock.getOutputStream();
            BufferedWriter out = new BufferedWriter(new OutputStreamWriter(
                    outputstream));

            out.write("java by ghf@china.com");
            out.flush();

            BufferedReader in = new BufferedReader(new InputStreamReader(sock
                    .getInputStream()));

            boolean more = true;
            while (more) {
                String str = in.readLine();
                if (str == null) {
                    more = false;
                } else {
                    // 处理数据
                    System.out.println(str);
                }
            }
            in.close();

        } catch (IOException e) {
            NetComm_Close();
            net_state = 0;
        }
        timer.start();
    }

    public void NetComm_Close() {
        if (sock != null)
            try {
                sock.close();
            } catch (IOException e) {
            }
    }

    public void actionPerformed(ActionEvent e) {
        if (net_state == 0) {
            NetComm_Init();
        } else {
            NetComm_Data();
        }
    }
}

在以上程序中，也可以为外部应用提供一个回调函数，以便在网络异常或恢复正常时通知应用。服务应用的网络通信类类似，可以放在同一类中。

都市淘沙者 2008-03-27 16:58 发表评论

实战体会Java的多线程编程【转】

都市淘沙者 — Mon, 24 Mar 2008 01:05:00 GMT

摘要: 在Java 程序中使用多线程要比在 C 或 C++ 中容易得多，这是因为 Java 编程语言提供了语言级的支持。本文通过简单的编程示例来说明 Java 程序中的多线程是多么直观。读完本文以后，用户应该能够编写简单的多线程程序。　　为什么会排队等待？　　下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，... 阅读全文

都市淘沙者 2008-03-24 09:05 发表评论

分层模式中的常见问题(zhuan)

都市淘沙者 — Mon, 17 Mar 2008 05:14:00 GMT

引言

分层结构是目前复杂应用系统开发时普遍使用的模式，软件中层之间的依赖关系约束是比较宽松的，并不要求上层仅可以依赖于直接下层，而是上层可以依赖于它的所有下层。

设计中我们会把各种系统的各种组件映射至不同层中，而在我所接触的一些实际项目中设计人员在映射这种组件和层间的关系时经常无意中破坏了层结构的依赖关系约束。

图表 1典型分层结构

设计中的常见问题

问题一:数据传输对象（DTO）是否应该属于业务层？

在J2EE开发的经典著作《Core J2EE Patterns》中数据传输对象被划分在业务层模式中，那么是否数据传输对象应该被映射到业务层呢？

数据访问对象（DAO）在该著作中是被映射到整合层的，这样就会出现一个违反层依赖约束的问题，因为数据访问对象是要依赖于数据传输对象的，因此下层就会出现对上层的依赖了。

所以本人认为DTO是在各层中传输数据的，我们可以不必强求的把他们映射到上述层次中，可以把他们放置在一个公共包中。

问题二:使用POJO作业务对象的轻量级架构与上述层模型的映射

在使用POJO的轻量级结构中我们通常会使用持久化框架（如Hibernate/JPA）同时会在架构中引入仓库对象(Repository Object)，负责业务对象的获取和保存。（注意：他的功能和DAO是有区别的，仓库对象中通常只应包括业务对象的获取和保存逻辑）。

通常设计人员会把业务对象映射至业务层，而将仓库对象映射至整合层。由于仓库对象对于业务对象的依赖关系就会破坏依赖关系约束，所以这种映射方式显然不正确。

下图是作者推荐的映射方式

图表 2轻量级架构参考模型

可以看到业务对象和仓库对象都被映射至业务层，而持久化框架被映射到了整合层。

总结

因此大家在设计过程中不要仅仅将分层结构留于形式，而要时刻注意设计是否符合这种架构模式，这样才能真正发挥这种架构模式的优势。

都市淘沙者 2008-03-17 13:14 发表评论

线程同步 (转)

都市淘沙者 — Sat, 15 Mar 2008 12:17:00 GMT

原文:http://www.javaeye.com/topic/164905

我们可以在计算机上运行各种计算机软件程序。每一个运行的程序可能包括多个独立运行的线程（Thread）。
线程（Thread）是一份独立运行的程序，有自己专用的运行栈。线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。
当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。
同步这个词是从英文synchronize（使同时发生）翻译过来的。我也不明白为什么要用这个很容易引起误解的词。既然大家都这么用，咱们也就只好这么将就。
线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。

因此，关于线程同步，需要牢牢记住的第一点是：线程同步就是线程排队。同步就是排队。线程同步的目的就是避免线程“同步”执行。这可真是个无聊的绕口令。
关于线程同步，需要牢牢记住的第二点是 “共享”这两个字。只有共享资源的读写访问才需要同步。如果不是共享资源，那么就根本没有同步的必要。
关于线程同步，需要牢牢记住的第三点是，只有“变量”才需要同步访问。如果共享的资源是固定不变的，那么就相当于“常量”，线程同时读取常量也不需要同步。至少一个线程修改共享资源，这样的情况下，线程之间就需要同步。
关于线程同步，需要牢牢记住的第四点是：多个线程访问共享资源的代码有可能是同一份代码，也有可能是不同的代码；无论是否执行同一份代码，只要这些线程的代码访问同一份可变的共享资源，这些线程之间就需要同步。

为了加深理解，下面举几个例子。
有两个采购员，他们的工作内容是相同的，都是遵循如下的步骤：
（1）到市场上去，寻找并购买有潜力的样品。
（2）回到公司，写报告。
这两个人的工作内容虽然一样，他们都需要购买样品，他们可能买到同样种类的样品，但是他们绝对不会购买到同一件样品，他们之间没有任何共享资源。所以，他们可以各自进行自己的工作，互不干扰。
这两个采购员就相当于两个线程；两个采购员遵循相同的工作步骤，相当于这两个线程执行同一段代码。

下面给这两个采购员增加一个工作步骤。采购员需要根据公司的“布告栏”上面公布的信息，安排自己的工作计划。
这两个采购员有可能同时走到布告栏的前面，同时观看布告栏上的信息。这一点问题都没有。因为布告栏是只读的，这两个采购员谁都不会去修改布告栏上写的信息。

下面增加一个角色。一个办公室行政人员这个时候，也走到了布告栏前面，准备修改布告栏上的信息。
如果行政人员先到达布告栏，并且正在修改布告栏的内容。两个采购员这个时候，恰好也到了。这两个采购员就必须等待行政人员完成修改之后，才能观看修改后的信息。
如果行政人员到达的时候，两个采购员已经在观看布告栏了。那么行政人员需要等待两个采购员把当前信息记录下来之后，才能够写上新的信息。
上述这两种情况，行政人员和采购员对布告栏的访问就需要进行同步。因为其中一个线程（行政人员）修改了共享资源（布告栏）。而且我们可以看到，行政人员的工作流程和采购员的工作流程（执行代码）完全不同，但是由于他们访问了同一份可变共享资源（布告栏），所以他们之间需要同步。

同步锁

前面讲了为什么要线程同步，下面我们就来看如何才能线程同步。
线程同步的基本实现思路还是比较容易理解的。我们可以给共享资源加一把锁，这把锁只有一把钥匙。哪个线程获取了这把钥匙，才有权利访问该共享资源。
生活中，我们也可能会遇到这样的例子。一些超市的外面提供了一些自动储物箱。每个储物箱都有一把锁，一把钥匙。人们可以使用那些带有钥匙的储物箱，把东西放到储物箱里面，把储物箱锁上，然后把钥匙拿走。这样，该储物箱就被锁住了，其他人不能再访问这个储物箱。（当然，真实的储物箱钥匙是可以被人拿走复制的，所以不要把贵重物品放在超市的储物箱里面。于是很多超市都采用了电子密码锁。）
线程同步锁这个模型看起来很直观。但是，还有一个严峻的问题没有解决，这个同步锁应该加在哪里？
当然是加在共享资源上了。反应快的读者一定会抢先回答。
没错，如果可能，我们当然尽量把同步锁加在共享资源上。一些比较完善的共享资源，比如，文件系统，数据库系统等，自身都提供了比较完善的同步锁机制。我们不用另外给这些资源加锁，这些资源自己就有锁。
但是，大部分情况下，我们在代码中访问的共享资源都是比较简单的共享对象。这些对象里面没有地方让我们加锁。
读者可能会提出建议：为什么不在每一个对象内部都增加一个新的区域，专门用来加锁呢？这种设计理论上当然也是可行的。问题在于，线程同步的情况并不是很普遍。如果因为这小概率事件，在所有对象内部都开辟一块锁空间，将会带来极大的空间浪费。得不偿失。
于是，现代的编程语言的设计思路都是把同步锁加在代码段上。确切的说，是把同步锁加在“访问共享资源的代码段”上。这一点一定要记住，同步锁是加在代码段上的。
同步锁加在代码段上，就很好地解决了上述的空间浪费问题。但是却增加了模型的复杂度，也增加了我们的理解难度。
现在我们就来仔细分析“同步锁加在代码段上”的线程同步模型。
首先，我们已经解决了同步锁加在哪里的问题。我们已经确定，同步锁不是加在共享资源上，而是加在访问共享资源的代码段上。
其次，我们要解决的问题是，我们应该在代码段上加什么样的锁。这个问题是重点中的重点。这是我们尤其要注意的问题：访问同一份共享资源的不同代码段，应该加上同一个同步锁；如果加的是不同的同步锁，那么根本就起不到同步的作用，没有任何意义。
这就是说，同步锁本身也一定是多个线程之间的共享对象。

Java语言的synchronized关键字

为了加深理解，举几个代码段同步的例子。
不同语言的同步锁模型都是一样的。只是表达方式有些不同。这里我们以当前最流行的Java语言为例。Java语言里面用synchronized关键字给代码段加锁。整个语法形式表现为
synchronized(同步锁) {
// 访问共享资源，需要同步的代码段
}

这里尤其要注意的就是，同步锁本身一定要是共享的对象。

… f1() {

Object lock1 = new Object(); // 产生一个同步锁

synchronized(lock1){
// 代码段 A
// 访问共享资源 resource1
// 需要同步
}
}

上面这段代码没有任何意义。因为那个同步锁是在函数体内部产生的。每个线程调用这段代码的时候，都会产生一个新的同步锁。那么多个线程之间，使用的是不同的同步锁。根本达不到同步的目的。
同步代码一定要写成如下的形式，才有意义。

public static final Object lock1 = new Object();

… f1() {

synchronized(lock1){ // lock1 是公用同步锁
// 代码段 A
// 访问共享资源 resource1
// 需要同步
}

你不一定要把同步锁声明为static或者public，但是你一定要保证相关的同步代码之间，一定要使用同一个同步锁。
讲到这里，你一定会好奇，这个同步锁到底是个什么东西。为什么随便声明一个Object对象，就可以作为同步锁？
在Java里面，同步锁的概念就是这样的。任何一个Object Reference都可以作为同步锁。我们可以把Object Reference理解为对象在内存分配系统中的内存地址。因此，要保证同步代码段之间使用的是同一个同步锁，我们就要保证这些同步代码段的synchronized关键字使用的是同一个Object Reference，同一个内存地址。这也是为什么我在前面的代码中声明lock1的时候，使用了final关键字，这就是为了保证lock1的Object Reference在整个系统运行过程中都保持不变。
一些求知欲强的读者可能想要继续深入了解synchronzied(同步锁)的实际运行机制。Java虚拟机规范中（你可以在google用“JVM Spec”等关键字进行搜索），有对synchronized关键字的详细解释。synchronized会编译成 monitor enter, … monitor exit之类的指令对。Monitor就是实际上的同步锁。每一个Object Reference在概念上都对应一个monitor。
这些实现细节问题，并不是理解同步锁模型的关键。我们继续看几个例子，加深对同步锁模型的理解。

public static final Object lock1 = new Object();

… f1() {

synchronized(lock1){ // lock1 是公用同步锁
// 代码段 A
// 访问共享资源 resource1
// 需要同步
}
}

… f2() {

synchronized(lock1){ // lock1 是公用同步锁
// 代码段 B
// 访问共享资源 resource1
// 需要同步
}
}

上述的代码中，代码段A和代码段B就是同步的。因为它们使用的是同一个同步锁lock1。
如果有10个线程同时执行代码段A，同时还有20个线程同时执行代码段B，那么这30个线程之间都是要进行同步的。
这30个线程都要竞争一个同步锁lock1。同一时刻，只有一个线程能够获得lock1的所有权，只有一个线程可以执行代码段A或者代码段B。其他竞争失败的线程只能暂停运行，进入到该同步锁的就绪（Ready）队列。
每一个同步锁下面都挂了几个线程队列，包括就绪（Ready）队列，待召（Waiting）队列等。比如，lock1对应的就绪队列就可以叫做lock1 - ready queue。每个队列里面都可能有多个暂停运行的线程。
注意，竞争同步锁失败的线程进入的是该同步锁的就绪（Ready）队列，而不是后面要讲述的待召队列（Waiting Queue，也可以翻译为等待队列）。就绪队列里面的线程总是时刻准备着竞争同步锁，时刻准备着运行。而待召队列里面的线程则只能一直等待，直到等到某个信号的通知之后，才能够转移到就绪队列中，准备运行。
成功获取同步锁的线程，执行完同步代码段之后，会释放同步锁。该同步锁的就绪队列中的其他线程就继续下一轮同步锁的竞争。成功者就可以继续运行，失败者还是要乖乖地待在就绪队列中。
因此，线程同步是非常耗费资源的一种操作。我们要尽量控制线程同步的代码段范围。同步的代码段范围越小越好。我们用一个名词“同步粒度”来表示同步代码段的范围。
同步粒度
在Java语言里面，我们可以直接把synchronized关键字直接加在函数的定义上。
比如。
… synchronized … f1() {
// f1 代码段
}

这段代码就等价于
… f1() {
synchronized(this){ // 同步锁就是对象本身
// f1 代码段
}
}

同样的原则适用于静态（static）函数
比如。
… static synchronized … f1() {
// f1 代码段
}

这段代码就等价于
…static … f1() {
synchronized(Class.forName(…)){ // 同步锁是类定义本身
// f1 代码段
}
}

但是，我们要尽量避免这种直接把synchronized加在函数定义上的偷懒做法。因为我们要控制同步粒度。同步的代码段越小越好。synchronized控制的范围越小越好。
我们不仅要在缩小同步代码段的长度上下功夫，我们同时还要注意细分同步锁。
比如，下面的代码

public static final Object lock1 = new Object();

… f1() {

synchronized(lock1){ // lock1 是公用同步锁
// 代码段 A
// 访问共享资源 resource1
// 需要同步
}
}

… f2() {

synchronized(lock1){ // lock1 是公用同步锁
// 代码段 B
// 访问共享资源 resource1
// 需要同步
}
}

… f3() {

synchronized(lock1){ // lock1 是公用同步锁
// 代码段 C
// 访问共享资源 resource2
// 需要同步
}
}

… f4() {

synchronized(lock1){ // lock1 是公用同步锁
// 代码段 D
// 访问共享资源 resource2
// 需要同步
}
}

上述的4段同步代码，使用同一个同步锁lock1。所有调用4段代码中任何一段代码的线程，都需要竞争同一个同步锁lock1。
我们仔细分析一下，发现这是没有必要的。
因为f1()的代码段A和f2()的代码段B访问的共享资源是resource1，f3()的代码段C和f4()的代码段D访问的共享资源是resource2，它们没有必要都竞争同一个同步锁lock1。我们可以增加一个同步锁lock2。f3()和f4()的代码可以修改为：
public static final Object lock2 = new Object();

… f3() {

synchronized(lock2){ // lock2 是公用同步锁
// 代码段 C
// 访问共享资源 resource2
// 需要同步
}
}

… f4() {

synchronized(lock2){ // lock2 是公用同步锁
// 代码段 D
// 访问共享资源 resource2
// 需要同步
}
}

这样，f1()和f2()就会竞争lock1，而f3()和f4()就会竞争lock2。这样，分开来分别竞争两个锁，就可以大大较少同步锁竞争的概率，从而减少系统的开销。

信号量

同步锁模型只是最简单的同步模型。同一时刻，只有一个线程能够运行同步代码。
有的时候，我们希望处理更加复杂的同步模型，比如生产者/消费者模型、读写同步模型等。这种情况下，同步锁模型就不够用了。我们需要一个新的模型。这就是我们要讲述的信号量模型。
信号量模型的工作方式如下：线程在运行的过程中，可以主动停下来，等待某个信号量的通知；这时候，该线程就进入到该信号量的待召（Waiting）队列当中；等到通知之后，再继续运行。
很多语言里面，同步锁都由专门的对象表示，对象名通常叫Monitor。
同样，在很多语言中，信号量通常也有专门的对象名来表示，比如，Mutex，Semphore。
信号量模型要比同步锁模型复杂许多。一些系统中，信号量甚至可以跨进程进行同步。另外一些信号量甚至还有计数功能，能够控制同时运行的线程数。
我们没有必要考虑那么复杂的模型。所有那些复杂的模型，都是最基本的模型衍生出来的。只要掌握了最基本的信号量模型——“等待/通知”模型，复杂模型也就迎刃而解了。
我们还是以Java语言为例。Java语言里面的同步锁和信号量概念都非常模糊，没有专门的对象名词来表示同步锁和信号量，只有两个同步锁相关的关键字——volatile和synchronized。
这种模糊虽然导致概念不清，但同时也避免了Monitor、Mutex、Semphore等名词带来的种种误解。我们不必执着于名词之争，可以专注于理解实际的运行原理。
在Java语言里面，任何一个Object Reference都可以作为同步锁。同样的道理，任何一个Object Reference也可以作为信号量。
Object对象的wait()方法就是等待通知，Object对象的notify()方法就是发出通知。
具体调用方法为
（1）等待某个信号量的通知
public static final Object signal = new Object();

… f1() {
synchronized(singal) { // 首先我们要获取这个信号量。这个信号量同时也是一个同步锁

// 只有成功获取了signal这个信号量兼同步锁之后，我们才可能进入这段代码
signal.wait(); // 这里要放弃信号量。本线程要进入signal信号量的待召（Waiting）队列

// 可怜。辛辛苦苦争取到手的信号量，就这么被放弃了

// 等到通知之后，从待召（Waiting）队列转到就绪（Ready）队列里面
// 转到了就绪队列中，离CPU核心近了一步，就有机会继续执行下面的代码了。
// 仍然需要把signal同步锁竞争到手，才能够真正继续执行下面的代码。命苦啊。
…
}
}

需要注意的是，上述代码中的signal.wait()的意思。signal.wait()很容易导致误解。signal.wait()的意思并不是说，signal开始wait，而是说，运行这段代码的当前线程开始wait这个signal对象，即进入signal对象的待召（Waiting）队列。

（2）发出某个信号量的通知
… f2() {
synchronized(singal) { // 首先，我们同样要获取这个信号量。同时也是一个同步锁。

// 只有成功获取了signal这个信号量兼同步锁之后，我们才可能进入这段代码
signal.notify(); // 这里，我们通知signal的待召队列中的某个线程。

// 如果某个线程等到了这个通知，那个线程就会转到就绪队列中
// 但是本线程仍然继续拥有signal这个同步锁，本线程仍然继续执行
// 嘿嘿，虽然本线程好心通知其他线程，
// 但是，本线程可没有那么高风亮节，放弃到手的同步锁
// 本线程继续执行下面的代码
…
}
}

需要注意的是，signal.notify()的意思。signal.notify()并不是通知signal这个对象本身。而是通知正在等待signal信号量的其他线程。

以上就是Object的wait()和notify()的基本用法。
实际上，wait()还可以定义等待时间，当线程在某信号量的待召队列中，等到足够长的时间，就会等无可等，无需再等，自己就从待召队列转移到就绪队列中了。
另外，还有一个notifyAll()方法，表示通知待召队列里面的所有线程。
这些细节问题，并不对大局产生影响。

绿色线程

绿色线程（Green Thread）是一个相对于操作系统线程（Native Thread）的概念。
操作系统线程（Native Thread）的意思就是，程序里面的线程会真正映射到操作系统的线程，线程的运行和调度都是由操作系统控制的
绿色线程（Green Thread）的意思是，程序里面的线程不会真正映射到操作系统的线程，而是由语言运行平台自身来调度。
当前版本的Python语言的线程就可以映射到操作系统线程。当前版本的Ruby语言的线程就属于绿色线程，无法映射到操作系统的线程，因此Ruby语言的线程的运行速度比较慢。
难道说，绿色线程要比操作系统线程要慢吗？当然不是这样。事实上，情况可能正好相反。Ruby是一个特殊的例子。线程调度器并不是很成熟。
目前，线程的流行实现模型就是绿色线程。比如，stackless Python，就引入了更加轻量的绿色线程概念。在线程并发编程方面，无论是运行速度还是并发负载上，都优于Python。
另一个更著名的例子就是ErLang（爱立信公司开发的一种开源语言）。
ErLang的绿色线程概念非常彻底。ErLang的线程不叫Thread，而是叫做Process。这很容易和进程混淆起来。这里要注意区分一下。
ErLang Process之间根本就不需要同步。因为ErLang语言的所有变量都是final的，不允许变量的值发生任何变化。因此根本就不需要同步。
final变量的另一个好处就是，对象之间不可能出现交叉引用，不可能构成一种环状的关联，对象之间的关联都是单向的，树状的。因此，内存垃圾回收的算法效率也非常高。这就让ErLang能够达到Soft Real Time（软实时）的效果。这对于一门支持内存垃圾回收的语言来说，可不是一件容易的事情。

都市淘沙者 2008-03-15 20:17 发表评论

常用的多线程异步处理

都市淘沙者 — Fri, 07 Mar 2008 06:13:00 GMT

摘要: package cn.allinpalm.sns.app.web.point.action; import java.util.LinkedList; import org.apache.log4j.Logger; import cn.allinpalm.sns.app.web.constants.Config; import cn... 阅读全文

都市淘沙者 2008-03-07 14:13 发表评论

程序员面试题（转）

都市淘沙者 — Mon, 03 Mar 2008 01:02:00 GMT

答题时间20分钟
1.
System.out.println(1+’\002’)会打印出多少? ___8进制______
System.out.println(1+2+”3”)会打印出多少? _________

2. 请简单补充完下面jdbc读取数据的实现
String SQL = “SELECT id , title, description FROM t_blog WHERE id = ?”;
long id;
String title;
String description;
Connection conn = null;//假设用ConnectionManager.getConnection();可以获得连接对象
PrepareStatement pstmt = null;

如果description字段在数据库中是text类型，而且存储的文字比较多（20K左右），这时候该如何优化读取，让系统支撑更大的并发？

3. 有一篇文章的URL为 view.jsp?id=100 ，每分钟访问量可能上千次，在记录和显示它的查看次数时，你觉得如何做性能比较好？

4. 写出你最常见到的一些运行时异常(runtime exception)，再简述一下你是如何避免java 中空指针异常的

5. 你用lucene做过全文检索吗? 简单描述一下你的经验。

6. 简述一下你对GC的理解，以及如何避免内存泄露。

7. 要求最后打印出的全部是数字，下面的程序满足要求吗？还可以再优化吗？请简单描述。
String strA = “1:2:3:4:5:6:7:8:9:10:”;
String arrA[] = strA.split(“:”);
for(int i=0;i {
System.out.println(arrA[i]);
}

8. 简述一下javascript/dhtml/css/ajax在你以前项目中的应用程度；熟悉跨浏览器兼容javascript/css吗? 有兴趣对它们进行深入研究吗？

9. 你最熟悉Web开发过程中的哪部分？>

都市淘沙者 2008-03-03 09:02 发表评论

JDK1.5中引入了对java语言的多种扩展

都市淘沙者 — Tue, 19 Feb 2008 14:11:00 GMT

摘要: JDK1.5中引入了对java语言的多种扩展，泛型(generics)即其中之一。这个教程的目标是向您介绍java的泛型(generic)。你可能熟悉其他语言的泛型，最著名的是C++的模板(templates)。如果这样，你很快就会看到两者的相似之处和重要差异。如果你不熟悉相似的语法结构，那么更好，你可以从头开始而不需要忘记误解。 Generics允许对类型进行抽象(abstract ove... 阅读全文

都市淘沙者 2008-02-19 22:11 发表评论

泛型是J2SE 5.0最重要的特性

都市淘沙者 — Tue, 19 Feb 2008 14:08:00 GMT

英文原文地址:
http://www.onjava.com/pub/a/onjava/2005/07/06/generics.html
中文地址:
http://www.matrix.org.cn/resource/article/43/43634_java_generics.html
关键词： java generics java5

摘要
       泛型是J2SE 5.0最重要的特性。他们让你写一个type(类或接口）和创建一个实例通过传递一个或多个引用类型。这个实例受限于只能作用于这些类型。比如，在java 5，java.util.List 已经被泛化。当建立一个list对象时，你通过传递一个java类型建立一个List实例，此list实例只能作用于所传递的类型。这意味着如果你传递一个String ,此List实例只能拥有String对象；如果你传递一个Integer，此实例只能存贮Integer对象。除了创建参数化的类型，你还能创建参数化的函数。
     泛型的第一个好处是编译时的严格类型检查。这是集合框架最重要的特点。此外,泛型消除了绝大多数的类型转换。在JDK 5.0之前，当你使用集合框架时，你不得不进行类型转换。
     本文将教你如何操作泛型。它的第一部分是“没有泛型的日子”，先让我们回忆老版本JDK的不便。然后，举一些泛型的例子。在讨论完语法以及有界泛型的使用之后，文章最后一章将解释如何写泛型。


没有泛型的日子
     所有的java类都源自java.lang.Object,这意味着所有的JAVA对象能转换成Object。因此，在之前的JDK的版本中，很多集合框架的函数接受一个Object参数。所以，collections是一个能持有任何对象的多用途工具，但带来了不良的后果。

     举个简单的例子，在JDK 5.0的之前版本中，类List的函数add接受一个Object参数：

public boolean add(java.lang.Object element)

所以你能传递任何类型给add。这是故意这么设计的。否则，它只能传递某种特定的对象，这样就会出现各种List类型，如，StringList, EmployeeList, AddressList等。
add通过Object传递能带来好处,现在我们考虑get函数(返回List中的一个元素).如下是JDK 5之前版本的定义：

public java.lang.Object get(int index) throws IndexOutOfBoundsException

get返回一个Object.不幸的事情从此开始了.假如你储存了两个String对象在一个List中:

List stringList1 = new ArrayList();

stringList1.add("Java 5");

stringList1.add("with generics");

当你想从stringList1取得一个元素时,你得到了一个Object.为了操作原来的类型元素,你不得不把它转换为String。

String s1 = (String) stringList1.get(0);

但是,假如你曾经把一个非String对象加入stringList1中,上面的代码会抛出一个ClassCastException. 有了泛型,你能创建一个单一用途的List实例.比如,你能创建一个只接受String对象的List实例,另外一个实例只能接受Employee对象.这同样适用于集合框架中的其他类型.

泛型入门

像一个函数能接受参数一样,一个泛型也能接受参数.这就是一个泛型经常被称为一个参数化类型的原因.但是不像函数用()传递参数,泛型是用<>传递参数的.声明一个泛型和声明一个普通类没有什么区别,只不过你把泛型的变量放在<>中.
比如,在JDK 5中,你可以这样声明一个java.util.List : List myList;
E 称为类型变量.意味着一个变量将被一个类型替代.替代类型变量的值将被当作参数或返回类型.对于List接口来说,当一个实例被创建以后,E 将被当作一个add或别的函数的参数.E 也会使get或别的参数的返回值.下面是add和get的定义:

boolean add

E get(int index)

NOTE:一个泛型在声明或例示时允许你传递特定的类型变量: E.除此之外,如果E是个类，你可以传递子类；如果E是个接口，你可以传递实现接口的类；

-----------------------------译者添加--------------------
List numberList= new ArrayList();
numberList.add(2.0);
numberList.add(2);
-----------------------------译者添加--------------------

如果你传递一个String给一个List，比如：

List myList;

那么mylist的add函数将接受一个String作为他的参数，而get函数将返回一个String.因为返回了一个特定的类型，所以不用类型转化了。

NOTE：根据惯例，我们使用一个唯一的大写字目表示一个类型变量。为了创建一个泛型，你需在声明时传递同样的参数列表。比如，你要想创建一个ArrayList来操作String ，你必须把String放在<>中。如：

List myList = new ArrayList();

再比如，java.util.Map 是这么定义的：

public interface Map

K用来声明map键(KEY)的类型而V用来表示值(VALUE)的类型。put和values是这么定义的：

V put(K key, V value)

Collection values()

NOTE:一个泛型不准直接的或间接的是java.lang.Throwable的子类。因为异常是在运行时抛出的,所以它不可能预言什么类型的异常将在编译时抛出.

列表1的例子将比较List在JDK 1.4 和JDK1.5的不同

package com.brainysoftware.jdk5.app16;

import java.util.List;

import java.util.ArrayList;



public class GenericListTest {

  public static void main(String[] args) {

    // in JDK 1.4

    List stringList1 = new ArrayList();

    stringList1.add("Java 1.0 - 5.0");

    stringList1.add("without generics");

    // cast to java.lang.String

    String s1 = (String) stringList1.get(0);

    System.out.println(s1.toUpperCase());



    // now with generics in JDK 5

    List stringList2 = new ArrayList();

    stringList2.add("Java 5.0");

    stringList2.add("with generics");

    // no need for type casting

    String s2 = stringList2.get(0);

    System.out.println(s2.toUpperCase());

  }

}

在列表1中，stringList2是个泛型。声明List告诉编译器List的实例能接受一个String对象。当然，在另外的情况中，你能新建能接受各种对象的List实例。注意，当从List实例中返回成员元素时，不需要对象转化，因为他返回的了你想要的类型，也就是String.

NOTE:泛型的类型检查(type checking)是在编译时完成的.

最让人感兴趣的事情是，一个泛型是个类型并且能被当作一个类型变量。比如，你想你的List储存lists of Strings,你能通过把List作为他的类型变量来声明List。比如：

List> myListOfListsOfStrings;

要从myList中的第一个List重新取得String，你可以这么用：

String s = myListOfListsOfStrings.get(0).get(0);

下一个列表中的ListOfListsTest类示范了一个List（命名为listOfLists）接受一个String List作为参数。

package com.brainysoftware.jdk5.app16;

import java.util.ArrayList;

import java.util.List;

public class ListOfListsTest {

  public static void main(String[] args) {

    List listOfStrings = new ArrayList();

    listOfStrings.add("Hello again");

    List> listOfLists = new ArrayList>();

    listOfLists.add(listOfStrings);

    String s = listOfLists.get(0).get(0);

    System.out.println(s); // prints "Hello again"

  }

}

另外，一个泛型接受一个或多个类型变量。比如，java.util.Map有两个类型变量s。第一个定义了键（key）的类型，第二个定义了值（value)的类型。下面的例子讲教我们如何使用个一个泛型Map.

package com.brainysoftware.jdk5.app16;

import java.util.HashMap;

import java.util.Map;

public class MapTest {

  public static void main(String[] args) {

    Map map = new HashMap();

    map.put("key1", "value1");

    map.put("key2", "value2");

    String value1 = map.get("key1");

  }

}

在这个例子中，重新得到一个key1代表的String值，我们不需要任何类型转换。

没有参数的情况下使用泛型

既然在J2SE 5.0中收集类型已经泛型化，那么，原来的使用这些类型的代码将如何呢？很幸运，他们在JAVA 5中将继续工作，因为你能使用没有参数的泛型。比如，你能继续像原来一样使用List接口，正如下面的例子一样。

List stringList1 = new ArrayList();

stringList1.add("Java 1.0 - 5.0");

stringList1.add("without generics");

String s1 = (String) stringList1.get(0);

一个没有任何参数的泛型被称为原型(raw type)。它意味着这些为JDK1.4或更早的版本而写的代码将继续在java 5中工作。

尽管如此，一个需要注意的事情是，JDK５编译器希望你使用带参数的泛型。否则，编译器将提示警告，因为他认为你可能忘了定义类型变量s。比如，编译上面的代码的时候你会看到下面这些警告，因为第一个List被认为是原型。

Note: com/brainysoftware/jdk5/app16/GenericListTest.java
uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

当你使用原型时，如果你不想看到这些警告，你有几个选择来达到目的：
1.编译时带上参数-source 1.4
2.使用@SupressWarnings("unchecked")注释
3.更新你的代码，使用List. List的实例能接受任何类型的对象，就像是一个原型List。然而，编译器不会报错。

使用？通配符
前面提过，如果你声明了一个List, 那么这个List对aType起作用，所以你能储存下面这些类型的对象：
1.一个aType的实例
2.它的子类的实例(如果aType是个类)
3.实现aType接口的类实例(如果aType是个接口)
但是，请注意，一个泛型本身是个JAVA类型，就像java.lang.String或java.io.File一样。传递不同的类型变量给泛型可以创建不同的JAVA类型。比如，下面例子中list1和list2引用了不同的类型对象。

List list1 = new ArrayList();

List list2 = new ArrayList();

list1指向了一个类型变量s为java.lang.Objects 的List而list2指向了一个类型变量s为String 的List。所以传递一个List给一个参数为List的函数将导致compile time错误。下面列表可以说明：

package com.brainysoftware.jdk5.app16;

import java.util.ArrayList;

import java.util.List;



public class AllowedTypeTest {

  public static void doIt(List l) {

  }

  public static void main(String[] args) {

    List myList = new ArrayList();

    // 这里将产生一个错误

    doIt(myList);

  }

}

上面的代码无法编译，因为你试图传递一个错误的类型给函数doIt。doIt的参数是List二你传递的参数是List。
可以使用？通配符解决这个难题。List 意味着一个对任何对象起作用的List。所以，doIt可以改为：

public static void doIt(List l) {}

在某些情况下你会考虑使用 ? 通配符。比如，你有一个printList函数，这个函数打印一个List的所有成员，你想让这个函数对任何类型的List起作用时。否则，你只能累死累活的写很多printList的重载函数。下面的列表引用了使用 ? 通配符的printList函数。

package com.brainysoftware.jdk5.app16;

import java.util.ArrayList;

import java.util.List;



public class WildCardTest {



  public static void printList(List list) {

    for (Object element : list) {

      System.out.println(element);

    }

  }

  public static void main(String[] args) {

    List list1 = new ArrayList();

    list1.add("Hello");

    list1.add("World");

    printList(list1);



    List list2 = new ArrayList();

    list2.add(100);

    list2.add(200);

    printList(list2);

  }

}

这些代码说明了在printList函数中，List表示各种类型的List对象。然而，请注意，在声明的时候使用 ? 通配符是不合法的，像这样：

List myList = new ArrayList(); // 不合法

如果你想创建一个接收任何类型对象的List，你可以使用Object作为类型变量，就像这样：

List myList = new ArrayList();

在函数中使用界限通配符
在之前的章节中，你学会了通过传递不同的类型变量s来创建不同JAVA类型的泛型，但并不考虑类型变量s之间的继承关系。在很多情况下，你想一个函数有不同的List参数。比如，你有一个函数getAverage，他返回了一个List中成员的平均值。然而，如果你把List作为getAverage的参数，你就没法传递List 或List参数，因为List和List 和List不是同样的类型。

你能使用原型或使用通配符，但这样无法在编译时进行安全类型检查，因为你能传递任何类型的List，比如List的实例。你可以使用List作为参数，但是你就只能传递List给函数。但这样就使你的函数功能减少，因为你可能更多的时候要操作List或List，而不是List。

J2SE5.0增加了一个规则来解决了这种约束，这个规则就是允许你定义一个上界(upper bound) 类型变量.在这种方式中，你能传递一个类型或它的子类。在上面getAverage函数的例子中，你能传递一个List或它的子类的实例，比如List or List。

使用上界规则的语法这么定义的：GenericType. 比如，对getAverage函数的参数，你可以这么写List. 下面例子说明了如何使用这种规则。

package com.brainysoftware.jdk5.app16;

import java.util.ArrayList;

import java.util.List;

public class BoundedWildcardTest {

  public static double getAverage(List numberList)

  {

    double total = 0.0;

    for (Number number : numberList)

      total += number.doubleValue();

    return total/numberList.size();

  }



  public static void main(String[] args) {

    List integerList = new ArrayList();

    integerList.add(3);

    integerList.add(30);

    integerList.add(300);

    System.out.println(getAverage(integerList)); // 111.0

    List doubleList = new ArrayList();

    doubleList.add(3.0);

    doubleList.add(33.0);

    System.out.println(getAverage(doubleList)); // 18.0

  }

}

由于有了上界规则，上面例子中的getAverage函数允许你传递一个List 或一个类型变量是任何java.lang.Number子类的List。

下界规则
关键字extends定义了一个类型变量的上界。通过使用super关键字，我们可以定义一个类型变量的下界，尽管使用的情况不多。比如，如果一个函数的参数是List，那么意味着你可以传递一个List的实例或者任何java.lang.Integer的超类(superclass)。

创建泛型

前面的章节主要说明了如何使使用泛型，特别是集合框架中的类。现在我们开始学习如何写自己的泛型。

基本上，除了声明一些你想要使用的类型变量s外，一个泛型和别的类没有什么区别。这些类型变量s位于类型后面的<>中。比如，下面的Point就是个泛型。一个Point对象代表了一个系统中的点，它有横坐标和纵坐标。通过使Point泛型化，你能定义一个点实例的精确程度。比如，如果一个Point对象需要非常精确，你就把Double作为类型变量。否则，Integer 就够了。

package com.brainysoftware.jdk5.app16;

public class Point {

  T x;

  T y;

  public Point(T x, T y) {

    this.x = x;

    this.y = y;

  }

  public T getX() {

    return x;

  }

  public T getY() {

    return y;

  }

  public void setX(T x) {

    this.x = x;

  }

  public void setY(T y) {

    this.y = y;

  }

}

在这个例子中，T是Point的类型变量。T是getX和getY的返回值类型，也是setX和setY的参数类型。此外，构造函数结合两个T参数。
使用point类就像使用别的类一样。比如，下面的例子创建了两个Point对象：ponint1和point2。前者把Integer作为类型变量，而后者把Double作为类型变量。

Point point1 = new Point(4, 2);

point1.setX(7);

Point point2 = new Point(1.3, 2.6);

point2.setX(109.91);

总结
泛型使代码在编译时有了更严格的类型检查。特别是在集合框架中，泛型有两个作用。第一，他们增加了对集合类型在编译时的类型检查，所以集合类所能持有的类型对传递给它的参数类型起了限制作用。比如你创建了一个持有strings的java.util.List实例，那么他就将不能接受Integers或别的类型。其次，当你从一个集合中取得一个元素时，泛型消除了类型转换的必要。
泛型能够在没有类型变量的情况下使用，比如，作为原型。这些措施让Java 5之前的代码能够运行在JRE 5中。但是，对新的应用程序，你最好不要使用原型，因为以后Java可能不支持他们。

你已经知道通过传递不同类型的类型变量给泛型可以产生不同的JAVA类型。就是说List和List的类型是不同的。尽管String是java.lang.Object。但是传递一个List给一个参数是List的函数会参数会产生编译错误（compile error）。函数能用 ? 通配符使其接受任何类型的参数。List 意味着任何类型的对象。
最后，你已经看到了写一个泛型和别的一般JAVA类没有什么区别。你只需要在类型名称后面的<>中声明一系列的类型变量s就行了。这些类型变量s就是返回值类型或者参数类型。根据惯例，一个类型变量用一个大写字母表示。

都市淘沙者 2008-02-19 22:08 发表评论

递归实现类似腾讯的积分等级处理 (原创)

都市淘沙者 — Tue, 15 Jan 2008 15:40:00 GMT

由于最近做积分系统刚好需要一个类似腾讯qq等级的方式:比如一个太阳等级A表示1000分,一个月亮B表示800分,另外一个星星C表示100分;则若用户的积分为2950则是AABC表示即可,若用户积分为1950则用ABC即可,若用户积分为2150则用AAC即可,若用户积分为1150则用AC即可,以此类推,可以用递归来解决这类问题,代码如下

import java.util.ArrayList;
import java.util.List;

public class BeanShellDemo {

    static StringBuffer sb = new StringBuffer();

    /**
     * point表示用户的总积分,levellist表示积分等级列表;

     * 在本例子中需要说明的是积分等级列表是要按顺序的
     * @param point
     * @param leverlist
     * @return
     */
    public static String getMyLand(int point, List levellist) {

        int starnum = 0;
        int leftpoint = 0;
        int maxlevel = Integer.parseInt(levellist.get(levellist.size() - 1)
                .toString());//列表中的最大等级
        int minlevel = Integer.parseInt(levellist.get(0).toString());//列表中的最小等级

        if(levellist.size() > 0 && point< minlevel){
            return "积分不够最小等级,则默认为最低的等级"+minlevel;
        }else
        if (levellist.size() > 0 && point >= minlevel) {    //当用户积分小于最小等级值则不做处理

            if (point < maxlevel && levellist.size() > 0) { // 小于最大等级则
                levellist.remove(levellist.size() - 1);     // 将当前list中的最大等级移除
                leftpoint = point;                          //(注意因为例子中的list是由小到大排序的,乱顺则要另外处理)
            } else {
                starnum = point / maxlevel;                 //取商比如280/6 = 46
                leftpoint = point % maxlevel;               //取模比如280%6 = 4
                sb.append("有" + starnum + "个等级为" + maxlevel + "的头衔" + "#");
            }
            getMyLand(leftpoint, levellist);
        }

        return sb.toString();
    }

    public static void main(String[] args) {

        int leverarray[] = { 50, 100, 300, 500, 1000 };
        List<Integer> levellist = new ArrayList<Integer>();
        for (int i = 0; i < leverarray.length; i++) {
            levellist.add(leverarray[i]);
        }
        int userpoint = 20;
        int userpoint2 = 2190;
        System.out.println(getMyLand(userpoint, levellist));
        System.out.println(getMyLand(userpoint2, levellist));

    }
}

执行结果如:

积分不够最小等级,则默认为最低的等级50
有2个等级为1000的头衔#有1个等级为100的头衔#有1个等级为50的头衔#

通过其他方法对返回的串做处理即可,有好方法的朋友欢迎沟通!!

都市淘沙者 2008-01-15 23:40 发表评论

java中的io系统总结（转）

都市淘沙者 — Wed, 26 Dec 2007 07:28:00 GMT

java中的io中的（input/output）stream无非就是包括基于字符的stream、基于字节的stream和把字节导向的stream转换
字符为导向的stream的stream。（很难理解么？）
以字节为导向的stream------InputStream/OutputStream
InputStream 和 OutputStream是两个abstact类，对于字节为导向的stream都扩展这两个鸡肋（基类^_^）;
--InputStream
ByteArrayInputStream -- 把内存中的一个缓冲区作为InputStream使用.

construct---ByteArrayInputStream(byte[])创建一个新字节数组输入流，它从指定字节数组中读取数据。
---ByteArrayInputStream(byte[], int, int) 创建一个新字节数组输入流，它从指定字节数组中读取数据。
---mark::该字节数组未被复制。

StringBufferInputStream -- 把一个String对象作为InputStream .
注释：不推荐使用 StringBufferInputStream 方法。此类不能将字符正确的转换为字节。
同 JDK 1.1 版中的类似，从一个串创建一个流的最佳方法是采用 StringReader 类。

construct---StringBufferInputStream(String) 据指定串创建一个读取数据的输入流串。

FileInputStream -- 把一个文件作为InputStream，实现对文件的读取操作

construct---FileInputStream(File) 创建一个输入文件流，从指定的 File 对象读取数据。
---FileInputStream(FileDescriptor) 创建一个输入文件流，从指定的文件描述器读取数据。
---FileInputStream(String) 创建一个输入文件流，从指定名称的文件读取数据。

method ---- read() 从当前输入流中读取一字节数据。
read(byte[]) 将当前输入流中 b.length 个字节数据读到一个字节数组中。
read(byte[], int, int) 将输入流中 len 个字节数据读入一个字节数组中。

PipedInputStream：实现了pipe的概念，主要在线程中使用. 管道输入流是指一个通讯管道的接收端。
一个线程通过管道输出流发送数据，而另一个线程通过管道输入流读取数据，
这样可实现两个线程间的通讯。

PipedInputStream() 创建一个管道输入流，它还未与一个管道输出流连接。
PipedInputStream(PipedOutputStream) 创建一个管道输入流, 它已连接到一个管道输出流。

SequenceInputStream：把多个InputStream合并为一个InputStream .“序列输入流”类允许应用程序把几个输入流连续地合并起来，
并且使它们像单个输入流一样出现。每个输入流依次被读取，直到到达该流的末尾。
然后“序列输入流”类关闭这个流并自动地切换到下一个输入流。
SequenceInputStream(Enumeration) 创建一个新的序列输入流，并用指定的输入流的枚举值初始化它。
SequenceInputStream(InputStream, InputStream) 创建一个新的序列输入流，初始化为首先读输入流 s1, 然后读输入流 s2。

--OutputSteam

ByteArrayOutputStream：把信息存入内存中的一个缓冲区中.该类实现一个以字节数组形式写入数据的输出流。
当数据写入缓冲区时，它自动扩大。用 toByteArray() 和 toString() 能检索数据。

construct --- ByteArrayOutputStream() 创建一个新的字节数组输出流。
--- ByteArrayOutputStream() 创建一个新的字节数组输出流。
--- ByteArrayOutputStream(int) 创建一个新的字节数组输出流，并带有指定大小字节的缓冲区容量。
toString(String) 根据指定字符编码将缓冲区内容转换为字符串，并将字节转换为字符。
write(byte[], int, int) 将指定字节数组中从偏移量 off 开始的 len 个字节写入该字节数组输出流。
write(int) 将指定字节写入该字节数组输出流。
writeTo(OutputStream) 用 out.write(buf, 0, count) 调用输出流的写方法将该字节数组输出流的全部内容写入指定的输出流参数。

FileOutputStream:文件输出流是向 File 或 FileDescriptor 输出数据的一个输出流。

FileOutputStream(File) 创建一个文件输出流，向指定的 File 对象输出数据。
FileOutputStream(FileDescriptor) 创建一个文件输出流，向指定的文件描述器输出数据。
FileOutputStream(String) 创建一个文件输出流，向指定名称的文件输出数据。
FileOutputStream(String, boolean) 用指定系统的文件名，创建一个输出文件。

PipedOutputStream:管道输出流是指一个通讯管道的发送端。一个线程通过管道输出流发送数据，
而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。

PipedOutputStream() 创建一个管道输出流，它还未与一个管道输入流连接。
PipedOutputStream(PipedInputStream) 创建一个管道输出流，它已连接到一个管道输入流。

以字符为导向的stream Reader/Writer

以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream 中写入信息。
Reader/Writer 为abstact类
以Unicode字符为导向的stream包括下面几种类型：

－－ Reader

1) CharArrayReader：与ByteArrayInputStream对应
CharArrayReader(char[]) 用指定字符数组创建一个 CharArrayReader。
CharArrayReader(char[], int, int) 用指定字符数组创建一个 CharArrayReader。

2) StringReader：与StringBufferInputStream对应
StringReader(String) 创建一新的串读取者。
3) FileReader：与FileInputStream对应

4) PipedReader：与PipedInputStream对应

－－ Writer

1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应

两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。
一个 InputStreamReader 类是从字节流到字符流的桥梁：它读入字节，并根据指定的编码方式，将之转换为字符流。
使用的编码方式可能由名称指定，或平台可接受的缺省编码方式。

InputStreamReader 的 read() 方法之一的每次调用，可能促使从基本字节输入流中读取一个或多个字节。
为了达到更高效率，考虑用 BufferedReader 封装 InputStreamReader，
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

InputStreamReader(InputStream) 用缺省的字符编码方式，创建一个 InputStreamReader。
InputStreamReader(InputStream, String) 用已命名的字符编码方式，创建一个 InputStreamReader。

OutputStreamWriter 将多个字符写入到一个输出流，根据指定的字符编码将多个字符转换为字节。
每个 OutputStreamWriter 合并它自己的 CharToByteConverter, 因而是从字符流到字节流的桥梁。

FilterInputStream、RandomAccessFile 见例子。
ObjectInputStream 、 ObjectOutputStream见另外blog。

Java IO的一般使用原则：

一、按数据来源（去向）分类：
1、是文件： FileInputStream, FileOutputStream, FileReader, FileWriter
2、是byte[]：ByteArrayInputStream, ByteArrayOutputStream
3、是Char[]: CharArrayReader, CharArrayWriter
4、是String: StringBufferInputStream, StringReader, StringWriter
5、网络数据流：InputStream, OutputStream, Reader, Writer

二、按是否格式化输出分：
1、要格式化输出：PrintStream, PrintWriter

三、按是否要缓冲分：
1、要缓冲：BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter

四、按数据格式分：
1、二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream及其所有带Stream结束的子类
2、纯文本格式（含纯英文与汉字或其他编码方式）；Reader, Writer及其所有带Reader, Writer的子类

五、按输入输出分：
1、输入：Reader, InputStream类型的子类
2、输出：Writer, OutputStream类型的子类

六、特殊需要：
1、从Stream到Reader,Writer的转换类：InputStreamReader, OutputStreamWriter
2、对象输入输出：ObjectInputStream, ObjectOutputStream
3、进程间通信：PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
4、合并输入：SequenceInputStream
5、更特殊的需要：PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：
首先，考虑最原始的数据格式是什么：原则四
第二，是输入还是输出：原则五
第三，是否需要转换流：原则六第1点
第四，数据来源（去向）是什么：原则一
第五，是否要缓冲：原则三（特别注明：一定要注意的是readLine()是否有定义，有什么比read, write更特殊的输入或输出方法）
第六，是否要格式化输出：原则二

文章2：
首先是java的IO。这破东西可真费事，I/O类库常使用”流(stream)”这种抽象。所谓”流”是一种能生成或接受数据的，代表数据的源和目标的对象。流把I/O设备内部的具体操作给隐藏起来了。正如JDK文档所显示的，Java的I/O类库分成输入和输出两大部分。所有InputStream和Reader的派生类都有一个基本的，继承下来的，能读取单个或byte数组的read( )方法。同理，所有OutputStream和Writer的派生类都有一个基本的，能写入单个或byte数组的write( )方法。但通常情况下，你是不会去用这些方法的；它们是给其它类用的 —— 而后者会提供一些更实用的接口。因此，你很少会碰到只用一个类就能创建一个流的情形，实际上你得把多个对象叠起来，并以此来获取所需的功能。Java的流类库之所以会那么让人犯晕，最主要的原因就是”你必须为创建一个流而动用多个对象”。
Java的IO类结构：
      根接口是InputStream/OutputStream，充当数据源的IO类有FileInputStream/FileOutputStream，ByteArrayInputStream / ByteArrayOutputStream 等，充当装饰功能的IO类有BufferedInputStream /   BufferedOutputStream，DataInputStream   /   DataOutputStream等，
   它们都是继承装饰接口FilterInputStream/FilterOutputStream。
      使用IO时，首先创建一个数据源IO，然后根据需要的功能创建装饰类IO，其构造函数的参数为已创建的数据源IO。
      我们以创建一个具有缓冲的文件输入流为例，假定需要从磁盘读取文件“C:\log.txt”：
      // 创建一个FileInputStream:
      FileInputStream fileInput = new FileInputStream(”C:\\log.txt”);
      // 创建一个BufferedInputStream:
      BufferedInputStream bufferedInput = new BufferedInputStream(fileInput);
     // 现在得到的bufferedInput即是具有缓冲的文件输入流
　　或者进一步简写如下：
     InputStream input = new BufferedInputStream(new FileInputStream(”C:\\log.txt”));
     // 现在得到的input即是具有缓冲的文件输入流
java.io.Reader 和 java.io.InputStream 区别
　　java.io.Reader 和 java.io.InputStream 组成了 Java 输入类。Reader 用于读入16位字符，也就是 Unicode 编码的字符；而 InputStream 用于读入 ASCII 字符和二进制数据。
在 Java 中，有不同类型的 Reader 输入流对应于不同的数据源：
    FileReader 用于从文件输入；
    CharArrayReader 用于从程序中的字符数组输入；
    StringReader 用于从程序中的字符串输入；
    PipedReader 用于读取从另一个线程中的 PipedWriter 写入管道的数据。
相应的也有不同类型的 InputStream 输入流对应于不同的数据源：FileInputStream，ByteArrayInputStream，StringBufferInputStream，PipedInputStream。另外，还有两种没有对应 Reader 类型的 InputStream 输入流：
    Socket 用于套接字；
    URLConnection 用于 URL 连接。
这两个类使用 getInputStream() 来读取数据。
相应的，java.io.Writer 和 java.io.OutputStream 也有类似的区别。
1、Java技术支持两种数据类型的流
InputStream和OutputStream：字节流。其它字节流都是InputStream或OutputStream的子类。
Reader和 Writer：字符流。其它字符流都是Reader或Writer的子类。
2、节点流
Java 2 SDK中有三种基本类型的节点：文件(file)、内存(memory)、管道(pipe)。
3、过程流
过程流在其它流之上，完成排序、变换等操作。过程流也被称做过滤流。
当你需要改变输入流的原始数据时，你可以将一个过滤输入流连接到一个原始的输入流上。
用过滤流将原始数据变换成你需要的格式。
4、基本字节流类
4.1、FileInputStream和FileOutputStream
这两个节点流用来操纵磁盘文件。这些类的构造函数允许你指定它们所连接的文件。
要构造一个FileInputStream，所关联的文件必须存在而且是可读的。
如果你要构造一个FileOutputStream而输出文件已经存在，则它将被覆盖。
FileInputStream infile = new FileInputStream(”myfile.dat”);
FileOutputStream outfile = new FileOutputStream(”results.dat”);
4.1、 BufferInputStream和BufferOutputStream
这些是过滤器流，它们可以提高I/O操作的效率。
4.3、 PipedInputStream和PipedOutputStream
管道流用来在线程间进行通信。一个线程的PipedInputStream对象从另一个线程的PipedOutputStream对象读取输入。
要使管道流有用，必须有一个输入方和一个输出方。
4.4、 DataInputStream和DataOutputStream
这些过滤器通过流来读写Java基本类
5、基本字符流类
图阐述了Reader和Writer字符流的体系结构。
5.1、InputStreamReader 和 OutputStreamWriter
用于字节流与字符流之间的转换接口。
当你构造一个InputStreamReader或OutputStreamWriter时，转换规则定义了16位Unicode和其它平台的特定表示之间的转换。
InputStreamReader从一个数据源读取字节，并自动将其转换成Unicode字符。
如果你特别声明，InputStreamReade会将字节流转换成其它种类的字符流。
OutputStreamWriter将字符的Unicode编码写到输出流，如果你的使用的不是Unicode字符，OutputStreamWriter会将你的字符编码转换成Unicode编码。
5.2.、缓冲读者和作者
因为在各种格式之间进行转换和其它I/O操作很类似，所以在处理大块数据时效率最高。
在InputStreamReader和OutputStreamWriter的结尾链接一个BufferedReader和BufferedWriter是一个好主意。
记住对BufferedWriter使用flush()方法。
5.3、使用其它字符转换
如果你需要从一个非本地(例如，从连接到一个不同类型的机器的网络连接读取)的字符编码读取输入，
你可以象下面这个程序那样，使用显式的字符编码构造ir=new InputStreamReader(System.in, “8859_1″);
注：如果你通过网络连接读取字符，就应该使用这种形式。
否则，你的程序会总是试图将所读取的字符当作本地表示来进行转换，而这并不总是正确的。ISO 8859-1是映射到ASCII的Latin-1编码模式。
6、对象串行化
java.io.Serializable接口支持将一个Java技术对象存放到一个流中。
将一个对象存放到某种类型的永久存储器上称为”保持”。
如果一个对象可以被存放到磁盘或磁带上，或者可以发送到另外一台机器并存放到存储器或磁盘上，那么这个对象就被称为可保持的。
java.io.Serializable接口没有任何方法，它只作为一个”标记”，用来表明实现了这个接口的类可以串行化。
类中没有实现Serializable接口的对象不能被保持。
// 文件实现追加：
// 其中的FileWriter()中的第二个参数的含义是:是否在文件中追加内容
PrintWriter out = new PrintWriter(new FileWriter(logFileName, true), true);
Java读写文件最常用的类是FileInputStream/FileOutputStream和FileReader/FileWriter。
其中FileInputStream和FileOutputStream是基于字节流的，常用于读写二进制文件。
读写字符文件建议使用基于字符的FileReader和FileWriter，省去了字节与字符之间的转换。
但这两个类的构造函数默认使用系统的编码方式，如果文件内容与系统编码方式不一致，可能会出现乱码。
在这种情况下，建议使用FileReader和FileWriter的父类：InputStreamReader/OutputStreamWriter，
它们也是基于字符的，但在构造函数中可以指定编码类型：InputStreamReader(InputStream in, Charset cs) 和OutputStreamWriter(OutputStream out, Charset cs)。

// 读写文件的编码：
InputStreamReader r = new InputStreamReader(new FileInputStream(fileName), “utf-8″);
OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(fileName),”utf-8″);

/**
三种IO性能比较:
在读写一个10k文件的时候，三种方式的耗时如下:
InputStreamReader And OutputStreamWriter : 63ms (可以设置文件的编码，如果不用buffer)
BufferedReader And BufferedWriter : 31ms
BufferedInputStream And BufferedOutputStream : 16ms
*/

/**
* Description: Test the java IO’s efficiency
* Author: KevinChen
* Date: 2007-02-18
*/
import java.io.*;

/**
* using the InputStreamReader And OutputStreamWriter
*/
class EncoderRW {
public static String read(String fileName) throws IOException {
  StringBuffer sb = new StringBuffer();
/*此处读文件时用了buffer，如果不用，性能损失一倍*/
  BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(fileName), “utf-8″));
  String s;
  while((s = in.readLine()) != null) {
    sb.append(s);
    sb.append(”\n”);
  }
  in.close();
  return sb.toString();
}
public void write(String fileName, String text) throws IOException {
  OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(fileName),”utf-8″);
  out.write(text);
  out.flush();
  out.close();
}
}

/**
* using the BufferedReader And BufferedWriter
*/
class WriterReader {
public String read(String fileName) throws IOException {
  StringBuffer sb = new StringBuffer();
  BufferedReader in = new BufferedReader(new FileReader(fileName));
  String s;
  while((s = in.readLine()) != null) {
    sb.append(s);
    sb.append(”\n”);
  }
  in.close();
  return sb.toString();
}
public void write(String fileName, String text) throws IOException {
  PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
  out.print(text);
  out.close();
}
}

/**
* using the BufferedInputStream And BufferedOutputStream
*/
class BufferedStream{
public byte[] read(String fileName) throws IOException {
  BufferedInputStream remoteBIS = new BufferedInputStream(new FileInputStream(fileName));
  ByteArrayOutputStream baos = new ByteArrayOutputStream(10240);
  byte[] buf = new byte[1024];
  int bytesRead = 0;
  while(bytesRead >= 0)
  {
   baos.write(buf, 0, bytesRead);
   bytesRead = remoteBIS.read(buf);
  }
  byte[] content = baos.toByteArray();
  return content;
}
public void write(String fileName, byte[] content) throws IOException {
  BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(fileName));
  out.write(content);
  out.flush();
  out.close();
}
}

public class TestIO
{
public static void main(String[] args)throws IOException {
  long currentTime = System.currentTimeMillis() ;
  EncoderRW rw = new EncoderRW();
  rw.write(”index.dat”,rw.read(”FileUtil.java”));
  System.out.println(”cost time:” + Long.toString(System.currentTimeMillis()-currentTime) + ” ms”);

  currentTime = System.currentTimeMillis() ;
  WriterReader wr = new WriterReader();
  wr.write(”index.dat”,wr.read(”FileUtil.java”));
  System.out.println(”cost time:” + Long.toString(System.currentTimeMillis()-currentTime) + ” ms”);

  currentTime = System.currentTimeMillis() ;
  BufferedStream bf = new BufferedStream();
  bf.write(”index.dat”,bf.read(”FileUtil.java”));
  System.out.println(”cost time:” + Long.toString(System.currentTimeMillis()-currentTime) + ” ms”);
}
}

都市淘沙者 2007-12-26 15:28 发表评论

心跳包检测不可检测断线 (转)

都市淘沙者 — Fri, 07 Dec 2007 09:43:00 GMT

摘要: 一般是用来判断对方（设备，进程或其它网元）是否正常动行，一般采用定时发送简单的通讯包，如果在指定时间段内未收到对方响应，则判断对方已经当掉。用于检测TCP的异常断开。基本原因是服务器端不能有效的判断客户端是否在线也就是说，服务器无法区分客户端是长时间在空闲，还是已经掉线的情况.所谓的心跳包就是客户端定时发送简单的信息给服务器端告诉它我还在而已。代码就是每隔几分钟发送一个固定信息给服务端... 阅读全文

都市淘沙者 2007-12-07 17:43 发表评论

四个有用的过滤器 Filter

都市淘沙者 — Mon, 03 Dec 2007 09:13:00 GMT

摘要: 一、使浏览器不缓存页面的过滤器 import javax.servlet.*; import javax.servlet.http.HttpServletResponse; import java.io.IOException; /** *//** * 用于的使 Browser&nbs... 阅读全文

都市淘沙者 2007-12-03 17:13 发表评论

JSP中与路径相关的常用的几个方法

都市淘沙者 — Sat, 01 Dec 2007 04:58:00 GMT

摘要: http:/localhost/123/jsp/test.jsp: <%@ page language="java" pageEncoding="UTF-8"%> <%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %> <%@ taglib uri="http://... 阅读全文

都市淘沙者 2007-12-01 12:58 发表评论

正则表达式的作用

都市淘沙者 — Fri, 23 Nov 2007 04:47:00 GMT

正则表达式的作用

提供更强大的字符串处理能力，测试字符串内的模式，例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或身份证号码模式。即数据验证替换文本可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它。

基于模式匹配从字符串中提取子字符串可以查找文档内或输入域内特定的文本。

在Java中使用正则表达式

正则表达式在字符串处理上有着强大的功能，sun在jdk1.4加入了对它的支持，jdk1.4中加入了java.util.regex包提供对正则表达式的支持。而且Java.lang.String类中的replaceAll和split函数也是调用的正则表达式来实现的。

正则表达式对字符串的操作主要包括：

1.字符串匹配

2.指定字符串替换

3.指定字符串查找

4.字符串分割

Pattern类

Pattern类的实例表示以字符串形式指定的正则表达式，其语法类似于Perl所用的语法。

用字符串形式指定的正则表达式，必须先编译成Pattern类的实例。生成的模式用于创建Matcher对象，它根据正则表达式与任意字符序列进行匹配。多个匹配器可以共享一个模式，因为它是非专属的。

用compile方法把给定的正则表达式编译成模式，然后用 matcher方法创建一个匹配器，这个匹配器将根据此模式对给定输入进行匹配。pattern 方法可返回编译这个模式所用的正则表达式。

Matcher类

通过调用某个模式的matcher方法，从这个模式生成匹配器。匹配器创建之后，就可以用它来执行三类不同的匹配操作：

matches方法根据此模式，对整个输入序列进行匹配。

lookingAt方法根据此模式，从开始处对输入序列进行匹配。

find方法扫描输入序列，寻找下一个与模式匹配的地方。

这些方法都会返回一个表示成功或失败的布尔值。如果匹配成功，通过查询匹配器的状态，可以获得更多的信息。

构建正则表达式

\d 等於 [0-9] 数字

\D 等於 [^0-9] 非数字

\s 等於 [ \t\n\x0B\f\r] 空白字符

\S 等於 [^ \t\n\x0B\f\r] 非空白字符

\w 等於 [a-zA-Z_0-9] 数字或是英文字

\W 等於 [^a-zA-Z_0-9] 非数字与英文字

$ 表示每行的结尾 . 匹配所有字符，包括空格、Tab字符甚至换行符或 []方括号只允许匹配单个字符 ^ 符号称为否符号。如果用在方括号内，表示不想要匹配的字符。表示每行的开头 ( ) 形成一组查询

import java.util.regex.*;
            public class RegexExample
            {
            public static void main(String[] args)
            {
            String str="aaabc efg ABC";
            String regEx="aaafff";
            Pattern p=Pattern.compile(regEx);//编译成模式
            Matcher m=p.matcher(str);//创建一个匹配器
            boolean rs=m.find();
            if(rs)
            {
            System.out.println("include!!!");
            }
            else
            {
            System.out.println("no include!!!");
            }
            }
            }

如果str中有regEx，那么rs为true，否则为flase。如果想在查找时忽略大小写，则可以写成Pattern p=Pattern.compile(regEx,Pattern.CASE_INSENSITIVE); 提取 (从本例所给完整路径中提取文件名)

import java.util.regex.*;
            public class RegexExample2
            {
            public static void main(String[] args)
            {
            String regEx=".+\\\\(.+)$";
            String str="c:\\dir1\\dir2\\name.txt";
            Pattern p=Pattern.compile(regEx);
            Matcher m=p.matcher(str);
            boolean rs=m.find();
            for(int i=1;i<=m.groupCount();i++)
            {
            System.out.println(m.group(i)); //括号内匹配内容
            }
            }
            }

以上的执行结果为name.txt，提取的字符串储存在m.group(i)中，其中i最大值为m.groupCount(); 分割

import java.util.regex.*;
            public class RegexExample3
            {
            public static void main(String[] args)
            {
            String regEx="::";
            Pattern p=Pattern.compile(regEx);
            String[] r=p.split("xd::abc::cde");
            for(int i=0;i

执行后，r就是{xd,abc,cde}，其实分割时还有跟简单的方法：

String str="xd::abc::cde";

String[] r=str.split("::");

替换（删除）

import java.util.regex.*;
            public class RegexExample1
            {
            public static void main(String[] args)
            {
            String regEx="a+";//表示一个或多个a
            Pattern p=Pattern.compile(regEx);
            Matcher m=p.matcher("aaabbced a ccdeaa");
            String s=m.replaceAll("A");
            System.out.println(s);
            }
            }

结果为"Abbced A ccdeA"

如果写成空串，既可达到删除的功能，比如：

String s=m.replaceAll("");

结果为"bbced ccde"

都市淘沙者 2007-11-23 12:47 发表评论

HttpClient 学习整理 (转)

都市淘沙者 — Thu, 22 Nov 2007 04:37:00 GMT

摘要: source：http://www.blogjava.net/Alpha/archive/2007/01/22/95216.html HttpClient 是我最近想研究的东西，以前想过的一些应用没能有很好的实现，发现这个开源项目之后就有点眉目了，令人头痛的cookie问题还是有办法解决滴。在网上整理了一些东西，写得很好，寄放在这里。 HTTP 协议可能是现在 Internet 上使用... 阅读全文

都市淘沙者 2007-11-22 12:37 发表评论

使用Java生成GUID的类（转）

都市淘沙者 — Sat, 17 Nov 2007 15:31:00 GMT

使用Java生成GUID的类

GUID是一个128位长的数字，一般用16进制表示。算法的核心思想是结合机器的网卡、当地时间、一个随即数来生成GUID。从理论上讲，如果一台机器每秒产生10000000个GUID，则可以保证（概率意义上）3240年不重复。

import java.net.*;
import java.util.*;
import java.security.*;public class GuidCreator extends Object {

private String seedingString = “”;
private String rawGUID = “”;
private boolean bSecure = false;
private static Random myRand;
private static SecureRandom mySecureRand;

private static String s_id;

public static final int BeforeMD5 = 1;
public static final int AfterMD5 = 2;
public static final int FormatString = 3;

static {
mySecureRand = new SecureRandom();
long secureInitializer = mySecureRand.nextLong();
myRand = new Random(secureInitializer);
try {
s_id = InetAddress.getLocalHost().toString();
} catch (UnknownHostException e) {
e.printStackTrace();
}
}

/*
* Default constructor. With no specification of security option,
* this constructor defaults to lower security, high performance.
*/
public GuidCreator() { }

/*
* Constructor with security option. Setting secure true
* enables each random number generated to be cryptographically
* strong. Secure false defaults to the standard Random function seeded
* with a single cryptographically strong random number.
*/
public GuidCreator(boolean secure) {
bSecure = secure;
}

/*
* Method to generate the random GUID
*/
private void getRandomGUID(boolean secure) {
MessageDigest md5 = null;
StringBuffer sbValueBeforeMD5 = new StringBuffer();

try {
md5 = MessageDigest.getInstance(”MD5″);
} catch (NoSuchAlgorithmException e) {
System.out.println(”Error: ” + e);
}

try {
long time = System.currentTimeMillis();
long rand = 0;

if (secure) {
rand = mySecureRand.nextLong();
} else {
rand = myRand.nextLong();
}

// This StringBuffer can be a long as you need; the MD5
// hash will always return 128 bits. You can change
// the seed to include anything you want here.
// You could even stream a file through the MD5 making
// the odds of guessing it at least as great as that
// of guessing the contents of the file!
sbValueBeforeMD5.append(s_id);
sbValueBeforeMD5.append(”:”);
sbValueBeforeMD5.append(Long.toString(time));
sbValueBeforeMD5.append(”:”);
sbValueBeforeMD5.append(Long.toString(rand));

seedingString = sbValueBeforeMD5.toString();
md5.update(seedingString.getBytes());

byte[] array = md5.digest();
StringBuffer sb = new StringBuffer();
for (int j = 0; j < array.length; ++j) {
int b = array[j] & 0xFF;
if (b < 0×10) sb.append(’0′);
sb.append(Integer.toHexString(b));
}

rawGUID = sb.toString();

} catch (Exception e) {
System.out.println(”Error:” + e);
}
}

public String createNewGuid(int nFormatType, boolean secure) {
getRandomGUID(secure);
String sGuid = “”;
if (BeforeMD5 == nFormatType) {
sGuid = this.seedingString;
} else if (AfterMD5 == nFormatType) {
sGuid = this.rawGUID;
} else {
sGuid = this.toString();
}
return sGuid;
}

public String createNewGuid(int nFormatType) {
return this.createNewGuid(nFormatType, this.bSecure);
}

/*
* Convert to the standard format for GUID
* (Useful for SQL Server UniqueIdentifiers, etc.)
* Example: C2FEEEAC-CFCD-11D1-8B05-00600806D9B6
*/
public String toString() {
String raw = rawGUID.toUpperCase();
StringBuffer sb = new StringBuffer();
sb.append(raw.substring(0, 8));
sb.append(”-”);
sb.append(raw.substring(8, 12));
sb.append(”-”);
sb.append(raw.substring(12, 16));
sb.append(”-”);
sb.append(raw.substring(16, 20));
sb.append(”-”);
sb.append(raw.substring(20));

return sb.toString();
}
}

/**
* Use Exceple
* public static void main(String args[]) {
* for (int i=0; i< 100; i++) {
* GuidCreator myGUID = new GuidCreator();
* System.out.println(”Seeding String=” + myGUID.getNewGuid(GuidCreator.BeforeMD5));
* System.out.println(”rawGUID=” + myGUID.getNewGuid(GuidCreator.AfterMD5));
* System.out.println(”RandomGUID=” + myGUID.getNewGuid(GuidCreator.FormatString));
* }
* }
*/

本方源于互联网，但已经过作者自己的修改，更易于使用

都市淘沙者 2007-11-17 23:31 发表评论

BlogJava-都市淘沙者-文章分类-Java Basic/Lucene/开源资料

BeanComparator实现ArrayList复合排序[转]

开源中最好的Web开发的资源

学习HTML 5编程和设计

服务器端的软件

PHP 框架和工具

数据库

API 和 在线数据

在线代码和媒体编辑器

代码资源和版本控制

JavaScript 桌面应用框架

JavaScript 移动和触摸框架

jQuery 插件

其它 jQuery 资源

HTML5 视频播放器

JavaScript 音频处理与可视化效果

JavaScript 图形 和 3D

JavaScript 浏览器接口 (HTML5)

JavaScript 工具

客户端和模拟器

CSS3 和 字库

Website (FULL) 模板

java中传输对象时候的问题（转）

Java Float类型 减法运算时精度丢失问题

ConcurrentHashMap原理分析

ConcurrentHashMap原理分析

一.Java并发基础

可见性

原子性

有序性

二.线程安全的HashMap

三.ConcurrentHashMap实现原理

数据结构

源码分析

http请求的详细过程 【推荐】

既有鱼肉又有熊掌——ListOrderedMap

JAVA异常详解

javaIO总结

j2ee的性能调优

利用HttpURLConnection连接servlet，发送接收xml包(转)

HttpURLConnection常用处理方式

Java分页

在java中理解“回调函数”

网络编程中的异步编程

实战体会Java的多线程编程 【转】

分层模式中的常见问题(zhuan)

引言

设计中的常见问题

问题一:数据传输对象（DTO）是否应该属于业务层？

问题二:使用POJO作业务对象的轻量级架构与上述层模型的映射

总结

线程同步 (转)

常用的多线程异步处理

程序员面试题（转）

JDK1.5中引入了对java语言的多种扩展

泛型是J2SE 5.0最重要的特性

递归实现类似腾讯的积分等级处理 (原创)

java中的io系统总结（转）

心跳包检测不可检测断线 (转)

四个有用的过滤器 Filter

JSP中与路径相关的常用的几个方法

正则表达式的作用

HttpClient 学习整理 (转)

使用Java生成GUID的类（转）

API 和在线数据

JavaScript 图形和 3D

CSS3 和字库

Java Float类型减法运算时精度丢失问题

http请求的详细过程【推荐】

实战体会Java的多线程编程【转】