自由手記

宣告：前面KeyType, 後面ValueType

放入新元素

lJava语言
l面向对象分析设计思想
l设计模式和框架结构
lXML语言
l网页脚本语言
l数据库
l应用服务器
l集成开发环境

下面我们具体地看每个技术.

1、Java语言

Java语言体系比较庞大，包括多个模块。从WEB项目应用角度讲有JSP、Servlet、JDBC、JavaBean(Application)四部分技术。

（1）、Java Database Connectivity (JDBC)技术
在Java Web应用开发中，数据库管理系统（RDBMS）的使用是不可缺少的。JDBC(Java Database Connectivity) 是一种用于执行 SQL 语句的 Java API。它由一组用 Java 编程语言编写的类和接口组成。JDBC 为工具/数据库开发人员提供了一个标准的API，使他们能够用纯Java API 来编写数据库应用程序。
简单地说，JDBC 可做三件事：
l与数据库建立连接，
l发送 SQL 语句，
l处理结果。

（2）、Servlet技术
Servlet是运行在服务器端的程序，可以被认为是服务器端的applet。servlet被Web服务器（例如Tomcat）加载和执行，就如同applet被浏览器加载和执行一样。servlet从客户端(通过Web服务器)接收请求，执行某种操作，然后返回结果。

Servlet的主要优点包括
lServlet是持久的。servlet只需Web服务器加载一次，而且可以在不同请求之间保持服务(例如一次数据库连接)。
lServlet是与平台无关的。如前所述，servlet是用Java编写的，它自然也继承了Java的平台无关性。
lServlet是可扩展的。由于servlet是用Java编写的，它就具备了Java所能带来的所有优点。Java是健壮的、面向对象的编程语言，它很容易扩展以适应你的需求。servlet自然也具备了这些特征。
lServlet是安全的。从外界调用一个servlet的惟一方法就是通过Web服务器。这提供了高水平的安全性保障，尤其是在你的Web服务器有防火墙保护的时候。
lServlet可以在多种多样的客户机上使用。由于servlet是用Java编写的，所以你可以很方便地在HTML中使用它们。

（3）、JavaServer Pages(JSP) 技术
JSP是从Servlet上分离出来的一小部分，简化了开发，加强了界面设计。JSP定位在交互网页的开发。运用Java语法，但功能较Servlet弱了很多，并且高级开发中只充当用户界面部分。JSP容器收到客户端发出的请求时，首先执行其中的程序片段，然后将执行结果以HTML格式响应给客户端。其中程序片段可以是：操作数据库、重新定向网页以及发送 E-Mail 等等，这些都是建立动态网站所需要的功能。所有程序操作都在服务器端执行，网络上传送给客户端的仅是得到的结果，与客户端的浏览器无关，因此，JSP 称为Server-Side Language。

JavaServer Pages的主要优点包括
●一次编写，各处执行(Write o-nce, Run Anywhere)特性
作为Java 平台的一部分，JavaServer Pages 技术拥有Java语言“一次编写，各处执行”的特点。随着越来越多的供货商将JavaServer Pages 技术添加到他们的产品中，您可以针对自己公司的需求，做出审慎评估后，选择符合公司成本及规模的服务器，假若未来的需求有所变更时，更换服务器平台并不影响之前所投下的成本、人力所开发的应用程序。
● 搭配可重复使用的组件
JavaServer Pages技术可依赖于重复使用跨平台的组件（如：JavaBean或Enterprise JavaBean组件）来执行更复杂的运算、数据处理。开发人员能够共享开发完成的组件，或者能够加强这些组件的功能，让更多用户或是客户团体使用。基于善加利用组件的方法，可以加快整体开发过程，也大大降低公司的开发成本和人力。
● 采用标签化页面开发
Web 网页开发人员不一定都是熟悉Java 语言的程序员。因此，JSP 技术能够将许多功能封装起来，成为一个自定义的标签，这些功能是完全根据XML 的标准来制订的，即JSP 技术中的标签库(Tag Library)。因此，Web 页面开发人员可以运用自定义好的标签来达成工作需求，而无须再写复杂的Java 语法，让Web 页面开发人员亦能快速开发出一动态内容网页。
今后，第三方开发人员和其他人员可以为常用功能建立自己的标签库，让Web 网页开发人员能够使用熟悉的开发工具，如同HTML 一样的标签语法来执行特定功能的工作。
● N-tier 企业应用架构的支持
有鉴于网际网络的发展，为因应未来服务越来越繁杂的要求，且不再受地域的限制，因此，
必须放弃以往Client-Server的Two-tier 架构，进而转向更具威力、弹性的分散性对象系统。由于JavaServer Page 技术是Java 2 Platform Enterprise Edition (J2EE)集成中的一部分，它主要是负责前端显示经过复杂运算后之结果内容，而分散性的对象系统则是主要依赖EJB ( Enterprise JavaBean )和JNDI ( Java Naming and Directory Interface )构建而成。

（4）、JavaBean(Application)应用组件技术
Application是Java应用程序，在WEB项目和一些开发中主要应用JavaBean。它就是Application的一部分，逻辑运算能力很强，能极大的发挥Java语言的优点。JavaBean 被称为是Java 组件技术的核心。JavaBean 的结构必须满足一定的命名约定。JavaBean能提供常用功能并且可以重复使用，这使得开发人员可以把某些关键功能和核心算法提取出来封装成为一个组件对象，这样就增加了代码的重用率和系统的安全性。

高级的WEB项目会应用到以上所有技术，它们之间联合使用和协作开发会提高开发的效率和系统的性能。 

2、面向对象分析设计思想

Java语言是完全面向对象的语言，所以在项目设计时会有很大的帮助，在设计时应尽量舍弃以往的面向过程的设计方式。 

