【JAVA数组操作的常用工具类】

Java提供了的Arrays类里包含了一些static修饰方法可以直接操作数组，这个Arrays类里包含了提供了如下几个static修饰的方法(static修饰的方法可以直接通过类名调用)：

int binarySearch(type[] a，type key)：这个方法查询key元素值在a数组中出现的索引; 如果a数组不包含key元素值，则返回-1.调用该方法时要求数组中元素已经按升序排列，这样才能得到正确结果。

binarySearch(type[] a，int fromIndex，int toIndex，type key)：这个方法与前一个方法类似，但它只搜索a数组中formIndex到toIndex索引的元素。调用该方法时要求数组中元素已经按升序排列，这样才能得到正确结果。

type[] copyOf(type[] original，int newLength)：这个方法将会把original数组复制成一个新数组，其中length是新数组的长度。如果length小于original数组的长度，则新数组就是原数组的前面length个元素; 如果length大于original数组的长度，则新数组的前面元素就是原数组的所个元素，后面补充0(数值型)、false(布尔型)或者null(引用型)。

type[] copyOfRange(type[] original，int from，int to)：这个方法与前面方法相似，但这个方法只复制original数组的from索引到to索引的元素。

boolean equals(type[] a，type[] a2)：如果a数组和a2数组的长度相等，而且a数组和a2数组的数组元素也一一相同，该方法将返回true.

void fill(type[] a，type val)：该方法将会把a数组所有元素值都赋值为val.

void fill(type[] a，int fromIndex， int toIndex， type val)：该方法与前一个方法的作用相同，区别只是该方法仅仅将a数组的fromIndex到toIndex索引的数组元素赋值为val.

void sort(type[] a)：该方法对a数组的数组元素进行排序。

void sort(type[] a，int fromIndex，int toIndex)：该方法与前一个方法相似，区别是该方法仅仅对fromIndex到toIndex索引的元素进行排序。

String toString(type[] a)：该方法将会一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号(，)和空格隔开。(利用该方法可以很清楚地看到各数组元素)

下面程序示范了Arrays类的用法：

public class TestArrays

{

public static void main(String[] args)

{

//定义一个a数组

int[] a = new int[]{3, 4 , 5, 6};

//定义一个a2数组

int[] a2 = new int[]{3, 4 , 5, 6};

//a数组和a2数组的长度相等，每个元素依次相等，将输出true

System.out.println("a数组和a2数组是否相等：" Arrays.equals(a , a2));

//通过复制a数组，生成一个新的b数组

int[] b = Arrays.copyOf(a, 6);

System.out.println("a数组和b数组是否相等：" Arrays.equals(a , b));

//输出b数组的元素，将输出[3, 4, 5, 6, 0, 0]

System.out.println("b数组的元素为：" Arrays.toString(b));

//将b数组的第3个元素(包括)到第5个元素(不包括)赋为1

Arrays.fill(b , 2, 4 , 1); //fill方法可一次对多个数组元素进行批量赋值

//输出b数组的元素，将输出[3, 4, 1, 1, 0, 0]

System.out.println("b数组的元素为：" Arrays.toString(b));

//对b数组进行排序

Arrays.sort(b);

//输出b数组的元素，将输出[0, 0, 1, 1, 3, 4]

System.out.println("b数组的元素为：" Arrays.toString(b));

}

}

注意：Arrays类处于java.util包下，为了在程序中使用Arrays类，必须在程序中导入java.util.Arrays类。

除此之外，在System类里也包含了一个static void arraycopy(Object src，int srcPos，Object dest， int destPos，int length)方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcPos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。

【浅析Hibernate下数据批量处理方法】

很多人都对Java在批量数据的处理方面是否是其合适的场所持有怀疑的念头，由此延伸，那么就会认为ORM可能也不是非凡适合数据的批量处理。其实，我想假如我们应用得当的话，完全可以消除ORM批量处理性能问题这方面的顾虑。下面以Hibernate为例来做为说明，假如我们真的不得不在 Java中使用Hibernate来对数据进行批量处理的话。 向数据库插入100 000条数据，用Hibernate可能像这样：

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

for ( int i=0; i＜100000; i ) {

Customer customer = new Customer(.....);

session.save(customer); }

tx.commit();

session.close();

大概在运行到第50 000条的时候，就会出现内存溢出而失败。这是Hibernate把最近插入的Customer都以session-level cache在内存做缓存，我们不要忘记Hiberante并没有限制first-level cache 的缓存大小。

持久对象实例被治理在事务结束时，此时Hibernate与数据库同步任何已经发生变 化的被治理的的对象。

Session实现了异步write-behind，它答应Hibernate显式地写操作的批处理。 这里，我给出Hibernate如何实现批量插入的方法：

首先，我们设置一个合理的JDBC批处理大小，hibernate.jdbc.batch_size 20。 然后在一定间隔对Session进行flush()和clear()。

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

