Java 快速入门练习

第5章实验–数组

5.1实验目标

(1)理解在Java中如何声明、分配和使用（多维）数组

(2)学习数组排序和查找的基本算法

(3)了解JA V A Reflection API 和其他常用类

5.2实验说明

本章实验教程将介绍数组（array）的使用，学习Java数组相关的类Array和Arrays。简单介绍Java反射（Reflection）的用法。

以下的实验包括4种类型，每种类型都用括号里面的字母表示：

D - 例程，表示这是一个例子, 要求练习者阅读指南和代码;

I - 交互式练习, 练习者完成实验指定的简单任务，如修改部分代码, 观察程序运行时的变化等;

W - 热身练习，练习者的编程工作量逐渐加大。

P - 完整编程，要求练习者根据要求，完成完整的JA V A程序。

5.3实验准备

从本实验教程光盘中拷贝Lab05文件目录到本地磁盘, 如D: 盘。Lab05文件目录中将包含本次实验所需的所有资料。Lab05的相关资料也可以从本实验教程的网站下载：http://javaLab/lab05.zip

将Lab04中的MathUtility.java（程序清单4-6）程序拷贝到Lab05目录下。

5.4实验任务

实验5.4.1: (D)数组的基本概念

Java变量（variable）可以存储程序的数据，每个变量有标识、类型和作用域。使用同种类型和作用域的多个数据时，我们通常把这些数据存放在一个数据结构而不是单个的变量中。最常见的数据结构是数组（array）。一个数组中能够存储的数据个数是固定的，并且存放的数据类型相同。尽管数组是一个对象，但是数组的用法与基本数据类型相似。

图5.1可以帮助我们理解数组的结构。

图5.1 长度为8的数组

这是一个有8个元素的数组，数组中的每个元素有各自的值。图中每个元素上方的数字表明了元素的索引（index）。数组中的元素总是使用索引引用的。第一个元素的索引总是为0。重复，第一个元素的索引总是为0，而最后一个元素的索引总是“数组长度-1”。上图的数组中，最后一个元素的索引是8-1 = 7。

我们可以创建任何数据类型的数组。下面来看一个整型数组的例子。

编译并运行ExamScoresl.java，输入0到100之间的一组整数为命令行参数。假设输入的这组整数就是考试成绩，这个程序将显示原始成绩和调整后的成绩。成绩调整的规则是：将最高成绩上调到100分，计算调整的幅度，再根据幅度相应调整其他成绩。

程序清单5-1：ExamScores1.java

// Given a sequence of exam scores as

// command-line arguments, displays table

// of exam scores and curved scores.

public class ExamScores1 {

public static void main(String[] commandLineArgs)

{

if ( commandLineArgs.length == 0 ) {

System.out.print("Given a sequence of exam scores ");

System.out.println("entered as command line arguments,");

System.out.print("this program will curve them up ");

System.out.println("by raising the highest to 100 and ");

System.out.println("raising all others by the same amount.");

System.exit(0);

} // if no command-line arguments

// Named constant for width of displayed columns:

final int columnWidth = 5;

// Named constant for the number of scores:

final int numberOfScores = commandLineArgs.length;

// Declare reference to array

// which will store exam scores:

int[] scores;

// Instantiate (create) the array itself,

// i.e. allocate space to store the exam scores:

scores = new int[numberOfScores];

// Read scores into array and determine maximum:

int maximumScore = 0;

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

scores[i] = Integer.parseInt(commandLineArgs[i]);

maximumScore = Math.max(maximumScore, scores[i]);

} // for i

// Determine how many points to curve up all scores:

int curveUp = 100 - maximumScore;

// Output table of original scores and curved scores

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

// Print original score in a right-justified column:

String scoreText = Integer.toString(scores[i]);

for ( int j = scoreText.length(); j < columnWidth; j++ )

System.out.print(" ");

System.out.print(scoreText);

// Calculate curved score;

int curvedScore = scores[i] + curveUp;

// Print curved score in a right-justified column;

String curvedScoreText = Integer.toString(curvedScore);

for ( int k = curvedScoreText.length(); k < columnWidth; k++ )

System.out.print(" ");

System.out.println(curvedScoreText);

} // for i

} // method main(String[])

} // class ExamScores1

大家可能已经发现，ExamScoresl.java源代码中main方法的命令行参数数组的名字与惯常不同，这里使用了commandLineArgs。其实使用什么名字作为命令行参数的数组名并没有关系，只要这个名字在整个main方法中保持一致就行。在一个具体的程序中，我们通常把命令行参数数组取名为args，把命令行参数个数的变量取名为argv，命令行参数数组是一个字符串数组。

ExamScoresl.java程序中需要跟踪所有的成绩，因此将考试成绩存放在一个int型数组中。创建数组的三个步骤是：（1）声明一个数组引用变量；（2）实例化（创建）数组本身，也就是为数组分配内存空间；（3）初始化数组中的每个变量。

1.数组的声明

数组变量的声明和其他Java变量的声明类似，声明数组的语法模板：

DataType ArrayName [ConstIntExpression];

或

DataType [ConstIntExpression] ArrayName;

DataType是数据类型，即数组中元素的数据类型；ArrayName是合法的变量；[ ]符号中的ConsIntExpression指明数组的大小，即数组中元素的个数。

程序ExamScoresl.java中，声明int数组变量：

int [] scores;

另外一种声明数组的方式：

int scores[];

这两种数组声明方式在语法上都是正确的，都能被编译器接受。编者个人喜欢第一种（int[] scores）声明方式，因为它更清晰地说明了数组变量的名字是scores，而不是scores[]；scores被声明为一个指向整型数组的指针。然而，更普遍使用的是第二种方式，尤其在Java官方文档中更为明显，因为这种方式与C++中的声明方式比较接近。