在分析项目业务关系的时候，应用一些UML(Unified Modeling Language)图,例如常用的用例图(use case diagram)，类图(class diagram)，时序图(sequence diagram)等等,会有很大的帮助，这样能尽快找出业务逻辑主要面对的对象，然后对每个对象进行行为划分，最后再实现对象之间的集成和通信。

3、设计模式和框架结构

Java从语言角度来讲不是很难，但是从整体设计角度来讲我们还需要了解一些高级应用框架。如果要设计一个良好的框架结构，单单只掌握Java语言远远不够。这就涉及到一个设计模式，还有和设计模式相关的一些知识。 

设计模式在Java项目实施过程更是重中之重。主要在与两层的设计模式、三层的设计模式和Ｎ层的设计模式。它直接决定着项目的应用、部署和实际开发设计。 

在普通的WEB项目中很多采用两层的开发结构。JSP+Servlet或JSP+JavaBean。当对开发要求高的项目中使用很多的还是MVC的三层开发结构，也就是JSP+Servlet+JavaBean。它能分有效的分离逻辑开发，使开发人员能专注于各自的开发。同时也能时整个开发结构流程更清晰，但是需要比较高的开发配合度。 
在项目中，我们经常使用著名的Model-View-Controller(MVC)架构。MVC架构是随着smalltalk language语言的发展提出的，它是一个著名的用户界面设计架构。经典的MVC架构把一个组件（可认为是整个应用程序的一个模块）划分成三部分组 Model管理这个模块中所用到的数据和业务逻辑。而View 管理模块如何显示给用户，Controller 决定如何处理用户和该模块交互式时候产生的事件 如用户点击一个按钮等。 

4、XML语言

在服务器和设计模式结构中会应用到自定义文件，而且在应用高级设计时也会定义自用的标签，现在流行的是用XML去定义配置，所以XML语言应该有一定掌握。
当前，Java 2平台企业版（J2EE）架构在厂商市场和开发者社区中倍受推崇。作为一种工具，可扩展标记语言（XML）简化了数据交换、进程间消息交换这一类的事情，因而对开发者逐渐变得有吸引力，并开始流行起来。自然，在J2EE架构中访问或集成XML解决方案的想法也很诱人。因为这将是强大系统架构同高度灵活的数据管理方案的结合。

XML的应用似乎是无穷无尽的，但它们大致上可以分为三大类：
1、简单数据的表示和交换（针对XML的简单API（SAX）和文档对象模型（DOM）语法解析，不同的文档类型定义（DTDs）和概要（schemas））
2、用户界面相关、表示相关的上下文（可扩展样式表语言（XSL），可扩展样式表语言转换（XSLT））
3、面向消息的计算（XML-RPC（远程过程调用），基于SOAP协议的Web 服务（Web Services），电子化业务XML（ebXML））

5、网页脚本语言

为了提高WEB项目的整体性能，提高人机交互的友好界面，网页的脚本语言是很有用处的，有的时候可以解决很大的难题或提高程序的性能和应用性。 

网页脚本语言的执行都是在客户端执行的，速度很很快，并且大多的操作与服务器没有交互运算，所以在一些应用中非常理想。在设计WEB项目的应用中，网页的脚本语言起着不能忽视的作用，所以如果设计WEB项目的应用中，对JavaScript应有一定的了解。

JavaScript是一种基于对象(Object Based)和事件驱动(Event Driven)并具有安全性能（Secure）的脚本语言。使用它的目的是与HTML超文本标记语言、Java 脚本语言（Java小程序）一起实现在一个Web页面中链接多个对象，与Web客户交互作用。从而可以开发客户端的应用程序等。它是通过嵌入或调入在标准的HTML语言中实现的。它具有以下几个基本特点：
1.它是一种脚本编写语言
JavaScript是一种脚本语言，它采用小程序段的方式实现编程。像其它脚本语言一样,JavaScript同样已是一种解释性语言,它提供了一个易的开发过程。 
它的基本结构形式与C、C++、VB十分类似。但它不像这些语言一样，需要先编译，而是在程序运行过程中被逐行地解释。它与HTML标识结合在一起，从而方便用户的使用操作。 
2. 基于对象的语言。
JavaScript是一种基于对象的语言，同时以可以看作一种面向对象的。这意味着它能运用自己已经创建的对象。因此，许多功能可以来自于脚本环境中对象的方法与脚本的相互作用。 
3.简单性
JavaScript的简单性主要体现在：首先它是一种基于Java基本语句和控制流之上的简单而紧凑的设计, 从而对于学习Java是一种非常好的过渡。其次它的变量类型是采用弱类型，并未使用严格的数据类型。 
4.安全性
JavaScript是一种安全性语言，它不允许访问本地的硬盘，并不能将数据存入到服务器上，不允许对网络文档进行修改和删除，只能通过浏览器实现信息浏览或动态交互。从而有效地防止数据的丢失。 
5. 动态性
JavaScript是动态的，它可以直接对用户或客户输入做出响应，无须经过Web服务程序。它对用户的响应，是采用以事件驱动的方式进行的。所谓事件驱动，就是指在主页(Home Page)中执行了某种操作所产生的动作，就称为“事件”(Event)。比如按下鼠标、移动窗口、选择菜单等都可以视为事件。当事件发生后，可能会引起相应的事件响应。 


6、开发工具
（1）、数据库 
在主要的应用中，数据库相关的环节应用很多，所以对数据库应该有一定了解。不能单单只了解一种数据库，因为在很多实际开发中会提出很多数据库解决方案，所以只有在了解多种数据库的情况下才能有一个比较方案。
对于数据库应该了解他的性能和一些基本的操作常识，还有该数据库的特点。而针对与Java语言WEB项目的数据库开发则主要是对JDBC的应用，还有数据库事务处理和连接池等高级概念的应用。