for ( int i=0; i＜100000; i ) {

Customer customer = new Customer(.....);

session.save(customer);

if ( i % 20 == 0 ) {

//flush 插入数据和释放内存:

session.flush(); session.clear(); }

}

tx.commit();

session.close();

那么，关于怎样删除和更新数据呢?那好，在Hibernate2.1.6或者更后版本，scroll() 这个方法将是最好的途径：

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

ScrollableResults customers = session.getNamedQuery("GetCustomers")

.scroll(ScrollMode.FORWARD_ONLY);

int count=0;

while ( customers.next() ) {

Customer customer = (Customer) customers.get(0);

customer.updateStuff(...);

if ( count % 20 == 0 ) {

//flush 更新数据和释放内存:

session.flush(); session.clear(); } }

tx.commit(); session.close();

这种做法并不困难，也不算不优雅。请注重，假如Customer启用了second-level caching ，我们仍然会有一些内存治理的问题。原因就是对于用户的每一次插入和更新，Hibernate在事务处理结束后不得不通告second-level cache 。因此，我们在批处理情况下将要禁用用户使用缓存。

【如何把Java程序编译成.exe文件】

常常在网上看到有人询问：如何把 java 程序编译成 .exe 文件。通常回答只有两种，一种是制作一个可执行的 JAR 文件包，然后就可以像.chm 文档一样双击运行了；而另一种是使用 JET 来进行 编译。但是 JET 是要用钱买的，而且据说 JET 也不是能把所有的 Java 程序都编译成执行文件，性能也要打些折扣。所以，使用制作可执行 JAR 文件包的方法就是最佳选择了，何况它还能保持 Java 的跨平台特性。

下面就来看看什么是 JAR 文件包吧：

1. JAR 文件包

JAR 文件就是 Java Archive File，顾名思意，它的应用是与 Java 息息相关的，是 Java 的一种文档格式。JAR 文件非常类似 ZIP 文件——准确的说，它就是 ZIP 文件，所以叫它文件包。JAR 文件与 ZIP 文件唯一的区别就是在 JAR 文件的内容中，包含了一个 META-INF/MANIFEST.MF 文件，这个文件是在生成 JAR 文件的时候自动创建的。举个例子，如果我们具有如下目录结构的一些文件：

==

`-- test

`-- Test.class

把它压缩成 ZIP 文件 test.zip，则这个 ZIP 文件的内部目录结构为：

test.zip

`-- test

`-- Test.class

如果我们使用 JDK 的 jar 命令把它打成 JAR 文件包 test.jar，则这个 JAR 文件的内部目录结构为：

test.jar

|-- META-INF

|　 `-- MANIFEST.MF

`-- test

`--Test.class

2. 创建可执行的 JAR 文件包

制作一个可执行的 JAR 文件包来发布你的程序是 JAR 文件包最典型的用法。

Java 程序是由若干个 .class 文件组成的。这些 .class 文件必须根据它们所属的包不同而分级分目录存放；运行前需要把所有用到的包的根目录指定给 CLASSPATH 环境变量或者 java 命令的 -cp 参数；运行时还要到控制台下去使用 java 命令来运行，如果需要直接双击运行必须写 Windows 的批处理文件 (.bat) 或者 Linux 的 Shell 程序。因此，许多人说，Java 是一种方便开发者苦了用户的程序设计语言。

其实不然，如果开发者能够制作一个可执行的 JAR 文件包交给用户，那么用户使用起来就方便了。在 Windows 下安装 JRE (Java Runtime Environment) 的时候，安装文件会将 .jar 文件映射给 javaw.exe 打开。那么，对于一个可执行的 JAR 文件包，用户只需要双击它就可以运行程序了，和阅读 .chm 文档一样方便 (.chm 文档默认是由 hh.exe 打开的)。那么，现在的关键，就是如何来创建这个可执行的 JAR 文件包。

创建可执行的 JAR 文件包，需要使用带 cvfm 参数的 jar 命令，同样以上述 test 目录为例，命令如下：

jar cvfm test.jar manifest.mf test

这里 test.jar 和 manifest.mf 两个文件，分别是对应的参数 f 和 m，其重头戏在 manifest.mf。因为要创建可执行的 JAR 文件包，光靠指定一个 manifest.mf 文件是不够的，因为 MANIFEST 是 JAR 文件包的特征，可执行的 JAR 文件包和不可执行的 JAR 文件包都包含 MANIFEST。关键在于可执行 JAR 文件包的 MANIFEST，其内容包含了 Main-Class 一项。这在 MANIFEST 中书写格式如下：

Main-Class: 可执行主类全名(包含包名)

例如，假设上例中的 Test.class 是属于 test 包的，而且是可执行的类 (定义了 public static void main(String[]) 方法)，那么这个 manifest.mf 可以编辑如下：

Main-Class: test.Test

这个 manifest.mf 可以放在任何位置，也可以是其它的文件名，只需要有 Main-Class: test.Test 一行，且该行以一个回车符结束即可。创建了 manifest.mf 文件之后，我们的目录结构变为：

==

|-- test

|　 `-- Test.class