2.实例化数组

实例化scores数组的语句如下：

scores = new int[numberOfScores];

实例化数组，即为数组元素分配内存空间，是通过new操作符实现的。new操作符后是数据类型以及元素个数。元素个数放在[]运算符中。下面是一些例子：

counts = new int[5];

names = new String[100];

3.数组元素的初始化

将scores数组中的元素在循环中初始化的语句如下：

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

scores[i] = Integer.parseInt(commandLineArgs[i]);

scores.length是数组元素的个数，就象commandLineArgs.length是数组commandLineArgs的元素个数一样。数组元素的范围从0到length - 1。

4.数组声明、实例化和初始化的更多解释

声明和实例化数组的常见形式如下例所示：

int[] scores;

scores = new int[numberOfScores];

声明和实例化数组可以合并成一个语句：

int[] scores = new int[numberOfScores];

还可以定义初始化列表(Initializer List)来初始化数组元素：

int[] numbers = {4, 3, 2, 1};

String[] name = {"Zhang", "Wang", "Li"};

数组的长度是由{}中的元素个数隐含定义的，numbers数组的长度为4，name数组的长度为3。当

数组的声明和创建分开时，仍然可以使用初始化列表，只是这种方式不太简练：int[] numbers;

numbers = new int[]{4, 3, 2, 1};

再次强调一下，数组变量是一个内存位置的名字，这个内存位置存储的不是数组本身，而是数组在内存中存放的地址。因此，数组变量存放了一个指向数组的指针。当数组变量第一次声明时，它并没有真正指向一个数组。数组声明只是开辟一个存放指针的空间。之后，当使用关键字new实例化数组并将其指定给一个数组变量时，该数组变量就存放了一个指向数组的指针。

范例5-1程序的顶端有这样一个声明：

final int columnWidth = 5;

这个声明看上去象一个变量的声明，不同的是在最前面有一个关键字final。关键字final意味着columnWidth被声明为一个常量。常量的值在第一次初始化之后就不能改变。

为什么要费心去定义常量，而不在代码中直接使用常量的值呢？原因在于方便程序员修改程序，程序员只需查看代码顶端并修改常量的值，而不需要修改该常量的值出现的每行代码。

实验5.4.2: (I)访问数组元素

引用数组中的元素，使用[ ] 操作符。范例5-1中，访问scores数组元素：

int score = scores[0]; // 得到第一个元素

int score = scores[3]; // 得到第四个元素

[ ]中的索引可以是整数，或者整型变量。索引的取值范围在0到数组元素个数-1之间。数组变量与数组中索引变量的区别在于，数组变量代表整个数组，数组中的索引变量代表了数组中的元素在数组中的位置。

通常我们会使用for循环语句来操作数组元素，见范例5-2。

程序清单5-2：AccessArrayWithForLoop.java

public class AccessArrayWithForLoop {

public static void main(String[] args) {

String[] months = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",

"July", "Aug", "Sep", "Oct", "Nov", "Dec"};

int[] sizes = {31,28,31,30,31,30,31,31,30,31,30,31};

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

System.out.println(months[i] + " has " + sizes[i] + " days.");

}

}

}

注意for循环中的变量i，i的取值在0到months.length-1之间。试着把源代码

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

改成：

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

重新编译、运行程序。回答下面的问题：

代码可以正常编译吗？为什么？

___________________________________________________________

程序可以正常执行吗？为什么？

___________________________________________________________

实验5.4.3: (I)查找最大数

GreatestNumber.java（范例5-3）将对话框输入的3个数字保存在数组中，计算出其中的最大值。

程序清单5-3：GreatestNumber.java

import javax.swing.JOptionPane;

public class GreatestNumber {

public static void main(String[] args) {

int[] num = new int[10];

int counter;

int max = 0;

int totalnumber = 3;

// Prompt a user to enter numbers

for(counter = 0; counter < totalnumber; counter++) {

num[counter] = Integer.parseInt ( JOptionPane.showInputDialog (

"Enter numbers until " + totalnumber + " numbers are entered"));

// Compute the greatest number up to this point

if((counter == 0)||(num[counter] > max))

max = num[counter];

}

// Display the greatest number.

JOptionPane.showMessageDialog(null,

"The number with the greatest value is " + max);

}

}

现在，参照GreatestNumber.java写一个新的程序SmallestNumber.java, 找出3个数中的最小值。实验5.4.4: (W)练习使用数组

写一个类似于ExamScores1.java的程序ExamScores2.java，从命令行参数输入学生成绩，没有输入命令行参数时，程序会显示提示信息。要求程序输出成绩列表，以及成绩的最高分和最低分。程序

中不使用Math类的max和min方法。

实验5.4.5: (P)用数组实现斐波纳契函数

编写程序FibonacciArray.java，用数组实现斐波纳契函数。由键盘读入n值（参见实验1.4.15）。程序将在控制台输出此斐波纳契序列f(0)，f(1)，…… f(n)。

斐波纳契序列的定义如下：

如果n = 0 或者n = 1 , 则f(n) = 1

如果n是一个整数并且n > 1 , 则f(n)= f(n-1) + f(n-2)

实验5.4.6: (I)字符串和字符数组

在Java库文件中查看String类的toCharArray方法。我们提到过String包含一串字符，更准确地讲，包含了一个字符数组以及操作这些字符的大量方法。

String类的toCharArray方法将字符串转换为Character数组。toCharArray是一个实例方法还是类方法，查看Java文档，写下结果：