（2）、Web服务器

同数据库一样，应该了解该服务器的性能，特点和一些常识。
在应用方面，Web服务器主要是针对于配置和部署，对目录的配置，调试；对配置文件属性的修改；对访问权限和并发性的控制；Java类的部署等。

（3）、集成开发环境（IDE）：
“公欲善其事， 必先利其器”. 对于Web应用开发人员来讲，好的集成开发环境（IDE：Integrated Development Enviroment）是非常重要的。目前在市场上占主导位置的一个集成开发工具就是Eclipse.

本文引用地址：http://blog.sciencenet.cn/blog-1622005-885493.html  此文来自科学网张晓斌博客，转载请注明出处。

1. 使用用例：

import java.io.File;
import java.util.StringTokenizer;

public class CopyFiles extends FileUtil {
        
        private static void CopyFiles_Help(final String src, final String dest)
        {
                int nIndex = dest.lastIndexOf(File.separator);
                CreateFolders( dest.substring(0, nIndex) );
                CopyFile(src,dest);
                
        }
        public static void main(String[] args) {
                String[] strs=new String[]{
                                "target\\config\\comps\\src\\usrUsb2PhdcInit.c",
                                "target\\config\\comps\\src\\usrUsbDebug.c",
                                "target\\config\\comps\\src\\usrUsbInit.c",
                                "target\\config\\comps\\vxWorks\\40usb.cdf",
                                "target\\h\\usb\\usbOsalDebug.h",
                                "target\\h\\usb2\\usb2Phdc.h",
                                "target\\src\\drv\\usb2\\healthcare\\usb2Phdc.c",
                                "target\\src\\drv\\usb2\\healthcare\\Makefile"
                };
                
                for(int i=0;i<strs.length;i++){
                        CopyFiles_Help("D:\\wind6921\\vxworks-6.9\\"+strs[i], "D:\\My Documents\\Google Drive\\pmd-medical\\usbhealthcare"+strs[i] );
                }
        }

}

2.  文件工具類

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.StringTokenizer;

public class FileUtil {

        public static  void CreateFolders(final String folders) {
                StringTokenizer st = new StringTokenizer(folders, File.separator);
                StringBuilder sb = new StringBuilder();
                String osname = System.getProperty("os.name");
                if (osname.compareToIgnoreCase("linux") == 0)
                        sb.append(File.separator);

                while (st.hasMoreTokens()) {
                        sb.append(st.nextToken());
                        File file = new File(sb.toString());
                        if (!file.exists())
                                file.mkdir();
                        sb.append(File.separator);
                }

        }

        
        public static  boolean CopyFile(final String src, final String dest) {
                File srcFile = new File(src);
                File destFile = new File(dest);
                try {
                        if(!destFile.exists())
                                destFile.createNewFile();
                        
                        FileInputStream fin = new FileInputStream(srcFile);
                        FileOutputStream fout = new FileOutputStream(destFile);
                        int n = 0;
                        byte[] buf = new byte[4096];
                        while ( (n = fin.read(buf)) != -1 ) {
                                fout.write(buf, 0, n);
                        }
                        
                        fout.close();
                        fin.close();

                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                        return false;
                } catch (IOException e) {
                        e.printStackTrace();
                        return false;
                }

                return true;
        }

}

From:CSDN

第一步，先創建一個view信息的javabean類：

package com.zte.layout.adapter;

import android.view.View;

/**
 * 存儲View信息的JavaBean類
 * 
 * @author 
 * 
 */
public class LayoutInformation
{
        /**
         * View的對象
         */
        private View view;

        /**
         * View的寬度
         */
        private double viewWidth;

        /**
         * View的高度
         */
        private double viewHeight;

        /**
         * View距左邊的距離，即marginLeft
         */
        private double viewMarginLeft;

        /**
         * View距頂部的距離,即MarginTop;
         */
        private double viewMarginTop;
        
        /**
         * 父類布局的類型为相對布局
         */
        public static int R=-1;
        
        /**
         * 父類布局的類型为線性布局
         */
        public static int L=-2;
        
        /**
         * 此View的父類布局的類型
         */
        private int parentLayoutType;

        /**
         * 存儲View信息的JavaBean類
         * 
         * @param view
         *            View的對象
         * @param viewWidth
         *            View的寬
         * @param viewHeight
         *            View的高
         * @param viewMarginLeft
         *            View距左邊的距離
         * @param viewMargdoubleop
         *            View距上部的距離
         * @param parentLayoutType
         *            父類布局的類型,LayoutInformation.R
         *            (表示相對布局)或者LayoutInformation.L(表示線性布局)
         */
        public LayoutInformation(View view, double viewWidth, double viewHeight,
                        double viewMarginLeft, double viewMarginTop, int parentLayoutType)
        {

                this.view = view;
                this.viewWidth = viewWidth;
                this.viewHeight = viewHeight;
                this.viewMarginLeft = viewMarginLeft;
                this.viewMarginTop = viewMarginTop;
                this.parentLayoutType=parentLayoutType;
        }

        /**
         * 獲取View的對象
         * 
         * @return View對象
         */
        public View getView()
        {
                return view;
        }

        /**
         * 設置View的對象
         */
        public void setView(View view)
        {
                this.view = view;
        }

        /**
         * 獲取View的寬度
         * 
         * @return View的寬度,double型
         */
        public double getViewWidth()
        {
                return viewWidth;
        }

        /**
         * 設置View的寬度，double型
         * 
         * @param viewWidth
         */
        public void setViewWidth(double viewWidth)
        {
                this.viewWidth = viewWidth;
        }

        /**
         * 獲取View的高度
         * 
         * @return View的高度,double型
         */
        public double getViewHeight()
        {
                return viewHeight;
        }

