北京邮电大学研究生java技术-孟祥武老师-期末复习题整理

1.判断闰年

import java.util.Scanner;

public class DemoTest {

/**

* @param args 此处代码无实际意义，可删除

*/

public static void main(String[]args){

Scanner scan = new Scanner(System.in);//创建输入流扫描器;

System.out.println("请输入一个年份：");//向控制台输出一个提示信息

long year;

try{

year = scan.nextLong();

if(year%4 == 0 && year%100!=0 || year%400 == 0){//是闰年

System.out.print(year+"是闰年!");

}else{

System.out.print(year+"不是闰年!");

}

}catch(Exception e){

System.out.println("你输入的不是有效的年份");

}

}

} 2.Socket编程

对于Java Socket编程而言，有两个概念，一个是ServerSocket，一个是Socket。服务端和客户端之间通过Socket建立连接，之后它们就可以进行通信了。首先ServerSocket将在服务端监听某个端口，当发现客户端有Socket来试图连接它时，它会accept该Socket的连接请求，同时在服务端建立一个对应的Socket与之进行通信。这样就有两个Socket了，客户端和服务端各一个。

对于Socket之间的通信其实很简单，服务端往Socket的输出流里面写东西，客户端就可以通过Socket的输入流读取对应的内容。Socket与Socket之间是双向连通的，所以客户端也可以往对应的Socket输出流里面写东西，然后服务端对应的Socket的输入流就可以读出对应的内容。下面来看一些服务端与客户端通信的例子：

1、客户端写服务端读

服务端代码

Java代码

public class Server {

public static void main(String args[]) throws IOException { //为了简单起见，所有的异常信息都往外抛

int port = 8899;

//定义一个ServerSocket监听在端口8899上

ServerSocket server = new ServerSocket(port);

//server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的

Socket socket = server.accept();

//跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。

Reader reader = new InputStreamReader(socket.getInputStream());

char chars[] = new char[64];

int len;

StringBuilder sb = new StringBuilder();

while ((len=reader.read(chars)) != -1) {

sb.append(new String(chars, 0, len));

}

System.out.println("from client: " + sb);

reader.close();

socket.close();

server.close();

}

}

服务端从Socket的InputStream中读取数据的操作也是阻塞式的，如果从输入流中没有读取到数据程序会一直在那里不动，直到客户端往Socket的输出流中写入了数据，或关闭了Socket的输出流。当然，对于客户端的Socket也是同样如此。在操作完以后，整个程序结束前记得关闭对应的资源，即关闭对应的IO流和Socket。

客户端代码

Java代码

public class Client {

public static void main(String args[]) throws Exception {

//为了简单起见，所有的异常都直接往外抛

String host = "127.0.0.1"; //要连接的服务端IP地址

int port = 8899; //要连接的服务端对应的监听端口

//与服务端建立连接

Socket client = new Socket(host, port);

//建立连接后就可以往服务端写数据了

Writer writer = new OutputStreamWriter(client.getOutputStream() );

writer.write("Hello Server.");

writer.flush();//写完后要记得flush

writer.close();

client.close();

}

}

对于客户端往Socket的输出流里面写数据传递给服务端要注意一点，如果写操作之后程序不是对应着输出流的关闭，而是进行其他阻塞式的操作（比如从输入流里面读数据），记住要flush一下，只有这样服务端才能收到客户端发送的数据，否则可能会引起两边无限的互相等待。在稍后讲到客户端和服务端同时读和写的时候会说到这个问题。

2、客户端和服务端同时读和写

前面已经说了Socket之间是双向通信的，它既可以接收数据，同时也可以发送数据。

服务端代码

Java代码

public class Server {

public static void main(String args[]) throws IOException { //为了简单起见，所有的异常信息都往外抛

int port = 8899;

//定义一个ServerSocket监听在端口8899上

ServerSocket server = new ServerSocket(port);

//server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的

Socket socket = server.accept();

//跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。

Reader reader = new InputStreamReader(socket.getInputStream());

char chars[] = new char[64];

int len;

StringBuilder sb = new StringBuilder();

while ((len=reader.read(chars)) != -1) {

sb.append(new String(chars, 0, len));

}

System.out.println("from client: " + sb);

//读完后写一句

Writer writer = new OutputStreamWriter(socket.getOutputStream() );

writer.write("Hello Client.");

writer.flush();

writer.close();

reader.close();

socket.close();

server.close();

}

}