_______________________________________________________

范例5-3使用toCharArray方法实现字符串反转。

程序清单5-3：StringReverse.java

public class StringReverse {

public static void main(String[] args) {

System.out.println(reverse(args[0]));

}

public static String reverse( String inputString) {

if (inputString == null)

return null;

else {

char[] charArray = inputString.toCharArray(); //string to char array

for (int i = 0; i < charArray.length / 2; i++) {

char temp = charArray [i];

charArray [i] = charArray [charArray.length - i - 1];

charArray [charArray.length - i - 1] = temp;

}

String re = new String(charArray); //char array to string

return re;

}

} // method reverse

}

以上程序的算法如下图所示，程序进行1/2数组长度次的循环，每次调换头尾两个位置中的元素。在第一次循环中，先将位置0上的元素存放在temp变量，然后将位置9上的元素赋值到位置0，最后将temp中元素存入位置9。在第二次循环时，先将位置1上的元素存放在temp变量，然后将位置8上的元素赋值到位置1，最后将temp中元素存入位置8。依次类推，最后一次循环，将位置4和位置5中的元素交换。

图5.2 字符串反转算法描述

实验5.4.7: (I)传递数组参数

用简单类型数据做参数时，Java遵循值传递的原则。实质上，就是将参数值先拷贝一份，然后将拷贝传递给方法。因此，在方法内部修改参数对原来的变量没有影响（因为只是对拷贝的修改），而且，方法返回时，方法调用的空间回收，拷贝的参数空间也被收回。

Java中，不能把对象传递给方法，只能传递对象的引用（Reference，即对象的内存地址）。引用本身也是采用值调用。当一个方法接受对象的引用后，它就可以直接操纵对象。

尽管数组在语法上有别于其他一般意义上的对象，但数组被Java看作是对象。数组以引用调用的方式传递给方法，数组的引用变量包含一个指针，指向数组在存储器中的实际存储位置。

编译并运行程序ValueVsReference.java。

程序清单5-4：V alueVsReference.java

public class ValueVsReference {

public static void main(String[] args) {

short[] a = { 0, 2, 4, 6, 8 };

System.out.println("The values originally stored in the array are:");

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

System.out.print(" " + a[i]);

System.out.println();

System.out.println("Let's see how the values change.");

modifyPrimitive(a[0]);

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

System.out.print(" " + a[i]);

System.out.println(" Method tried to modify primitive element.");

modifyArray(a);

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

System.out.print(" " + a[i]);

System.out.println(" Method modified array.");

modifyArrayReference(a);

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

System.out.print(" " + a[i]);

System.out.println(" Method modified its own reference to array.");

} // method main

public static void modifyPrimitive(short p) {

p = 20;

} // method methodA

public static void modifyArray(short[] b) {

for ( int j = 0; j < b.length; j++ )

b[j] = (short) (j*(-3));

} // method modifyArray

public static void modifyArrayReference(short[] b) {

b = new short[5];

for ( int j = 0; j < b.length; j++ )

b[j] = (short) (j*3);

} // method modifyArrayReference

} // class ValueVsReference

范例5-4定义了main和其他三个方法modifyPrimitive,、modifyArray和modifyArrayReference。

(1)modifyPrimitive 方法修改参数p的值，p是short原始数据类型。因此，此方法的参数转递为值传递。main方法中调用modifyPrimitive方法，传递的实际参数是数组的一个元素a[0]，此元素的类型也是short原始数据类型。

(2)modifyArray方法的参数为数组引用变量b，而不是单独的某个数组元素。方法的头部定义如下：

public static void modifyArray(short[] b)

通过引用变量b，可以操纵b指向的数组对象。main方法中调用modifyArray方法，传递的实际参数是数组引用变量a，此时a和b的实际值都是一个指向同一数组对象的指针。modifyArray 方法中，对b引用的数组对象的修改，就是对a引用的数组对象的修改。方法调用完成后，变量b的空间被回收，a引用的数组对象被修改。

(3)modifyArrayReference 方法内，数组引用变量b 被重新赋值，指向一个新创建的数组：

b = new short[5];

main方法中调用modifyArrayReference方法，传递的实际参数是数组引用变量a。但由于上面的这个赋值语句，形式参数b指向了一个新的数组，而不再指向a引用的数组。对变量b引用

的数组对象的任何修改都不会改变变量a引用的数组对象。

现在，请写下程序执行后的结果，并认真思考为什么是这样的结果。

___________________________________________________________________________________ ___________________________________________________________________________________ ___________________________________________________________________________________ ___________________________________________________________________________________ 实验5.4.8: (W)写一个带有数组参数的方法

在MathUtility.java（见程序清单4-6）中，写一个静态方法average，此方法用一个双精度浮点数（double）数组作为参数，并返回此数组中元素的平均值。如果数组长度为0，方法返回值为0，并打印一个标准错误输出流消息。回顾如何定义一个指向double类型数组的指针，并在方法的参数列表中声明。

以如下方式定义average方法的方法头：

public static double average (double[] doubleArray)

运行AverageTest.java程序测试average方法。

程序清单5-5：AverageTest

public class AverageTest {

public static void main(String[] args) {

if (args.length == 0) {

System.out.println("This program will average any "

+ "number of precision floating-point ");

System.out.println("numbers entered as command-line "

+ "arguments. Result should be zero");

System.out.println("for no command-line arguments.");

} // if

double[] numbers = new double[args.length];

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

numbers[i] = new Double(args[i]).doubleValue();

System.out.println("The average is " + MathUtility.average(numbers) + ".");

} // method main

} // class AverageTest

