任务：相同在上一家公司。公司还须要一个程序来找出当月工资最高的员工（高富帅）和当月工资最低的员工（屌丝）。
我们先定义一个类描写叙述员工（Employee）。为员工拟定姓名（name）和工资（salary）两个属性。
Java是一个面向对象的编程语言，员工是对象。我们把员工共同的属性和行为抽取出来，就能够定义出员工类。
定义一个类的过程就是一个抽象的过程，我们要做两种抽象：数据抽象（定义对象的属性）和行为抽象（定义对象的方法）。从问题中抽取出类的方法事实上非常easy。就是找名词和动词，名词会成为类或者类中的属性。动词会成为类中的方法。
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 + " ");
}
}
}