任务：同样在上一家公司，公司还需要一个程序来找出当月工资最高的员工（高富帅）和当月工资最低的员工（屌丝）。
我们先定义一个类描述员工（Employee），为员工拟定姓名（name）和工资（salary）两个属性。Java是一个面向对象的编程语言，员工是对象，我们把员工共同的属性和行为抽取出来，就可以定义出员工类。定义一个类的过程就是一个抽象的过程，我们要做两种抽象：数据抽象（定义对象的属性）和行为抽象（定义对象的方法）。从问题中抽取出类的方法其实很简单，就是找名词和动词，名词会成为类或者类中的属性，动词会成为类中的方法。
package com.lovo;
/**
* 员工类
* @author 骆昊
*/
public class Employee {
private String name; // 员工姓名
private double salary; // 员工工资
/**
* 构造器
* @param name 姓名
* @param salary 工资
*/
public Employee(String name, double salary) {
this.name = name;
this.salary = salary;
}
/**
* 获取员工姓名
* @return 姓名
*/
public String getName() {
return name;
}
/**
* 获取员工工资
* @return 工资
*/
public double getSalary() {
return salary;
}
public String toString() {
return name + " : " + salary;
}
}接下来我们用随机的方式创建员工并指定其工资并找出高富帅和屌丝。
package com.lovo;
public class MaxMin {
/**
* 查找最高工资的员工
* @param es 装所有员工的数组
* @return 最高工资的员工
*/
public static Employee findMax(Employee[] es) {
Employee max = es[0]; // 假设第一个员工就是工资最高的员工
// 从第二个员工开始找比高富帅工资更高的员工
for(int i = 1; i < es.length; i++) {
// 比当前的高富帅工资更高就是新的高富帅
if(es[i].getSalary() > max.getSalary()) {
max = es[i];
}
}
return max;
}
/**
* 查找最低工资的员工
* @param es 装所有员工的数组
* @return 最低工资的员工
*/
public static Employee findMin(Employee[] es) {
Employee min = es[0]; // 假设第一个员工就是工资最低的员工
for(int i = 1; i < es.length; i++) {
// 比当前的屌丝工资更低就是新的屌丝
if(es[i].getSalary() < min.getSalary()) {
min = es[i];
}
}
return min;
}
public static void main(String[] args) {
// 用一个字符串数组保存员工的姓名
String[] names = {"赵云", "黄忠", "典韦", "许褚", "张飞", "马超", "曹仁", "甘宁"};
// 创建一个数组保存所有员工并用1000-5000的随机数作为员工工资
Employee[] emps = new Employee[names.length];
for(int i = 0; i < emps.length; i++) {
int salary = (int) (Math.random() * 4001 + 1000);
emps[i] = new Employee(names[i], salary);
System.out.println(emps[i]); // 在控制台打印员工信息(调用toString()方法)
}
Employee wealthy = findMax(emps); // 高富帅
Employee cockwire = findMin(emps); // 屌丝
System.out.println("[高富帅]\t" + wealthy);
System.out.println("[屌丝]\t" + cockwire);
}
}其实大家可能注意到了，上面代码中的findMax和findMin方法的代码其实很类似，明显，这两个方法是可以合并为一个方法的，请大家自己思考：）
在Java中数组也是对象类型，所谓数组就是一个存储数据的仓库，它包含了若干个仓位，编号从0开始。创建数组的时候可以用静态初始化的方式（如上面例子中员工名字的数组），也可以用new运算符并指定数组中元素的个数（names.length）。在创建数组对象后，可以通过数组对象的length属性获取数组中元素的个数。数组可以通过下标运算[]来操作数组中的元素，下标的范围是0到数组的length-1。通常可以用循环来控制数组的下标并操作数组元素。
如果数组中的每个元素又是数组，那么可以将其称之为二维数组，二维数组很像我们平时使用的表格（table），有若干行若干列来存储数据，也很像数学中的矩阵（matrix）。除此之外，2D游戏中的地图也可以用二维数组来表示，国际象棋、五子棋等棋类游戏的棋盘也可以用二维数组来表示。下面是一个用二维数组生成10行杨辉三角的例子，杨辉三角如下所示，其中每行的数字就是二项式从0次方到N次方的展开系数。
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
... ... ... ... ... ...
package com.lovo;
public class YangHuiTriangle {
public static void main(String[] args) {
int[][] array = new int[10][];
for(int i = 0; i < array.length; i++) {
array[i] = new int[i + 1];
for(int j = 0; j < array[i].length; j++) {
if(j == 0 || j == i) { // 元素在对角线上或在第一列就是1
array[i][j] = 1;
}
else { // 其他位置的元素是它上一行的元素加上上一行前一列的元素的和
array[i][j] = array[i - 1][j] + array[i - 1][j - 1];
}
System.out.print(array[i][j] + "\t");
}
System.out.println();
}
}
}关于数组，还有一个重要的应用就是排序。虽然Java API（应用程序编程接口）中的Arrays类提供了排序的sort()方法，但是下面的代码还是用一种虽然算不上有效率但是仍然很经典的冒泡排序实现数组元素的从小到大（升序）排序。冒泡排序的原理是：对数组中的元素进行两两比较，如果前面的元素比后面的元素大，那么就交换两个元素；这样一趟下来最大的元素就被移动到数组的末尾，再进行第二趟，将第二大的元素放到倒数第二个位置；这样，大的沉下去小的浮起来，这就是冒泡排序。
package com.lovo;
public class Bubble {
public static void bubbleSort(int[] array) {
boolean swapped = true; // 是否发生了元素交换的布尔值（如果为false表示没有元素交换则排序完成）
for(int i = 1; swapped && i <= array.length - 1; i++) {
swapped = false;
for(int j = 0; j < array.length - i; j++) {
if(array[j] > array[j + 1]) { // 前面的元素大于后面的元素就交换两个元素
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
swapped = true;
}
}
}
}
public static void main(String[] args) {
int[] x = new int[10];
System.out.println("排序前: ");
for(int i = 0; i < x.length; i++) {
x[i] = (int) (Math.random() * 100); // 为数组元素赋上0-99的随机值
System.out.print(x[i] + " ");
}
bubbleSort(x);
System.out.println("\n排序后: ");
for(int y : x) { // 用for-each循环打印数组中的元素
System.out.print(y + " ");
}
}
}