实验5.4.9: (P)写一个返回值为数组的方法

一个方法如果没有返回值，则在该方法的前面用void关键字来修饰；如果返回值的类型为基本数据类型，只需在声明方法的前面加上相应的数据类型即可。同理，若方法需返回一个数组，则必须在该方法的前面加上数组类型的修饰符。例如，方法返回一个整形数组，则在该方法前加上int[ ]。

在MathUtility.java（见程序清单4-6）中，写一个power方法，计算一组数的指数。计算结果以数组的方式返回，这个方法应该有如下的方法头：

public static double[] power(float[] base, int exponent)

要求作为参数传递进来的数组不被改变。提示：在power方法内部，创建了一个新的数组并把base的内容拷贝到其中。然后对新数组进行操作，而不是修改旧的数组，旧的数组被完整地保留下来。

执行程序PowerTest4.java来测试该方法。

程序清单5-6：PowerTest4.java

public class PowerTest4 {

public static void main(String[] args) {

System.out.print("This program will raise the float ");

System.out.println("numbers in an array to an integer power.");

float[] basesToTest = { 1, 2, 3, 4};

testPower(basesToTest, 2);

testPower(basesToTest, 3);

testPower(basesToTest, -2);

testPower(basesToTest, 0);

} // method main(String[])

public static void testPower(float[] base, int exponent)

{

System.out.println();

System.out.print("Raising the numbers in ");

printArray(base);

System.out.println(" to the " + exponent + " power:");

double[] result = MathUtility.power(base, exponent);

System.out.print(" The numbers in ");

printArray(base);

System.out.println(" to the " + exponent + " power are:");

System.out.print(" ");

printArray(result);

} // method testPower

public static void printArray(double[] numbers) {

System.out.print("{");

if ( numbers.length > 0 )

System.out.print(" " + numbers[0]);

for ( int i = 1; i < numbers.length; i++ )

System.out.print(", " + numbers[i]);

System.out.print(" }");

} // method printArray(double[])

} // class PowerTest4

实验5.4.10: (P)简单的数组中的查找

在数组中查找某个元素，一种简单的方法是顺序查找法（Linear Search），即，从数组的第一个记录开始，逐个进行数组中元素和给定值的比较。

写一个LinearSearch.java程序查找一个字符串中包含多少个指定字符，这个字符串和指定字符由键盘输入。要求输出此字符串中指定字符的位置，及字符总数。

实验5.4.11: (D)多维数组

1.Java语言中，多维数组（Multi-dimensional arrays）被看作是数组的数组。

二维数组可以被想象成一个二维的表，表里的所有元素有统一的数据类型。

一个int类型的二维数组声明如下：

int a[ ][ ];

int[ ][ ] a;

二维数组的初始化有两种方式：静态初始化和动态初始化。

(1)静态初始化

a[ ][ ]={{1,2},{3,4},{5,6,7}};

图5.3 静态初始化一个二维数组a

Java语言中，不要求多维数组每一维的大小相同。

(2)动态初始化

int[ ][ ] b = new int[2][3]；

这种方式直接为每一维分配空间，因为是int类型数组，数组中的元素被初始化成0。

图5.4 动态初始化一个2行(rows)3列(columns)的二维数组b

下面的语句同样实现了数组的初始化:

int b[ ][ ] = new int[2][ ]；

b[0] = new int[3];

b[1] = new int[3];

二维数组元素的引用方式为：b[1][2] = 5;

图5.5二维数组元素的引用

2.编译、运行MultiDimArray.java程序，理解其中各种多维数组的创建：

程序清单5-7：MultiDimArray.java

import java.util.*;

public class MultiDimArray {

static Random rand = new Random();

static int pRand(int mod) {//产生1～mod之间的随机数

return Math.abs(rand.nextInt()) % mod + 1;

}

public static void main(String[] args) {

int[][] a1 = {//声明2维数组al，并初始化

{ 1, 2, 3, },

{ 4, 5, 6, },

};

for(int i = 0; i < a1.length; i++)//输出数组al

for(int j = 0; j < a1[i].length; j++)

prt("a1[" + i + "][" + j +"] = " + a1[i][j]);

// 声明三维数组a2，分配固定的空间:

int[][][] a2 = new int[2][2][4];

for(int i = 0; i < a2.length; i++)//输出a2中元素

for(int j = 0; j < a2[i].length; j++)

for(int k = 0; k < a2[i][j].length;

k++)

prt("a2[" + i + "][" +j + "][" + k +"] = " + a2[i][j][k]);

// 任意长度的三维数组:

int[][][] a3 = new int[pRand(7)][][];//指定第一维的大小为1～7的随机数

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

a3[i] = new int[pRand(5)][];//指定第二维大小

for(int j = 0; j < a3[i].length; j++)

a3[i][j] = new int[pRand(5)];//指定第三维大小

}

for(int i = 0; i < a3.length; i++)//输出a3中元素

for(int j = 0; j < a3[i].length; j++)

for(int k = 0; k < a3[i][j].length;

k++)

prt("a3[" + i + "][" +j + "][" + k +"] = " + a3[i][j][k]);

// 非基本类型的三维数组:

Integer[][] a4 = {

{ new Integer(1), new Integer(2)},

{ new Integer(3), new Integer(4)},

{ new Integer(5), new Integer(6)},

};

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

for(int j = 0; j < a4[i].length; j++)

prt("a4[" + i + "][" + j +"] = " + a4[i][j]);

Integer[][] a5;

a5 = new Integer[3][];

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

a5[i] = new Integer[3];

for(int j = 0; j < a5[i].length; j++)

a5[i][j] = new Integer(i*j);

}

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