`-- manifest.mf

这时候，需要到 test 目录的上级目录中去使用 jar 命令来创建 JAR 文件包。也就是在目录树中使用“==”表示的那个目录中，使用如下命令：

jar cvfm test.jar manifest.mf test

之后在“==”目录中创建了 test.jar，这个 test.jar 就是执行的 JAR 文件包。运行时只需要使用 java -jar test.jar 命令即可。

需要注意的是，创建的 JAR 文件包中需要包含完整的、与 Java 程序的包结构对应的目录结构，就像上例一样。而 Main-Class 指定的类，也必须是完整的、包含包路径的类名，如上例的 test.Test；而且在没有打成 JAR 文件包之前可以使用 java 来运行这个类，即在上例中 java test.Test 是可以正确运行的 (当然要在 CLASSPATH 正确的情况下)。

【如何使用Java编写多线程程序】

线程呢可以看作单独地占有CPU时间来执行相应的代码的。当然一个程序可以是多线程的，多线程的各个线程看上去像是并行地独自完成各自的工作，就像一台一台计算机上运行着多个处理机一样。

1、什么是线程

线程呢可以看作单独地占有CPU时间来执行相应的代码的。当然一个程序可以是多线程的，多线程的各个线程看上去像是并行地独自完成各自的工作，就像一台一台计算机上运行着多个处理机一样。在多处理机计算机上实现多线程时，它们确实可以并行工作，而且采用适当的分时策略可以大大提高程序运行的效率。

2、为什么要使用多线程

顺序执行程序和采用多线程并行执行程序相比，效率是可以大大地提高。

3、java中是如何实现多线程

在java语言中的线程系统是java语言自建的， 因为java中有专门的支持多线程的API库，所以很容易写一个支持线程的程序。在使用java创建线程的时候，可以生成一个Thread类或者他的子类对象，并给这个对象发送start()消息(程序可以向任何一个派生自 Runnable 接口的类对象发送 start() 消息的)，这样一来程序会一直执行，直到run返回为止，此时该线程就停止了。

在这里我们用多线程中最典型的例子，生产者与消费者问题。在这个例子里面我们定义了生产者Producer，消费者Consumer和仓库Warehouse三个类，在整个程序的生命周期里，生产者随机地制造出产品放到仓库中，消费者也是随即地从仓库中取出产品。

import exception.ProducerConsumerException;

/**

* Consumer.java

* Consumer

* By: Jiabo

* Date: Mar 21, 2004

* Time: 2:47:58 PM

*/

public class Consumer extends Thread {

private Warehouse warehouse;

private String id;

public Consumer(Warehouse warehouse, String id) {

this.warehouse = warehouse;

this.id = id;

}

public void run() {

int tmp = (int) Math.random() * 10;

try {

warehouse.get(tmp);

System.out.println("Consumer # " this.id " get " tmp);

} catch (ProducerConsumerException e) {

e.printStackTrace();

}

try {

sleep((int) (Math.random() * 100));

} catch (InterruptedException e) {

e.printStackTrace();

}

}

在这个类中，值得注意的一点是run方法中必须使用try-catch，因为，消费者从仓库中取东西时有可能诸如仓库中的储量不够得异常，在消费者里面也是一样，只不过异常变为仓库已满。

import exception.*;

/**

* Producer.java

* Producer

* By: Jiabo

* Date: Mar 21, 2004

* Time: 2:47:45 PM

*/

public class Producer extends Thread {

private Warehouse warehouse;

private String id;

public Producer(Warehouse warehouse, String id) {

this.warehouse = warehouse;

this.id = id;

}

public void run() {

int tmp = (int) Math.random() * 10;

if (tmp != 0) {

try {

warehouse.put(tmp);

System.out.println("Consumer # " this.id " put " tmp);

} catch (ProducerConsumerException e) {

e.printStackTrace();

}

}

try {

sleep((int) (Math.random() * 100));

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

最重要的一部分在Warehouse类，如上所说为了保证get何set的原子性，在这里使用了synchronized关键字，并且在操作时抛出了可能跑出的异常。

import exception.*;

/**

* Warehouse

* By: Jiabo

* Date: Mar 21, 2004

* Time: 2:48:10 PM

*/

public class Warehouse {

// max capability of the warehouse

private int MAX;

private int contents;

// init with max capacity

public Warehouse(int max) {

this.MAX = max;

this.contents = 0;

}

public synchronized void get(int amount) throws ProducerConsumerException {

// the amount you want to get is bigger than the contends that the warehouse stores

if (amount ＞ this.contents) {

throw new NotEnoughGoodsException();

}

amount -= contents;

}

public synchronized void put(int amount) throws ProducerConsumerException {

// the amount you want to put is out of the capability of the warehouse

if (amount ＞ (this.MAX - this.contents)) {

throw new WarehouseFullException();

} else if (this.contents == 0) {

// warehouse is empty

throw new WarehouseEmptyException();

}

amount = contents;

}

}