        /**
         * 設置View的高度，double型
         * 
         * @param viewHeight
         */
        public void setViewHeight(double viewHeight)
        {
                this.viewHeight = viewHeight;
        }

        /**
         * 獲取View距離左邊的距離
         * 
         * @return View距離左邊的距離，double型
         */
        public double getViewMarginLeft()
        {
                return viewMarginLeft;
        }

        /**
         * 設置View距離左邊的距離,double型
         * 
         * @param viewMarginLeft
         */
        public void setViewMarginLeft(double viewMarginLeft)
        {
                this.viewMarginLeft = viewMarginLeft;
        }

        /**
         * 獲取View距離上部的距離
         * 
         * @return View距離上部的距離，double型
         */
        public double getViewMarginTop()
        {
                return viewMarginTop;
        }

        /**
         * 設置View距離上部的距離，double型
         * 
         * @param viewMargdoubleop
         */
        public void setViewMarginTop(double viewMarginTop)
        {
                this.viewMarginTop = viewMarginTop;
        }
        
        /**
         * 獲取父類布局的類型
         * @return parentLayoutType，int型
         */
        public int getParentLayoutType()
        {
                return parentLayoutType;
        }

        /**
         * 設置父類布局的類型
         * @param parentLayoutType
         */
        public void setParentLayoutType(int parentLayoutType)
        {
                this.parentLayoutType = parentLayoutType;
        }

}

第二步：創建一個計算方法：

import java.util.List;

import android.app.Activity;
import android.content.Context;
import android.util.DisplayMetrics;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;

/**
 * 分配率通配類
 * 
 * @author 
 * 
 */
public class MyLayoutAdapter
{
        /**
         * 基准分辨率的寬
         */
        public double STANDARD_SCREEN_WIDTH;

        /**
         * 基准分辨率的高
         */
        public double STANDARD_SCREEN_HEIGHT;

        /**
         * 系統當前的分辨率的寬
         */
        public double CURRENT_SCREEN_WIDTH;

        /**
         * 系統當前的分辨率的高
         */
        public double CURRENT_SCREEN_HEIGHT;

        /**
         * 基准屏幕密度
         */
        public static final double STANDARD_DENSITY = 160;

        /**
         * 當前屏幕密度
         */
        private double CURRENT_DENSITY;

        /**
         * 屏幕密度比例
         */
        private double DENSITY_RATIO;

        /**
         * 屏幕寬度比例
         */
        private double WIDTH_RATIO;

        /**
         * 屏幕高度比例
         */
        private double HEIGHT_RATIO;

        /**
         * 組件基准的寬度
         */
        private double viewStandardWidth;

        /**
         * 組件基准的高度
         */
        private double viewStandardHeight;

        /**
         * 組件基准的距離左邊的距離
         */
        private double viewStandardMarginLeft;

        /**
         * 組件基准的距離頂部的距離
         */
        private double viewStandardMarginTop;

        /**
         * 組件當前的寬
         */
        private double viewCurrentWidth;

        /**
         * 組件當前的高
         */
        private double viewCurrentHeight;

        /**
         * 組件當前距離左邊的距離
         */
        private double viewCurrentMarginLeft;

        /**
         * 組件當前距離頂部的距離
         */
        private double viewCurrentMarginTop;

        /**
         * UI組件的對象
         */
        private View view;

        /**
         * 此View的父類布局的類型
         */
        private int parentLayoutType;

        /**
         * 父類布局的類型为相對布局
         */
        private final int LAYOUT_TYPE_RELATiVELAYOUT = LayoutInformation.R;

        /**
         * 父類布局的類型为線性布局
         */
        private final int LAYOUT_TYPE_LINEARLAYOUT = LayoutInformation.L;

        /**
         * 布局屬性为wrap_content
         */
        private final int LAYOUTPARAMS_WARP_CONTENT = LayoutParams.WRAP_CONTENT;

        /**
         * 布局屬性为fill_parent
         */
        private final int LAYOUTPARAMS_FILL_PARENT = LayoutParams.FILL_PARENT;

        private Context context;

        /**
         * 類對象實例化時,設置 基准屏幕寬度,高度
         * 
         * @param context
         *            Context
         * @param standardWidth
         *            基准屏幕的寬
         * @param standardHeight
         *            基准屏幕的高
         */
        public MyLayoutAdapter(Context context, double standardWidth,
                        double standardHeight)
        {
                this.context = context;
                getScreenSize();
                STANDARD_SCREEN_HEIGHT = standardHeight;
                STANDARD_SCREEN_WIDTH = standardWidth;
                // 計算寬高比率
                WIDTH_RATIO = CURRENT_SCREEN_WIDTH / STANDARD_SCREEN_WIDTH;
                HEIGHT_RATIO = CURRENT_SCREEN_HEIGHT / STANDARD_SCREEN_HEIGHT;
        }

        /**
         * 獲取當前屏幕大小和密度
         */
        private void getScreenSize()
        {
                DisplayMetrics displayMetrics = new DisplayMetrics();
                ((Activity) context).getWindowManager().getDefaultDisplay()
                                .getMetrics(displayMetrics);
                CURRENT_SCREEN_WIDTH = displayMetrics.widthPixels;
                CURRENT_SCREEN_HEIGHT = displayMetrics.heightPixels;
                CURRENT_DENSITY = displayMetrics.densityDpi;
                DENSITY_RATIO = STANDARD_DENSITY / CURRENT_DENSITY;
        }