for(int j = 0; j < a5[i].length; j++)

prt("a5[" + i + "][" + j +"] = " + a5[i][j]);

}

static void prt(String s) {

System.out.println(s);

}

}

实验5.4.12: (P)练习使用多维数组

写一个Matrix.java程序实现两个3×3的整数矩阵相乘，并将其结果打印到屏幕上，运算过程中要用到嵌套循环及+=这样的复合运算符号，并用“\t”调整输出的格式。

int[][] matrixA = { { 1, 0, 1 },

{ 1, 2, 3 },

{ 1, 4, 5 } };

int[][] matrixB = { { 5, 4, 0 },

{ 4, 8, 1 },

{ 1, 1, 0 } };

提示：在写程序之前，仔细分析矩阵相乘的原理，并将matrixA x matrixB的计算结果写在下面，便于纠正程序设计思路。

int[][] matrixAB =

实验5.4.13: (D)int数组的冒泡排序

在程序中，经常需要将数组中的数据排序。排序对象要能够相互比较，这是排序的前提。范例5-8是对int数组进行冒泡排序的示例。

冒泡排序的基本思想：

设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。

算法示例：以升序排列int数组{3，6，2，1，5，4，8，7}。依次比较相邻的两个数，将小数放在前面，大数放在后面。首先比较数组的倒数第1个和倒数第2个数，将小数放前，大数放后，即7放前，8放后；然后比较倒数第2个数和倒数第3个数，4放前，7放后；如此继续，4放前，5放后；1放前，4放后；1放前，2放后；1放前，6放后；1放前，3放后；此时第一轮结束，在最前面的数一定为所有数中的最小数。重复以上过程，仍从倒数第1个和倒数第2个数开始比较（因为可能由于倒数第2个数和倒数第3个数的交换，使得倒数第1个数不再大于倒数第2个数），将小数放前，大数放后，一直比较到最小数后的一对相邻数，将小数放前，大数放后，第二轮结束，在第二个数中得到一个新的最小数。如此下去，直至最终完成排序。

３１１１１１１１

６３２２２２２２

２６３３３３３３

１２６４４４４４

５４４６５５５５

４５５５６６６６

８７７７７７７７

７８８８８８８８

图5.7 冒泡排序（Bubble Sort）算法示例

程序清单5-8：Int BubbleSort.java

// IntBubbleSort.java

public class IntBubbleSort {

private int[] testArray={3,6,2,1,5,4,8,7};//声明并初始化数组

public static void main(String[] args) {

IntBubbleSort ibs = new IntBubbleSort();

for(int i=0;i

System.out.println(ibs.testArray[i]);

} // 输出原始的数组

ibs.sort();//调用排序方法

System.out.println("排序后的输出");

for(int i=0;i

System.out.println(ibs.testArray[i]);

}

}

public void sort(){

for(int i = 1;i < testArray.length; i++){

for(int j = testArray.length-1;j >= i; j--)

if(testArray[j] < testArray[j-1]) {

int temp = testArray[j-1];

testArray[j-1]= testArray[j];

testArray[j]= temp;

}

}

}

}

testArray是一个int数组引用变量，它是一个实例变量，其作用域为整个实例。testArray有一个private修饰符，表明这是一个私有变量，只能在类内部访问。

注意这里的sort方法，由于它不是静态方法，调用的形式为：

对象引用.方法(参数)

范例5-8中，首先调用构造方法创建了一个IntBubbleSort实例ibs：

IntBubbleSort ibs = new IntBubbleSort();

再由ibs调用sort方法：

ibs.sort(); //调用排序方法

冒泡算法是由双重for循环具体实现的，具体见sort方法中的代码。

实验5.4.14: (P)int数组的选择排序

模仿范例5-8写一个IntSelectionSort.java程序，采用选择排序（Selection Sort）算法实现int数组的排序。选择排序法是一个很简单的算法。其原理是首先找到数据清单中的最小的数据，然后将这个数据同第一个数据交换位置；接下来找第二小的数据，再将其同第二个数据交换位置，以此类推。

算法示例：

３１１１１１１１

６６２２２２２２

２２６３３３３３

１３３６４４４４

５５５５５５５５

４４４４６６６６

８８８８８８８７

７７７７７７７８

图5.8 选择排序（Selection Sort）算法说明

实验5.4.15: (I)数组的复制

如何将整个数组的值复制给另一个数组呢？或许会用如下语句：

double[] b = a；

来实现将数组a的内容拷贝到数组b中，虽然这是有效的代码，但并不能得到我们想要的结果。为了能够复制一个数组，要用for循环对数组中的每一个元素都进行操作。见如下的代码片断：

// 创建一个和数组a相同长度的数组b

double[] b = new double[a.length];

// 设定数组b中每个元素的值等于数组a中每个元素的值

for (int i=0; i

b[i] = a[i];

}

范例5-9示范了进行数组复制的方法，预测其运行结果：

_____________________________________________________________________________

程序清单5-9：ArrayCopy.java

import java.io.*;