在上述代码中首先我们从输入流中读取客户端发送过来的数据，接下来我们再往输出流里面写入数据给客户端，接下来关闭对应的资源文件。而实际上上述代码可能并不会按照我们预先设想的方式运行，因为从输入流中读取数据是一个阻塞式操作，在上述的while循环中当读到数据的时候就会执行循环体，否则就会阻塞，这样后面的写操作就永远都执行不了了。除非客户端对应的Socket关闭了阻塞才会停止，while循环也会跳出。针对这种可能永远无法执行下去的情况的解决方法是while循环需要在里面有条件的跳出来，纵观上述代码，在不断变化的也只有取到的长度len和读到的数据了，len已经是不能用的了，唯一能用的就是读到的数据了。针对这种情况，通常我们都会约定一个结束标记，当客户端发送过来的数据包含某个结束标记时就说明当前的数据已经发送完毕了，这个时候我们就可以进行循环的跳出了。那么改进后的代码会是这个样子：

Java代码

public class Server {

public static void main(String args[]) throws IOException { //为了简单起见，所有的异常信息都往外抛

int port = 8899;

//定义一个ServerSocket监听在端口8899上

ServerSocket server = new ServerSocket(port);

//server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的

Socket socket = server.accept();

//跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。

Reader reader = new InputStreamReader(socket.getInputStream());

char chars[] = new char[64];

int len;

StringBuilder sb = new StringBuilder();

String temp;

int index;

while ((len=reader.read(chars)) != -1) {

temp = new String(chars, 0, len);

if ((index = temp.indexOf("eof")) != -1) {//遇到eof时

就结束接收

sb.append(temp.substring(0, index));

break;

}

sb.append(temp);

}

System.out.println("from client: " + sb);

//读完后写一句

Writer writer = new OutputStreamWriter(socket.getOutputStream() );

writer.write("Hello Client.");

writer.flush();

writer.close();

reader.close();

socket.close();

server.close();

}

}

在上述代码中，当服务端读取到客户端发送的结束标记，即“eof”时就会结束数据的接收，终止循环，这样后续的代码又可以继续进行了。

客户端代码

Java代码

public class Client {

public static void main(String args[]) throws Exception {

//为了简单起见，所有的异常都直接往外抛

String host = "127.0.0.1"; //要连接的服务端IP地址

int port = 8899; //要连接的服务端对应的监听端口

//与服务端建立连接

Socket client = new Socket(host, port);

//建立连接后就可以往服务端写数据了

Writer writer = new OutputStreamWriter(client.getOutputStream());

writer.write("Hello Server.");

writer.flush();

//写完以后进行读操作

Reader reader = new InputStreamReader(client.getInputStream());

char chars[] = new char[64];

int len;

StringBuffer sb = new StringBuffer();

while ((len=reader.read(chars)) != -1) {

sb.append(new String(chars, 0, len));

}

System.out.println("from server: " + sb);

writer.close();

reader.close();

client.close();

}

}

在上述代码中我们先是给服务端发送了一段数据，之后读取服务端返回来的数据，跟之前的服务端一样在读的过程中有可能导致程序一直挂在那里，永远跳不出while循环。这段代码配合服务端的第一段代码就正好让我们分析服务端永远在那里接收数据，永远跳不出while

循环，也就没有之后的服务端返回数据给客户端，客户端也就不可能接收到服务端返回的数据。解决方法如服务端第二段代码所示，在客户端发送数据完毕后，往输出流里面写入结束标记告诉服务端数据已经发送完毕了，同样服务端返回数据完毕后也发一个标记告诉客户端。那么修改后的客户端代码就应该是这个样子：

Java代码