        /**
         * 進行通配
         * 
         * @param listdata
         */
        public void setViewLayout(List<LayoutInformation> listdata)
        {

                for (int i = 0; i < listdata.size(); i++)
                {

                        view = listdata.get(i).getView();
                        viewStandardWidth = listdata.get(i).getViewWidth();
                        viewStandardHeight = listdata.get(i).getViewHeight();
                        viewStandardMarginLeft = listdata.get(i).getViewMarginLeft();
                        viewStandardMarginTop = listdata.get(i).getViewMarginTop();

                        setLayoutParams();
                        viewCurrentMarginLeft = viewStandardMarginLeft * WIDTH_RATIO;
                        viewCurrentMarginTop = viewStandardMarginTop * HEIGHT_RATIO;
                        parentLayoutType = listdata.get(i).getParentLayoutType();
                        setLayoutByParentLayoutType();
                }
        }

        /**
         * 判斷布局屬性的值，設置布局的屬性
         */
        private void setLayoutParams()
        {
                // 如果基准的寬是wrap_content或者fill_parent則使用原值，否則進行計算得到通配後的值
                if (viewStandardWidth == LAYOUTPARAMS_WARP_CONTENT
                                || viewStandardWidth == LAYOUTPARAMS_FILL_PARENT)
                {
                        viewCurrentWidth = viewStandardWidth;
                } else
                {
                        viewCurrentWidth = viewStandardWidth * WIDTH_RATIO;
                }

                // 如果基准的寬是wrap_content或者fill_parent則使用原值，否則進行計算得到通配後的值
                if (viewStandardHeight == LAYOUTPARAMS_WARP_CONTENT
                                || viewStandardHeight == LAYOUTPARAMS_FILL_PARENT)
                {
                        viewCurrentHeight = viewStandardHeight;
                } else
                {
                        viewCurrentHeight = viewStandardHeight * HEIGHT_RATIO;
                }
        }

        /**
         * 通過判斷此View父類的布局類型,给此View設置布局
         */
        private void setLayoutByParentLayoutType()
        {

                if (parentLayoutType == LAYOUT_TYPE_RELATiVELAYOUT)
                {

                        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
                                        (int) viewCurrentWidth, (int) viewCurrentHeight);

                        params.setMargins((int) viewCurrentMarginLeft,
                                        (int) viewCurrentMarginTop, 0, 0);

                        view.setLayoutParams(params);

                } else if (parentLayoutType == LAYOUT_TYPE_LINEARLAYOUT)
                {

                        LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
                                        (int) viewCurrentWidth, (int) viewCurrentHeight);
                        params.setMargins((int) viewCurrentMarginLeft,
                                        (int) viewCurrentMarginTop, 0, 0);
                        view.setLayoutParams(params);
                }
        }

        /**
         * 設置字體大小
         * 
         * @param standardSize
         *            原始大小
         * @return int
         */
        public int setTextSize(int standardSize)
        {
                int currentSize;
                currentSize = (int) (standardSize * WIDTH_RATIO * DENSITY_RATIO);

                return currentSize;
        }
}

第三步，寫一個接口：

public interface InitAllView{
        /**
         * 初始化控件的大小
         */
        public void initAllView();

}

第四步：代碼控制：

/**
         * 通配方法
         */
        private void initWildcard() {
                myLayout = new MyLayoutAdapter(this, 320, 480);
                listInfo = new ArrayList<LayoutInformation>();
                listInfo.add(new LayoutInformation(mBtn1, LayoutParams.WRAP_CONTENT,
                                LayoutParams.WRAP_CONTENT, 0, 0, LayoutInformation.R));
                listInfo.add(new LayoutInformation(mNowRegisterBtn, 80, 27.3, 14.7, 0,
                                LayoutInformation.R));
                listInfo.add(new LayoutInformation(mNextRegisterBtn, 80, 27.3, 14.7, 0,
                                LayoutInformation.R));

                // listInfo.add(new LayoutInformation(mCheckBtn, 17.3,17.3, 14.7, 0,
                // LayoutInformation.L));
                mBtn1.setTextSize(myLayout.setTextSize(12));
                mNowRegisterBtn.setTextSize(myLayout.setTextSize(12));
                mNextRegisterBtn.setTextSize(myLayout.setTextSize(12));
                myLayout.setViewLayout(listInfo);
        }

package lesson5;

import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