public class ArrayCopy {

public static void main(String[] argv) {

// create a new integer array

int N = 12; // length of array

int[] array1 = new int[N];

System.out.print("array1 = ");

// assign some arbitrary values to the array elements

for (int i=0; i

array1[i] = i*i;

}

// print the array

for (int i=0; i

System.out.print(array1[i] + " ");

}

System.out.println("");

// Create a copy (?) of array1 and print it out

System.out.print("array2 = ");

int[] array2 = array1; // "copy" the array in one go

for (int i=0; i

System.out.print(array2[i] + " ");

}

System.out.println("");

// Create a copy (?) of array1 individual elements and print it out

System.out.print("array3 = ");

int[] array3 = new int[array1.length];

for (int i=0; i

array3[i] = array1[i]; // copy element by element

System.out.print(array3[i] + " "); // print new array

}

System.out.println("");

// Modify an element of array1 and see what else changes.

System.out.println("Changing array1[3] to 999 ...");

array1[3] = 999;

System.out.println("array1[3] = " + array1[3]);

System.out.println("array2[3] = " + array2[3]);

System.out.println("array3[3] = " + array3[3]);

}

} // ArrayCopy.java

编译，运行范例5-9，比较程序运行结果是否和预测输出相同。若相同，说明对数组的理解比较到位，否则，仔细阅读下面的解释。

数组间赋值语句：

Java中，对于基本数据类型变量，double b = a 实现的是将a的值赋给b。数组则不同，b = a的含义是b和a引用的是同一个数组，因此对b的一系列操作等同于对a的。数组是引用数据类型，也就是说他们是按引用处理的；而int、double、boolean这些原始数据类型，是按值处理的。例如，int[] list={1,2,3}中的数组{1，2，3}是放在计算机内存的某个地方的，用“=”运算符将数组对象指定给数组引用变量list。

注意，用new创建的对象，包括数组，都是引用数据类型。图5.8说明了使用数组间赋值语句的结果。先定义数组a，再将a赋值给数组b，其结果是它们会指向同一组数据，b并没有创建和a 一样的副本。

图5.9 数组间赋值语句

数组的比较：

注意，不可以用==来比较两个数组的元素值是否相等，==使用于对象比对时，是用来比对两个对象名称是否引用自同一个对象。范例5-10是这个概念的实例示范。

程序清单5-10：TestArrayValue.java

public class TestArrayValue {

public static void main(String[] args) {

int[] arr1 = {1, 2, 3, 4, 5};

int[] arr2 = {1, 2, 3, 4, 5};

int[] tmp = arr1;

System.out.println(arr1 == arr2);

System.out.println(arr1 == tmp);

System.out.println(arr2 == tmp);

}

}

在范例5-10中，虽然arr1与arr2中的元素值是相同的，arr1 == arr2并非比较arr1和arr2数组元素值，而是引用的比较，比较arr1和arr2是否指向的是内存中同一个位置。但实际上arr1与arr2是引用自不同的两个数组对象, arr1== arr2布尔表达式的值为false。将arr1指定给tmp来引用，由于tmp 与arr1是引用同一数组对象，所以进行==比较时会显示true；而tmp与arr2是引用自不同数组对象，所以进行==比较时会显示false。执行结果如下：

图5.10 TestArrayValue.java执行结果

进行数组复制的另一种方法是使用System类提供的arraycopy()方法。其语法如下：System.arraycopy(来源, 起始索引, 目的, 起始索引, 复制长度);

修改范例5-9，使用

System.arraycopy(array1, 0, array3, 0, array1.length);

替换掉原有的相应代码，实现数组的复制。测试程序，保证程序的运行结果与原来一致。

实验5.4.16: (D)for-each循环与数组

Java SE 5.0新增了for-each的语法，又称强化的for循环（Enhanced for Loop），应用于数组的依次存取。for-each循环的语法如下：

for (ElementType element : arrayName) {}

解释一下，冒号前面是声明一个临时变量，将在该foreach的代码段中进行引用；冒号后面是表达式，应该为集合或者数组。注意，临时变量element的类型ElementType必须与数组（或集合）元素的数据类型相同。

运行AccessArrayWithForEach.java（范例5-11），学习for-each循环的用法。

程序清单5-11：AccessArrayWithForEach.java

public class AccessArrayWithForEach {

public static void main(String[] args) {

String months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",

"July", "Aug", "Sep", "Oct", "Nov", "Dec"};

// Shortcut syntax loops through array months and assigns the next

// element to variable month for each pass through the loop

for(String month: months) {

System.out.println("month: " + month);

}

}

}

AccessArrayWithForEach.java中，每一次从数组months中取出的元素，会自动设定给month，不再需要判断是否超出了数组的长度。与AccessArrayWithForLoop.java（范例5-2）相比较，For-each的形式实现数组中的元素的依次存取，比for循环的代码简洁不少。但是这种形式的一个最大的缺点就是for-each没法定位访问单个元素，也就没办法修改，删除集合中的内容；同时，for-each也不能并行操作多个集合。所以，在编写代码时，还得看情况使用它。

二维数组如何使用for-each的方式来存取呢？要是了解数组本身就是一个对象，自然就会知道如何存取。举个例子：

int[][] arr = {{1, 2, 3},

{4, 5, 6},

{7, 8, 9}};

For-each形式的数组存取代码如下：