public class Client {

public static void main(String args[]) throws Exception {

//为了简单起见，所有的异常都直接往外抛

String host = "127.0.0.1"; //要连接的服务端IP地址

int port = 8899; //要连接的服务端对应的监听端口

//与服务端建立连接

Socket client = new Socket(host, port);

//建立连接后就可以往服务端写数据了

Writer writer = new OutputStreamWriter(client.getOutputStream());

writer.write("Hello Server.");

writer.write("eof");

writer.flush();

//写完以后进行读操作

Reader reader = new InputStreamReader(client.getInputStream());

char chars[] = new char[64];

int len;

StringBuffer sb = new StringBuffer();

String temp;

int index;

while ((len=reader.read(chars)) != -1) {

temp = new String(chars, 0, len);

if ((index = temp.indexOf("eof")) != -1) {

sb.append(temp.substring(0, index));

break;

}

sb.append(new String(chars, 0, len));

}

System.out.println("from server: " + sb);

writer.close();

reader.close();

client.close();

}

}

我们日常使用的比较多的都是这种客户端发送数据给服务端，服务端接收数据后再返回相应的结果给客户端这种形式。只是客户端和服务端之间不再是这种一对一的关系，而是下面要讲到的多个客户端对应同一个服务端的情况。

3、多个客户端连接同一个服务端

像前面讲的两个例子都是服务端接收一个客户端的请求之后就结束了，不能再接收其他客户端的请求了，这往往是不能满足我们的要求的。通常我们会这样做：

Java代码

public class Server {

public static void main(String args[]) throws IOException { //为了简单起见，所有的异常信息都往外抛

int port = 8899;

//定义一个ServerSocket监听在端口8899上

ServerSocket server = new ServerSocket(port);

while (true) {

//server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的

Socket socket = server.accept();

//跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。

Reader reader = new InputStreamReader(socket.getInputStream() );

char chars[] = new char[64];

int len;

StringBuilder sb = new StringBuilder();

String temp;

int index;

while ((len=reader.read(chars)) != -1) {

temp = new String(chars, 0, len);

if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收

sb.append(temp.substring(0, index));

break;

}

sb.append(temp);

}

System.out.println("from client: " + sb);

//读完后写一句

Writer writer = new OutputStreamWriter(socket.getOutputStream ());

writer.write("Hello Client.");

writer.flush();

writer.close();

reader.close();

socket.close();

}

}

}

在上面代码中我们用了一个死循环，在循环体里面ServerSocket调用其accept方法试图接收来自客户端的连接请求。当没有接收到请求的时候，程序会在这里阻塞直到接收到来自客户端的连接请求，之后会跟当前建立好连接的客户端进行通信，完了后会接着执行循环体再次尝试接收新的连接请求。这样我们的ServerSocket就能接收来自所有客户端的连接请求了，并且与它们进行通信了。这就实现了一个简单的一个服务端与多个客户端进行通信的模式。

上述例子中虽然实现了一个服务端跟多个客户端进行通信，但是还存在一个问题。在上述例子中，我们的服务端处理客户端的连接请求是同步进行的，每次接收到来自客户端的连接请求后，都要先跟当前的客户端通信完之后才能再处理下一个连接请求。这在并发比较多的情况下会严重影响程序的性能，为此，我们可以把它改为如下这种异步处理与客户端通信的方式：

Java代码