public class logion extends JFrame{

public static void main(String[] args){

原文地址：C/C++调用java---JNI常用函数作者：枝叶飞扬
类操作

DefineClass
jclass DefineClass(JNIEnv *env, jobject loader, const jbyte *buf, jsize bufLen);
从原始类数据的缓冲区中加载类。
参数：
env：JNI 接口指针。
loader：分派给所定义的类的类加载器。
buf：包含 .class 文件数据的缓冲区。

标签：java   获取压缩包文件   广度优先遍历   深度优先遍历   递归调用   

          作者：张昌昌

         为了获取一个压缩包中的文件，而该压缩包里可能又含有压缩包 、文件夹、文件夹里又包含压缩包、文件等各种嵌套的情况，采用广度优先遍历和深度优先遍历的方法解决了此问题。

public static List<File> getFilesOfZipAndRar(String zipPath) throws IOException
     {
      String destPath = zipPath.substring(0,zipPath.lastIndexOf(".")) + "/";
      //先将该压缩文件解压
      if(zipPath.contains(".zip"))
       unZipFile(new File(zipPath),destPath);
      if(zipPath.contains(".rar"))
       unRarFile(new File(zipPath),destPath);
      //进入解压目录，将该目录的所有zip都解压
      recursiveCompressedFile(new File(destPath));
      //得到该目录下的所有文件
      Iterator iterator = Directory.walk(destPath).iterator();
         List<File> files = new ArrayList<File>();
         File file = null;
         while(iterator.hasNext())
         {
          file = (File)iterator.next();
          if(file.getName().contains(".rar"))
           continue;
          files.add(file);
         }
         return files;
     }
     
     public static void recursiveCompressedFile(File file) throws IOException
     {
      //广度优先遍历
      for(File e:file.listFiles())
      {
       String filePath = e.getAbsolutePath().replace("\\\\","/");
       //深度优先遍历
       if(e.getName().contains(".zip"))
       {
        String desString = filePath.substring(0,filePath.lastIndexOf("."))+"/";
        unZipFile(e,desString);
        e.delete();
        recursiveCompressedFile(new File(desString));
       }
       if(e.getName().contains(".rar"))
       {
        String desString = filePath.substring(0,filePath.lastIndexOf("."))+"/";
        unRarFile(e,desString);
        e.delete();
        recursiveCompressedFile(new File(desString)); 
       }
       if(e.isDirectory())
        recursiveCompressedFile(e);
      }
     }

总结：该问题的解决过程中学习了：（1）广度优先和深度优先的策略；（2）递归调用的方法；（3）如何解压文件

转载请说明出处。

java获取递归获取嵌套压缩包(zip和rar)中的所有文件

原文：Java 扑克发牌算法实现  代码下载地址：http://www.zuidaima.com/share/1550463274224640.htm

两种方法: A. 扑克发牌算法是棋牌游戏中常用的基础算法，也是游戏开发人员需要熟悉的基础算法之一。下面介绍一下该算法的一种实现方式。 B.利用Random类的对象的链表中一随机的顺序存储一副52张的纸牌。用含有连个字符的字符串代表纸牌，例如“1C”表示梅花A,”JD”表示方片J等。从栈中输出4手牌，每手牌有13张纸牌。

Java代码  

1. 首先给扑克牌中每张牌设定一个编号，下面算法实现的编号规则如下：  
2. 　　u　　　 红桃按照从小到大依次为：1-13  
3. 　　u　　　 方块按照从小到大依次为：14-26  
4. 　　u　　　 黑桃按照从小到大依次为：27-39  
5. 　　u　　　 梅花按照从小到大依次为：40-52  
6. 　　u　　　 小王为53，大王为54  
7. 　　算法实现如下：  
8. 　　u　　　 首先按照以上编号规则初始化一个包含108个数字的数组  
9. 　　u　　　 每次随机从该数组中抽取一个数字，分配给保存玩家数据的数组  
10. 　　实现该功能的代码如下所示：  
11.     package com.zuidaima;  
12. 　　import Java.util.*;  
13. 　　/** 
14. 　　* 发牌算法的实现 
15. 　　* 要求：把2副牌，也就是108张，发给4个人，留6张底牌 
16. *     @author www.zuidaima.com 
17. */  
18. public class Exec{  
19. 　　　 public static void main(String[] args){  
20. 　　　　　　　//存储108张牌的数组  
21. 　　　　　　　int[] total = new int[108];  
22. 　　　　　　　//存储四个玩家的牌  
23. 　　　　　　　int[][] player = new int[4][25];  
24. 　　　　　　　//存储当前剩余牌的数量  
25. 　　　　　　　int leftNum = 108;  
26. 　　　　　　　//随机数字  
27. 　　　　　　　int ranNumber;  
28. 　　　　　　　//随机对象  
29. 　　　　　　　Random random = new Random();  
30. 　　　　　　　//初始化数组  
31. 　　　　　　　for(int i = 0;i < total.length;i++){  
32. 　　　　　　　　　　 total[i] = (i + 1) % 54;  
33. 　　　　　　　　　　 //处理大小王编号  
34. 　　　　　　　　　　 if(total[i] == 0){  
35. 　　　　　　　　　　　　　　total[i] = 54;　  
36. 　　　　　　　　　　 }  
37. 　　　　　　　}  
38. 　　　　　　　//循环发牌  
39. 　　　　　　　for(int i = 0;i < 25;i++){  
40. 　　　　　　　　　　 //为每个人发牌  
41. 　　　　　　　　　　 for(int j = 0;j < player.length;j++){  
42. 　　　　　　　　　　　　　　//生成随机下标  
43. 　　　　　　　　　　　　　　ranNumber = random.nextInt(leftNum);  
44. 　　　　　　　　　　　　　　//发牌  
45. 　　　　　　　　　　　　　　player[j][i] = total[ranNumber];  
46. 　　　　　　　　　　　　　　//移动已经发过的牌  
47. 　　　　　　　　　　　　　　total[ranNumber] = total[leftNum - 1];  
48. 　　　　　　　　　　　　　　//可发牌的数量减少1  
49. 　　　　　　　　　　　　　　leftNum--;　　　  
50. 　　　　　　　　　　 }　　  
51. 　　　　　　　}  
52. 　　　　　　　//循环输出玩家手中的牌  
53. 　　　　　　　for(int i = 0;i < player.length;i++){  
54. 　　　　　　　　　　 for(int j = 0;j < player[i].length;j++){  
55. 　　　　　　　　　　　　　　System.out.print("　" + player[i][j]);　　  
56. 　　　　　　　　　　 }  
57. 　　　　　　　　　　 System.out.println();  
58. 　　　　　　　}  
59. 　　　　　　　//底牌  
60. 　　　　　　　for(int i = 0;i < 8;i++){  
61. 　　　　　　　　　　 System.out.print("　" + total[i]);　  
62. 　　　　　　　}  
63. 　　　　　　　System.out.println();  
64. 　　　 }  
65. }  
66.   
67.                       

通过java实现解压zip，rar的代码。

原创不易，转载请注明出处：java解压zip，rar的代码

Java代码  

1. package com.zuidaima.util.unzip;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.io.OutputStream;  
8. import java.net.URL;  
9. import java.util.zip.ZipEntry;  
10. import java.util.zip.ZipInputStream;  
11.   
12. import com.github.junrar.Archive;  
13. import com.github.junrar.exception.RarException;  
14. import com.github.junrar.rarfile.FileHeader;  
15.   
16. public class Main {  
17.   
18.     public void extractZipFiles() {  
19.         String root = "c:/javazip/";  
20.         URL url = Main.class.getResource("/aa.zip");  
21.         String filename = url.getFile();  
22.         try {  
23.             // destination folder to extract the contents  
24.             byte[] buf = new byte[1024];  
25.             ZipInputStream zipinputstream = null;  
26.             ZipEntry zipentry;  
27.             zipinputstream = new ZipInputStream(new FileInputStream(filename));  
28.             zipentry = zipinputstream.getNextEntry();  
29.             while (zipentry != null) {  
30.   
31.                 // for each entry to be extracted  
32.                 String entryName = zipentry.getName();  
33.   
34.                 System.out.println(entryName);  
35.   
36.                 int n;  
37.                 FileOutputStream fileoutputstream;  
38.                 File newFile = new File(entryName);  
39.   
40.                 String directory = newFile.getParent();  
41.   
42.                 // to creating the parent directories  
43.                 if (directory == null) {  
44.                     if (newFile.isDirectory()) {  
45.                         break;  
46.                     }  
47.                 } else {  
48.                     new File(root + directory).mkdirs();  
49.                 }  
50.   
51.                 if (!zipentry.isDirectory()) {  
52.                     System.out.println("File to be extracted....." + entryName);  
53.                     fileoutputstream = new FileOutputStream(root + entryName);  
54.                     while ((n = zipinputstream.read(buf, 0, 1024)) > -1) {  
55.                         fileoutputstream.write(buf, 0, n);  
56.                     }  
57.                     fileoutputstream.close();  
58.                 }  
59.   
60.                 zipinputstream.closeEntry();  
61.                 zipentry = zipinputstream.getNextEntry();  
62.             }  
63.             zipinputstream.close();  
64.         } catch (Exception e) {  
65.             e.printStackTrace();  
66.         }  
67.     }  
68.   
69.     public void extractRarFiles() {  
70.         URL url = Main.class.getResource("/bb.rar");  
71.         String filename = url.getFile();  
72.         File archive = new File(filename);  
73.         File destination = new File("c:/javazip/");  
74.   
75.         Archive arch = null;  
76.         try {  
77.             arch = new Archive(archive);  
78.         } catch (RarException e) {  
79.             e.printStackTrace();  
80.         } catch (IOException e) {  
81.             e.printStackTrace();  
82.         }  
83.         if (arch != null) {  
84.             if (arch.isEncrypted()) {  
85.                 System.out.println("archive is encrypted cannot extreact");  
86.                 return;  
87.             }  
88.             FileHeader fh = null;  
89.             while (true) {  
90.                 fh = arch.nextFileHeader();  
91.                 if (fh == null) {  
92.                     break;  
93.                 }  
94.                 if (fh.isEncrypted()) {  
95.                     System.out.println("file is encrypted cannot extract: "  
96.                             + fh.getFileNameString());  
97.                     continue;  
98.                 }  
99.                 System.out.println("extracting: " + fh.getFileNameString());  
100.                 try {  
101.                     if (fh.isDirectory()) {  
102.                         createDirectory(fh, destination);  
103.                     } else {  
104.                         File f = createFile(fh, destination);  
105.                         OutputStream stream = new FileOutputStream(f);  
106.                         arch.extractFile(fh, stream);  
107.                         stream.close();  
108.                     }  
109.                 } catch (Exception e) {  
110.                     e.printStackTrace();  
111.                 }  
112.             }  
113.         }  
114.     }  
115.   
116.     private File createFile(FileHeader fh, File destination) {  
117.         File f = null;  
118.         String name = null;  
119.         if (fh.isFileHeader() && fh.isUnicode()) {  
120.             name = fh.getFileNameW();  
121.         } else {  
122.             name = fh.getFileNameString();  
123.         }  
124.         f = new File(destination, name);  
125.         if (!f.exists()) {  
126.             try {  
127.                 f = makeFile(destination, name);  
128.             } catch (IOException e) {  
129.                 e.printStackTrace();  
130.             }  
131.         }  
132.         return f;  
133.     }  
134.   
135.     private File makeFile(File destination, String name) throws IOException {  
136.         String[] dirs = name.split("\\\\");  
137.         if (dirs == null) {  
138.             return null;  
139.         }  
140.         String path = "";  
141.         int size = dirs.length;  
142.         if (size == 1) {  
143.             return new File(destination, name);  
144.         } else if (size > 1) {  
145.             for (int i = 0; i < dirs.length - 1; i++) {  
146.                 path = path + File.separator + dirs[i];  
147.                 new File(destination, path).mkdir();  
148.             }  
149.             path = path + File.separator + dirs[dirs.length - 1];  
150.             File f = new File(destination, path);  
151.             f.createNewFile();  
152.             return f;  
153.         } else {  
154.             return null;  
155.         }  
156.     }  
157.   
158.     private void createDirectory(FileHeader fh, File destination) {  
159.         File f = null;  
160.         if (fh.isDirectory() && fh.isUnicode()) {  
161.             f = new File(destination, fh.getFileNameW());  
162.             if (!f.exists()) {  
163.                 makeDirectory(destination, fh.getFileNameW());  
164.             }  
165.         } else if (fh.isDirectory() && !fh.isUnicode()) {  
166.             f = new File(destination, fh.getFileNameString());  
167.             if (!f.exists()) {  
168.                 makeDirectory(destination, fh.getFileNameString());  
169.             }  
170.         }  
171.     }  
172.   
173.     private void makeDirectory(File destination, String fileName) {  
174.         String[] dirs = fileName.split("\\\\");  
175.         if (dirs == null) {  
176.             return;  
177.         }  
178.         String path = "";  
179.         for (String dir : dirs) {  
180.             path = path + File.separator + dir;  
181.             new File(destination, path).mkdir();  
182.         }  
183.     }  
184.   
185.     public static void main(String[] args) {  
186.         Main main = new Main();  
187.         // extract zip  
188.         main.extractZipFiles();  
189.         // extract rar  
190.         main.extractRarFiles();  
191.     }  
192. }  
193.   
194.                       

 代码下载地址:http://www.zuidaima.com/share/1550463229430784.htm

三種jar包：

<1>androiddataframework HTTP://code.google.com/p/androiddataframework/

<2>ormlite HTTP://ormlite.com/sqlite_java_android_orm.shtml

<3>AHibernate HTTP://www.cnblogs.com/zlja/archive/2012/04/13/2446561.html

由於我先看的第二個ormlite，那就先說ormlite，後續會補上androiddataframework和AHibernate。

Ormlite

ormlite的最新jar包可以從上面的下載，我從這個網頁上瞭解一下ormlite的相關知識，總結如下：

<1>對於Android開發來說需要下載ormlite-android-4.45.jar and ormlite-core-
4.45.jar，運行環境要求是JDK1.5以上

<2>此工具不能自動Model，需要手動生成Model

* 一個多線程異步Http連接框架。它可用於Android項目或者一般JAVA項目。

程式碼下載

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

public class MessageServer {

public static final int PORT = 10123;

1、通過設置page指令的pageEncoding="UTF-8"屬性，來設置jsp檔的保存編碼。

從ftp主機取xx數據檔.

千萬級別只是個概念，代表數據量等於千萬或者大於千萬的數據

本分享不牽扯分散式採集存儲之類的.是在一台機器上處理數據，如果數據量很大很大的話，可以考慮分散式處理，如果以後我有這方面的經驗，會及時分享的.

1、程式採用的ftp工具， apache 的 commons-net-ftp-2.0.jar

PermGen space的全稱是Permanent Generation space,是指內存的永久保存區域OutOfMemoryError: PermGen space從表面上看就是內存益出，解決方法也一定是加大內存。說說為什麼會內存益出：這一部分用於存放Class和Meta的資訊,Class在被 Load的時候被放入PermGen space區域，它和和存放Instance的Heap區域不同,GC(Garbage Collection)不會在主程式運行期對PermGen space進行清理，所以如果你的APP會LOAD很多CLASS的話,就很可能出現PermGen space錯誤。這種錯誤常見在web服務器對JSP進行pre compile的時候。改正方法：-Xms256m -Xmx256m -XX:MaxNewSize=256m -XX:MaxPermSize=256m 2、在tomcat中redeploy時出現outofmemory的錯誤. 可以有以下幾個方面的原因:
1,使用了proxool,因為proxool內部包含了一個老版本的cglib.
2, log4j,最好不用,只用common-logging
3, 老版本的cglib,快點更新到最新版。
4，更新到最新的hibernate3.2 3、

這裏以tomcat環境為例，其它WEB服務器如jboss,weblogic等是同一個道理。
一、java.lang.OutOfMemoryError: PermGen space PermGen space的全稱是Permanent Generation space,是指內存的永久保存區域, 這塊內存主要是被JVM存放Class和Meta資訊的,Class在被Loader時就會被放到PermGen space中, 它和存放類實例(Instance)的Heap區域不同,GC(Garbage Collection)不會在主程式運行期對 PermGen space進行清理，所以如果你的應用中有很多CLASS的話,就很可能出現PermGen space錯誤, 這種錯誤常見在web服務器對JSP進行pre compile的時候。如果你的WEB APP下都用了大量的協力廠商jar, 其大小超過了jvm默認的大小(4M)那麼就會產生此錯誤資訊了。
解決方法： 手動設置MaxPermSize大小修改TOMCAT_HOME/bin/catalina.sh 在「echo "Using CATALINA_BASE: $CATALINA_BASE"」上面加入以下行： JAVA_OPTS="-server -XX:PermSize=64M -XX:MaxPermSize=128m
建議：將相同的協力廠商jar檔移置到tomcat/shared/lib目錄下，這樣可以達到減少jar 文檔重複佔用內存的目的。
二、java.lang.OutOfMemoryError: JAVA heap space Heap size 設置 JVM堆的設置是指java程式運行過程中JVM可以調配使用的內存空間的設置.JVM在啟動的時候會自動設置Heap size的值，其初始空間(即-Xms)是物理內存的1/64，最大空間(-Xmx)是物理內存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等選項可進行設置。Heap size 的大小是Young Generation 和Tenured Generaion 之和。提示：在JVM中如果98％的時間是用於GC且可用的Heap size 不足2％的時候將拋出此異常資訊。提示：Heap Size 最大不要超過可用物理內存的80％，一般的要將-Xms和-Xmx選項設置為相同，而-Xmn為1/4的-Xmx值。

這些日子要用爪哇語言（Java）做內存數據中心。於是把用 Java 監控運行環境硬件資源的內容复習了一下。爪哇類庫提供了 java.util.Runtim 類，主要負責調用爪哇虛擬機（JavaVM）外部的基層操作系統功能、處理基於一種叫鉤子的原理的程序、獲取系統資源信息以及控制調試信息生成。本文單獨利用其獲取系統資源信息的功能。

java.util.Runtim 類具有以下幾個方法和獲取系統資源信息有關。以下代碼可不是簡簡單單從標准類庫裏邊复制出來的哦。全球目前獨此一份。

/**
* 返回爪哇（Java）虛擬機可用線程數。
*
* <p>該值在特定的虛擬機調用期間可能發生更改。因此，對可用處理器數目很敏感的
* 應用程序應該不定期地輪詢該屬性，並相應地調整其資源用法。</p>
*
* @return 虛擬機可用的最大處理器數目；從不小於 1
* @since 1.4