for ( int[] row : arr ) {

for ( int element : row ) {

System.out.println(element);

}

java web 工作原理总结

总结 第一章java web 工作原理 1.1、web应用程序有web服务器，web客服端浏览器，HTTP协议以及静态HTML文件。 Web服务器的作用是接受客服端请求，然后向客服端返回些结果；浏览器的作用是允许用户请求服务器上的某个资源，并且向用户显示请求的结果； HTML是用于告诉浏览器怎么样向用户显示内容； HTTP是web上客服端和服务器之间通信所用的协议。 1.1.2 HTTP协议将来自于客服端的请求信息封装成HTTP请求； 封装的信息当中包括请求行、请求头、消息体、分隔请求头、消息体的一个空行。 请求行是一个ASCII文本行，由三个标记组成：请求的HTTP方法、请求的URL、HTTP版本；中间用空格分开例如： GET /lovobook/index.html HTTP/1.0 在HTTP1.1版本中请求方法有八种分别是下面： GET：用于向服务器检索资源在HTTP请求头 POST：用于向服务器发送资源，并要求指定的URI处理在消息体HEAD：于GET方法相同，服务器只返回状态行和头标，并不返回请求文档。 PUT：请求服务器保持请求数据作为指定的URI新内容；

DELETE：请求服务器删除URI中命名的资源； OPTIONS：请求关于服务器支持的请求方法信息； TRACE：请求web服务器反馈HTTP请求和其头标；CONNECT：已文档化但当前未实现的一个方法，预留做隧道处理；请求头： HTTP协议使用HTTP头来传递请求的元信息。HTTP头是一个用冒号分隔的名称/值对，冒号前面是HTTP头的名称，后面是HTTP头的值。 1.1.3 HTTP响应包括：状态行、响应头、消息体、分割消息头、响应头。状态行里面出现： 1XX:表示信息，请求收到，继续处理。 2XX:表示成功 3XX:表示重定向 4XX:表示客服端错误 5XX:表示服务器错误 1.2 Web服务器的缺陷是只能向用户提供静态网页内容。 1.3 服务器端网页编程就是web服务器创建动态服务器端内容的过程。 1.3.1 服务器端网页编程出现得最早的技术就是CGI，它的缺点就是每次请求一个CGI资源，将在服务器上创建一个新的进程，并且通过标准输

JavaWeb程序设计教程课后练习答案

第1章 Web应用开发简介 习题答案 1．Web在组成上包括______和______两部分。 答案： 服务器 客户端 2．谈谈对面向对象的认识。 答案： 面向对象将将要解决的问题分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙解决问题中的各个步骤中的行为。面向对象编程方式是建立在面向过程编程方式基础上，其最重要的改变在于面向对象编程中，程序将围绕被操作的对象来设计，而不是操作本身。面向对象编程方式以类作为构造程序的基本单位，具有封装、抽象、继承、多态性等特点。 3．介绍几种常用的框架技术。 答案： Java中常用的框架。 1．Struts Struts是Apache 基金会Jakarta 项目组的一个开源项目，是一个基于Sun J2EE平台的MVC框架，它将Servlet和JSP标签作为实现自身功能的一部分。 2．WebWork WebWork是由OpenSymphony组织开发的，是一个基于Web的MVC框架。它在运行时通过Interceptor（拦截器）自动应用，因此脱离了Action类。 3．Struts 2 Struts 2是Apache基金会的一个开源项目，它建立在Struts框架与WebWork框架基础之上，继承了二者的优点，是目前非常流行的一个Web框架。 4．Spring Spring是一个以IoC和AOP为核心的轻量级容器框架。它提供了一系列的Java EE开发解决方案，包括表示层的Spring MVC、持久层的Spring JDBC以及业务层事务管理等众

多的企业级应用技术。 5．Hibernate Hibernate是一个ORM（对象关系映射）框架，它对JDBC进行了轻量级的封装。通过使用Hibernate框架，开发人员能够以面向对象的思维方式来操作数据库。 6．Ibatis 相对于Hibernate而言，Ibatis是一个“半自动化”的ORM实现框架，它主要致力于POJO与SQL之间的映射关系，是对“全自动化”ORM框架的一种有益补充。 7．EasyJWeb EasyJWeb是一个核心基于模板技术实现的MVC框架，主要致力于Java Web应用程序的快速开发。 4．IDE的用途是什么？ 答案： IDE是一种用于辅助开发人员开发应用程序的应用软件，它一般包括代码编辑器、编译器、调试器和图形用户界面工具，有的还包括版本控制系统、性能分析器等更多工具，因此IDE也就具有了编写、编译、调试等多种功能。正是基于这些功能，使用IDE能够减少项目的开发周期，减轻程序员的工作量，提高应用程序的开发效率等。 5．Web应用服务器的用途是什么？ Web应用服务器是为创建、部署、运行以及管理Web应用提供多种运行时服务（如事务、安全等等）的分布式系统，它是应用程序运行的一个基本环境。

java反射机制

Java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。灵活掌握Java反射机制，对大家以后学习框架技术有很大的帮助。 那么什么是Java的反射呢？ 大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。 Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。 那么Java反射有什么作用呢？ 假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。 Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用过Jcreator和eclipse。当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审。 Class类 要正确使用Java反射机制就得使用https://www.wendangku.net/doc/4a9145939.html,ng.Class这个类。它是Java反射机制的起源。当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。 反射API ◆反射API用于反应在当前Java虚拟机中的类、接口或者对象信息 ◆功能 —获取一个对象的类信息. —获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息. —检获属于一个接口的常量和方法声明. —创建一个直到程序运行期间才知道名字的类的实例. —获取并设置一个对象的成员，甚至这个成员的名字是 在程序运行期间才知道. —检测一个在运行期间才知道名字的对象的方法 利用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信

JAVA反射机制(内含大量实例)

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。 反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。可以看出，同一般的反射概念相比，计算机科学领域的反射不单单指反射本身，还包括对反射结果所采取的措施。所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实

际状态和行为上的情况，反之亦然。开放性和原因连接是反射系统的两大基本要素。 Java中，反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。 二、Java中的类反射： Reflection 是 Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。 1．检测类： 1.1 reflection的工作机制 考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

2020年Java自学路线图--Javaweb学习

2020年Java自学路线图--Javaweb学习Javaweb的学习时是Java学习路线图的第三个阶段，在Java学习路线图前两个阶段学习后开始学习Javaweb。具备基本的JavaWeb开发能力，熟悉Linux服 务器及相关软件的使用，可完成中小型企业级项目的开发需求。这个阶段学完后就可以考虑工作了，是不是很快？ 这个阶段需要你掌握JavaWeb开发基础知识，熟悉Java基本开发环境、熟悉项目管理工具使用及Linux服务器使用，达到了这些才能满足Java软件开发行业的基本开发需求。

1.数据库的概念 2.常见的数据库软件 3.MySQL数据库的安装卸载 4.MySQL数据库的登录退出 5.MySQL的目录结构 6.SQL语句的分类 7.数据库和数据表的操作 8.数据的添加(insert) 9.数据的删除(delete) 10.数据的修改(update) 11.数据的查询(select) 12.数据的复杂查询 13.约束的使用 14.多表关系(一对一、一对多、多对多) 15.三大范式详解 16.数据库的还原和备份 17.多表查询操作 18.事务介绍 19.事务的隔离 20.数据库的用户管理和权限管理 21.黑马程序员视频库网址：https://www.wendangku.net/doc/4a9145939.html,（海量热门编程视频、资料免费学习） 22.学习路线图、学习大纲、各阶段知识点、资料网盘免费领取+QQ 1679806262

1.JDBC入门 2.DriverManager类详解 3.Connection类详解 4.Statement类详解 5.JDBC完成增删改查操作 6.ResultSet类详解 7.JDBC工具类的编写 8.PreparedStatement类详解 9.使用JDBC完成事务管理 10.连接池的介绍 11.c3p0连接池的使用 12.druid连接池的使用 13.创建druid连接池工具类 14.JDBCTemplate的使用HTML5&CSS3 1．B/S架构 2．HTML基本使用 3．HTML常用标签 4．CSS选择器 5．常用样式

JavaWeb

二、填空题 1．在编写Servlet时，需要继承HttpServlet类，在Servlet中声明doGet()和doPost()需要HttpServletRequest 和HttpServletResponse类型的两个参数。 2．jsp主要内置对象有：response、exception、pageContext、 request、session、application 、out、config、page。 3．使用useBean动作标记的时候scope属性有4种选项，作用范围由小到大是page、_requset_、_session ,application__，其中session _是指当关闭浏览器的时候这个javabean失效，_application_ 是指当关闭服务器的时候这个javabean失效。 1、控制一个Servlet的生命周期的方法有init( ), service( )和_ destroy( )。其中init()_在Servlet加载时调用，_destroy()__在撤消应用或关闭web container时调用，客户端的每次请求此Servlet时都会调用service()方法。Servlet通常只有一个实例，被所有的访问者共享，因此要注意资源的同步。 2. 在Servlet中要输出内容，使用HttpServletResponse的方法_setContentType 方法设置文档内容类型，对于文本类型调用方法_getWriter获得一个PrintWrite的输出流，对于二进制类型调用_getOutputStream获得ServeltOutputStream的输出流。调用HttpServletRequest的方法_getParameter获取有名参数，调用getInputStream获得一个ServletInputStream 的输入流。在Servlet中也可以调用ServletContext 和HttpServletRequest 的方法_ getRequestDispatche_获得RequestDispatcher, 将请求的处理权交给一个新的资源。 3.在Java Web开发中，跟踪客户状态的手段可通过_session_和_cookie_; 增加一个新的cookie, 调用HttpServletResponse的_addCookie _方法；要在服务器端查询cookie, 调用HttpServletRequest的getCookies方法。Session的类型是HttpSession, 获得session的途径是调用HttpServletRequest的方法是_ getSession_。 三．笔试题 18简述servlet进行中文处理的方法。 19请写出获取初始化参数的方法。 20简述使用Cookie进行会话跟踪过程。（写出主要步骤）

反射(reflection)学习整理

反射学习整理 【摘要】 本文主要通过自己对反射机制的总结编写的文档，主要目的就是为了自己以后能可以参考温习也可以方便刚刚入门的同仁们学习指导，通过doc的编写相信可以在帮助别人的同时提高自己。 反射机制； Reflection API； 如何使用反射机制； 反射机制的应用举例； 第一节反射机制 什么是反射机制，说的通俗一些就是在java运行期间动态加载一些不确定的类对象，那么我们如何使用一个类的呢？当然大多数情况下我们是使用一个确定的类，然后通过在内存中的加载再使用之。 其实在一个project中会有很多类，虚拟机并不是在每一次运行时都将所有的类都进行加载然后解析的，是在我们使用的过程中才会被加载，这个大家可以看一下ClassLoader（在后期中我也会编写ClassLoader相关的文章总结） 反射机制提供的功能： 加载运行时才能确定的数据类型； 解析类的结构，获取其内部的信息； 能够操作的类型或者实例； 1. 访问属性； 2. 调用方法； 3. 创建新的对象； 以上的功能我会在接下来的文字中都进行阐述，然后每一个功能点都会通过代码的形式进行逐一的说明举例； 1.1动态加载类 Java虚拟机在运行是能加载的类型有如下几种： 类接口； 数组； 枚举； 注解（Annotation，可以参见我的另一篇文档，《java Annotation学习文档》）； 基本数据类型； 在类加载的时候，JVM会自动加载上述类型对应的Class对象。 package com.wangwenjun.demo;

import java.util.ArrayList; public class ReflectionDemo1 { private final static String LIST_STRING="java.util.ArrayList"; //动态加载java.util.ArrayList的类路径 @SuppressWarnings("unchecked") public static void main(String[] args) { try { Class clazz=Class.forName(LIST_STRING); //通过反射获取运行时的Class ArrayList