public class Server {

public static void main(String args[]) throws IOException { //为了简单起见，所有的异常信息都往外抛

int port = 8899;

//定义一个ServerSocket监听在端口8899上

ServerSocket server = new ServerSocket(port);

while (true) {

//server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的

Socket socket = server.accept();

//每接收到一个Socket就建立一个新的线程来处理它

new Thread(new Task(socket)).start();

}

}

/**

* 用来处理Socket请求的

*/

static class Task implements Runnable {

private Socket socket;

public Task(Socket socket) {

this.socket = socket;

}

public void run() {

try {

handleSocket();

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 跟客户端Socket进行通信

* @throws Exception

*/

private void handleSocket() throws Exception {

Reader reader = new InputStreamReader(socket.getInputStre am());

char chars[] = new char[64];

int len;

StringBuilder sb = new StringBuilder();

String temp;

int index;

while ((len=reader.read(chars)) != -1) {

temp = new String(chars, 0, len);

if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收

sb.append(temp.substring(0, index));

break;

}

sb.append(temp);

}

System.out.println("from client: " + sb);

//读完后写一句

Writer writer = new OutputStreamWriter(socket.getOutputStream ());

writer.write("Hello Client.");

writer.flush();

writer.close();

reader.close();

socket.close();

}

}

}

在上面代码中，每次ServerSocket接收到一个新的Socket连接请求后都会新起一个线程来跟当前Socket进行通信，这样就达到了异步处理与客户端Socket进行通信的情况。

在从Socket的InputStream中接收数据时，像上面那样一点点的读就太复杂了，有时候我们就会换成使用BufferedReader来一次读一行，如：

Java代码

public class Server {

public static void main(String args[]) throws IOException { //为了简单起见，所有的异常信息都往外抛

int port = 8899;

//定义一个ServerSocket监听在端口8899上

ServerSocket server = new ServerSocket(port);

while (true) {

//server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的

Socket socket = server.accept();

//每接收到一个Socket就建立一个新的线程来处理它

new Thread(new Task(socket)).start();

}

}

/**

* 用来处理Socket请求的

*/

static class Task implements Runnable {

private Socket socket;

public Task(Socket socket) {

this.socket = socket;

}

public void run() {

try {

handleSocket();

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 跟客户端Socket进行通信

* @throws Exception

*/

private void handleSocket() throws Exception {

BufferedReader br = new BufferedReader(new InputStreamRe ader(socket.getInputStream()));

StringBuilder sb = new StringBuilder();

String temp;

int index;

while ((temp=br.readLine()) != null) {

System.out.println(temp);

if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收

sb.append(temp.substring(0, index));

break;

}

sb.append(temp);

}

System.out.println("from client: " + sb);

//读完后写一句

Writer writer = new OutputStreamWriter(socket.getOutputStream ());

writer.write("Hello Client.");

writer.write("eof\n");

writer.flush();

writer.close();

br.close();

socket.close();

}

}

}

这个时候需要注意的是，BufferedReader的readLine方法是一次读一行的，这个方法是阻塞的，直到它读到了一行数据为止程序才会继续往下执行，那么readLine什么时候才会读到一行呢？直到程序遇到了换行符或者是对应流的结束符readLine方法才会认为读到了一行，才会结束其阻塞，让程序继续往下执行。所以我们在使用BufferedReader的readLine 读取数据的时候一定要记得在对应的输出流里面一定要写入换行符（流结束之后会自动标记为结束，readLine可以识别），写入换行符之后一定记得如果输出流不是马上关闭的情况下记得flush一下，这样数据才会真正的从缓冲区里面写入。对应上面的代码我们的客户端程序应该这样写：

Java代码

public class Client {

public static void main(String args[]) throws Exception {

//为了简单起见，所有的异常都直接往外抛

String host = "127.0.0.1"; //要连接的服务端IP地址

int port = 8899; //要连接的服务端对应的监听端口

//与服务端建立连接

Socket client = new Socket(host, port);

//建立连接后就可以往服务端写数据了

Writer writer = new OutputStreamWriter(client.getOutputStream());

writer.write("Hello Server.");

writer.write("eof\n");

writer.flush();

//写完以后进行读操作

BufferedReader br = new BufferedReader(new InputStreamReader(cli ent.getInputStream()));

StringBuffer sb = new StringBuffer();

String temp;

int index;

while ((temp=br.readLine()) != null) {

if ((index = temp.indexOf("eof")) != -1) {

sb.append(temp.substring(0, index));

break;

}

sb.append(temp);

}

System.out.println("from server: " + sb);

writer.close();

br.close();

client.close();

}

}

4、设置超时时间

假设有这样一种需求，我们的客户端需要通过Socket从服务端获取到XX信息，然后给用户展示在页面上。我们知道Socket在读数据的时候是阻塞式的，如果没有读到数据程序会一直阻塞在那里。在同步请求的时候我们肯定是不能允许这样的情况发生的，这就需要我们在请求达到一定的时间后控制阻塞的中断，让程序得以继续运行。Socket为我们提供了一个setSoTimeout()方法来设置接收数据的超时时间，单位是毫秒。当设置的超时时间大于0，并且超过了这一时间Socket还没有接收到返回的数据的话，Socket就会抛出一个SocketTimeoutException。

假设我们需要控制我们的客户端在开始读取数据10秒后还没有读到数据就中断阻塞的话我们可以这样做：

Java代码

public class Client {

public static void main(String args[]) throws Exception {

//为了简单起见，所有的异常都直接往外抛

String host = "127.0.0.1"; //要连接的服务端IP地址

int port = 8899; //要连接的服务端对应的监听端口

//与服务端建立连接

Socket client = new Socket(host, port);

//建立连接后就可以往服务端写数据了

Writer writer = new OutputStreamWriter(client.getOutputStream());

writer.write("Hello Server.");

writer.write("eof\n");

writer.flush();

//写完以后进行读操作

BufferedReader br = new BufferedReader(new InputStreamReader(cli ent.getInputStream()));

//设置超时间为10秒

client.setSoTimeout(10*1000);

StringBuffer sb = new StringBuffer();

String temp;

int index;

try {

while ((temp=br.readLine()) != null) {

if ((index = temp.indexOf("eof")) != -1) {

sb.append(temp.substring(0, index));

break;

}

sb.append(temp);

}

} catch (SocketTimeoutException e) {

System.out.println("数据读取超时。");

}

System.out.println("from server: " + sb);

writer.close();

br.close();

client.close();

}

}

5、接收数据乱码

对于这种服务端或客户端接收中文乱码的情况通常是因为数据发送时使用的编码跟接收时候使用的编码不一致。比如有下面这样一段服务端代码：

Java代码

public class Server {

public static void main(String args[]) throws IOException { //为了简单起见，所有的异常信息都往外抛

int port = 8899;

//定义一个ServerSocket监听在端口8899上

ServerSocket server = new ServerSocket(port);

while (true) {

//server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的

Socket socket = server.accept();

//每接收到一个Socket就建立一个新的线程来处理它

new Thread(new Task(socket)).start();

}

}

/**

* 用来处理Socket请求的

*/

static class Task implements Runnable {

private Socket socket;

public Task(Socket socket) {

this.socket = socket;

}

public void run() {

try {

handleSocket();

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 跟客户端Socket进行通信

* @throws Exception

*/

private void handleSocket() throws Exception {

BufferedReader br = new BufferedReader(new InputStreamRe ader(socket.getInputStream(), "GBK"));

StringBuilder sb = new StringBuilder();

String temp;

int index;

while ((temp=br.readLine()) != null) {

System.out.println(temp);

if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收

sb.append(temp.substring(0, index));

break;

}

sb.append(temp);

}

System.out.println("客户端: " + sb);

//读完后写一句

Writer writer = new OutputStreamWriter(socket.getOutputStream (), "UTF-8");

writer.write("你好，客户端。");

writer.write("eof\n");

writer.flush();

writer.close();

br.close();

socket.close();

}

}

}

这里用来测试我就弄的混乱了一点。在上面服务端代码中我们在定义输入流的时候明确定义了使用GBK编码来读取数据，而在定义输出流的时候明确指定了将使用UTF-8编码来发送数据。如果客户端上送数据的时候不以GBK编码来发送的话服务端接收的数据就很有可能会乱码；同样如果客户端接收数据的时候不以服务端发送数据的编码，即UTF-8编码来接收数据的话也极有可能会出现数据乱码的情况。所以，对于上述服务端代码，为使我们的程序能够读取对方发送过来的数据，而不出现乱码情况，我们的客户端应该是这样的：

Java代码

public class Client {

public static void main(String args[]) throws Exception {

//为了简单起见，所有的异常都直接往外抛

String host = "127.0.0.1"; //要连接的服务端IP地址

int port = 8899; //要连接的服务端对应的监听端口

//与服务端建立连接

Socket client = new Socket(host, port);

//建立连接后就可以往服务端写数据了

Writer writer = new OutputStreamWriter(client.getOutputStream(), "GBK");

writer.write("你好，服务端。");

writer.write("eof\n");

writer.flush();

//写完以后进行读操作

BufferedReader br = new BufferedReader(new InputStreamReader(cli ent.getInputStream(), "UTF-8"));

//设置超时间为10秒

client.setSoTimeout(10*1000);

StringBuffer sb = new StringBuffer();

String temp;

int index;

try {

while ((temp=br.readLine()) != null) {

if ((index = temp.indexOf("eof")) != -1) {

sb.append(temp.substring(0, index));

break;

}

sb.append(temp);

}

} catch (SocketTimeoutException e) {

System.out.println("数据读取超时。");

}

System.out.println("服务端: " + sb);

writer.close();

br.close();

client.close();

}

}

3.排序

日常操作中常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。

冒泡排序

是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

代码

/**

* 冒泡法排序

*

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

*

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

*

针对所有的元素重复以上的步骤，除了最后一个。

*

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

*

* @param numbers

* 需要排序的整型数组

*/

public static void bubbleSort(int[] numbers) {

int temp; // 记录临时中间值

int size = numbers.length; // 数组大小

for (int i = 0; i < size - 1; i++) {

for (int j = i + 1; j < size; j++) {

if (numbers[i] < numbers[j]) { // 交换两数的位置

temp = numbers[i];

numbers[i] = numbers[j];

numbers[j] = temp;

}

}

}

}

快速排序

使用分治法策略来把一个序列分为两个子序列。

代码

/**

* 快速排序

*

*

• 从数列中挑出一个元素，称为“基准”

*

• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，

  * 该基准是它的最后位置。这个称为分割（partition）操作。

*

• 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

*

*

* @param numbers

* @param start

* @param end

*/

public static void quickSort(int[] numbers, int start, int end) {

if (start < end) {

int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）

int temp; // 记录临时中间值

int i = start, j = end;

do {

while ((numbers[i] < base) && (i < end))

i++;

while ((numbers[j] > base) && (j > start))

j--;

if (i <= j) {

temp = numbers[i];

numbers[i] = numbers[j];

numbers[j] = temp;

i++;

j--;

}

} while (i <= j);

if (start < j)

quickSort(numbers, start, j);

if (end > i)

quickSort(numbers, i, end);

}

}

选择排序

是一种简单直观的排序方法，每次寻找序列中的最小值，然后放在最末尾的位置。

代码

/**

* 选择排序

*

在未排序序列中找到最小元素，存放到排序序列的起始位置

*

再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。

*

以此类推，直到所有元素均排序完毕。

*

* @param numbers

*/

public static void selectSort(int[] numbers) {

int size = numbers.length, temp;

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

int k = i;

for (int j = size - 1; j >i; j--) {

if (numbers[j] < numbers[k]) k = j;

}

temp = numbers[i];

numbers[i] = numbers[k];

numbers[k] = temp;

}

}

插入排序

的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。其具体步骤参见代码及注释。

代码

/**

* 插入排序

*

*

• 从第一个元素开始，该元素可以认为已经被排序

*

• 取出下一个元素，在已经排序的元素序列中从后向前扫描

*

• 如果该元素（已排序）大于新元素，将该元素移到下一位置

*

• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

*

• 将新元素插入到该位置中

*

• 重复步骤2

*

*

* @param numbers

*/

public static void insertSort(int[] numbers) {

int size = numbers.length, temp, j;

for(int i=1; i

temp = numbers[i];

for(j = i; j > 0 && temp < numbers[j-1]; j--)

numbers[j] = numbers[j-1];

numbers[j] = temp;

}

}

归并排序

是建立在归并操作上的一种有效的排序算法，归并是指将两个已经排序的序列合并成一个序列的操作。参考代码如下：

代码

/**

* 归并排序

*

*

• 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
*
• 设定两个指针，最初位置分别为两个已经排序序列的起始位置

*

• 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

*

• 重复步骤3直到某一指针达到序列尾

*

• 将另一序列剩下的所有元素直接复制到合并序列尾

*

*

* @param numbers

*/

public static void mergeSort(int[] numbers, int left, int right) {

int t = 1;// 每组元素个数

int size = right - left + 1;

while (t < size) {

int s = t;// 本次循环每组元素个数

t = 2 * s;

int i = left;

while (i + (t - 1) < size) {

merge(numbers, i, i + (s - 1), i + (t - 1));

i += t;

}

if (i + (s - 1) < right)

merge(numbers, i, i + (s - 1), right);

}

}

/**

* 归并算法实现

*

* @param data

* @param p

* @param q

* @param r

*/

private static void merge(int[] data, int p, int q, int r) {

int[] B = new int[data.length];

int s = p;

int t = q + 1;

int k = p;

while (s <= q && t <= r) {

if (data[s] <= data[t]) {

B[k] = data[s];

s++;

} else {

B[k] = data[t];

t++;

}

k++;

}

if (s == q + 1)

B[k++] = data[t++];

else

B[k++] = data[s++];

for (int i = p; i <= r; i++)

data[i] = B[i];

}

将之前介绍的所有排序算法整理成NumberSort类，代码

代码

package test.sort;

import java.util.Random;

//Java实现的排序类

public class NumberSort {

//私有构造方法，禁止实例化

private NumberSort() {

super();

}

//冒泡法排序

public static void bubbleSort(int[] numbers) {

int temp; // 记录临时中间值

int size = numbers.length; // 数组大小

for (int i = 0; i < size - 1; i++) {

for (int j = i + 1; j < size; j++) {

if (numbers[i] < numbers[j]) { // 交换两数的位置

temp = numbers[i];

numbers[i] = numbers[j];

numbers[j] = temp;

}

}

}

}

//快速排序

public static void quickSort(int[] numbers, int start, int end) {

if (start < end) {

int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）

int temp; // 记录临时中间值

int i = start, j = end;

do {

while ((numbers[i] < base) && (i < end))

i++;

while ((numbers[j] > base) && (j > start))

j--;

if (i <= j) {

temp = numbers[i];

numbers[i] = numbers[j];

numbers[j] = temp;

i++;

j--;

}

} while (i <= j);

if (start < j)

quickSort(numbers, start, j);

if (end > i)

quickSort(numbers, i, end);

}

}

//选择排序

public static void selectSort(int[] numbers) {

int size = numbers.length, temp;

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

int k = i;

for (int j = size - 1; j > i; j--) {

if (numbers[j] < numbers[k])

k = j;

}

temp = numbers[i];

numbers[i] = numbers[k];

numbers[k] = temp;

}

}

//插入排序

// @param numbers

public static void insertSort(int[] numbers) {

int size = numbers.length, temp, j;

for (int i = 1; i < size; i++) {

temp = numbers[i];

for (j = i; j > 0 && temp < numbers[j - 1]; j--)

numbers[j] = numbers[j - 1];

numbers[j] = temp;

}

}

//归并排序

public static void mergeSort(int[] numbers, int left, int right) { int t = 1;// 每组元素个数

int size = right - left + 1;

while (t < size) {

int s = t;// 本次循环每组元素个数

t = 2 * s;

int i = left;

while (i + (t - 1) < size) {

merge(numbers, i, i + (s - 1), i + (t - 1));

i += t;

}

if (i + (s - 1) < right)

merge(numbers, i, i + (s - 1), right);

}

}

//归并算法实现

private static void merge(int[] data, int p, int q, int r) { int[] B = new int[data.length];

int s = p;

int t = q + 1;

int k = p;

while (s <= q && t <= r) {

if (data[s] <= data[t]) {

B[k] = data[s];

s++;

} else {

B[k] = data[t];

t++;

}

k++;

}

if (s == q + 1)

B[k++] = data[t++];

else

B[k++] = data[s++];

for (int i = p; i <= r; i++)

data[i] = B[i];

}

}