目录
JAVA数组
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。
声明数组变量
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。
实例
下面是这两种语法的代码示例：
double[] myList; // 首选的方法
或
double myList[]; // 效果相同，但不是首选方法创建数组
Java语言使用new操作符来创建数组，语法如下：
arrayRefVar = new dataType[arraySize];上面的语法语句做了两件事：
- 一、使用 dataType[arraySize] 创建了一个数组。
- 二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];另外，你还可以使用如下的方式创建数组。
dataType[] arrayRefVar = {value0, value1, ..., valuek};数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。
实例
下面的语句首先声明了一个数组变量 myList，接着创建了一个包含 10 个 double 类型元素的数组，并且把它的引用赋值给 myList 变量。
public class TestArray {
public static void main(String[] args) {
// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
myList[0] = 5.6;
myList[1] = 4.5;
myList[2] = 3.3;
myList[3] = 13.2;
myList[4] = 4.0;
myList[5] = 34.33;
myList[6] = 34.0;
myList[7] = 45.45;
myList[8] = 99.993;
myList[9] = 11123;
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < size; i++) {
total += myList[i];
}
System.out.println("总和为： " + total);
}
}以上实例输出结果为：
下面的图片描绘了数组 myList。这里 myList 数组里有 10 个 double 元素，它的下标从 0 到 9。
处理数组
数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环。
示例
该实例完整地展示了如何创建、初始化和操纵数组：
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// 查找最大元素
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}以上实例编译运行结果如下：
For-Each 循环
JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
语法格式如下：
for(type element: array)
{
System.out.println(element);
}实例
该实例用来显示数组 myList 中的所有元素：
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
}
}以上实例编译运行结果如下：
数组作为函数的参数
数组可以作为参数传递给方法。
例如，下面的例子就是一个打印 int 数组中元素的方法:
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}下面例子调用 printArray 方法打印出 3，1，2，6，4 和 2：
printArray(new int[]{3, 1, 2, 6, 4, 2});数组作为函数的返回值
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}以上实例中 result 数组作为函数的返回值。
多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：
String[][] str = new String[3][4];多维数组的动态初始化（以二维数组为例）
1. 直接为每一维分配空间，格式如下：
type[][] typeName = new type[typeLength1][typeLength2];type 可以为基本数据类型和复合数据类型，typeLength1 和 typeLength2 必须为正整数，typeLength1 为行数，typeLength2 为列数。
例如：
int[][] a = new int[2][3];二维数组 a 可以看成一个两行三列的数组。
从最高维开始，分别为每一维分配空间，例如：
String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。
多维数组的引用（以二维数组为例）
对二维数组中的每个元素，引用方式为 arrayName[index1][index2]，例如：
num[1][0];Arrays 类
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
- 给数组赋值：通过 fill 方法。
- 对数组排序：通过 sort 方法,按升序。
- 比较数组：通过 equals 方法比较数组中元素值是否相等。
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
具体说明请查看下表：
| 序号 | 方法和说明 |
|---|---|
| 1 | public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。 |
| 2 | public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
| 3 | public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
| 4 | public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
数组相关算法题
力扣56.合并区间
以数组
intervals表示若干个区间的集合，其中单个区间为intervals[i] = [starti, endi]。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。示例 1：
输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]] 解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].示例 2：
输入：intervals = [[1,4],[4,5]] 输出：[[1,5]] 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。提示：
1 <= intervals.length <= 104intervals[i].length == 20 <= starti <= endi <= 104
题解：
class Solution {
public int[][] merge(int[][] intervals) {
LinkedList<int[]> res = new LinkedList<>();
//按左边界从小到大排序
Arrays.sort(intervals, (o1, o2) -> Integer.compare(o1[0], o2[0]));
//至少有一个区间
res.add(intervals[0]);
for (int i = 1; i < intervals.length; i++) {
//如果当前区间的左边界小于前一个区间的右边界 --可以合并区间
if (intervals[i][0] <= res.getLast()[1]) {
//上一个区间的左边界一定是最小的
int start = res.getLast()[0];
//更新右边界 上一个区间的右边界和现在区间的右边界作比较
int end = Math.max(intervals[i][1], res.getLast()[1]);
//在进行区间合并操作时，如果当前区间可以与前一个区间合并，那么将移除链表中的最后一个元素，然后将合并后的区间添加到链表的末尾。这样可以确保链表中始终保留着最新合并的区间。
res.removeLast();
res.add(new int[]{start, end});
}
else {
//直接把这个区间放进来
res.add(intervals[i]);
}
}
//返回 一个不重叠的区间数组
return res.toArray(new int[res.size()][]);
}
}
力扣15.三数之和
给你一个整数数组
nums，判断是否存在三元组[nums[i], nums[j], nums[k]]满足i != j、i != k且j != k，同时还满足nums[i] + nums[j] + nums[k] == 0。请你返回所有和为
0且不重复的三元组。注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4] 输出：[[-1,-1,2],[-1,0,1]] 解释： nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。 nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。 注意，输出的顺序和三元组的顺序并不重要。示例 2：
输入：nums = [0,1,1] 输出：[] 解释：唯一可能的三元组和不为 0 。示例 3：
输入：nums = [0,0,0] 输出：[[0,0,0]] 解释：唯一可能的三元组和为 0 。提示：
3 <= nums.length <= 3000-105 <= nums[i] <= 105
题解：
class Solution {
public static List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans = new ArrayList(); // 定义答案列表
int len = nums.length; // 数组长度
if(nums == null || len < 3) return ans; // 如果数组为空或者长度小于3，返回答案列表
Arrays.sort(nums); // 对数组进行排序
for (int i = 0; i < len ; i++) { // 遍历数组
if(nums[i] > 0) break; // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
if(i > 0 && nums[i] == nums[i-1]) continue; // 去重
int L = i+1; // 左指针从i+1开始
int R = len-1; // 右指针从数组尾部开始
while(L < R){ // 当左指针小于右指针时
int sum = nums[i] + nums[L] + nums[R]; // 计算三数之和
if(sum == 0){ // 如果三数之和为0
ans.add(Arrays.asList(nums[i],nums[L],nums[R])); // 将三个数加入答案列表中
while (L<R && nums[L] == nums[L+1]) L++; // 去重
while (L<R && nums[R] == nums[R-1]) R--; // 去重
L++; // 左指针向右移动
R--; // 右指针向左移动
}
else if (sum < 0) L++; // 如果三数之和小于0，左指针向右移动
else if (sum > 0) R--; // 如果三数之和大于0，右指针向左移动
}
}
return ans; // 返回答案列表
}
}JAVA查找和排序
JAVA查找
查找的定义
查找是这样一个过程，即在某个项目组中寻找某一指定目标元素，或者确定该组中并不存在该目标元素。 对其进行查找的项目的组有时也成为查找池。
两种常见的查找方式：线性查找和二分查找。
为了能够查找某一对象，我们就必须将一个对象跟另一个对象进行比较。我们对这些算法的实现就是对某个Comparable对象的数组进行查找。因此，所涉及的元素实现了Comparable接口且彼此是可比较的。我们将在Searching类头中完成这一限制。
算法查找
线性查找
/**
* 线性查找 在没有找到之前 需要一直遍历
*
* @param data
* @param min
* @param max
* @param target
* @return
*/
public static boolean linearSearch(T[] data,
int min, int max, T target) {
int index = min;
boolean found = false;
while (!found && index <= max) {
found = data[index].equals(target);
index++;
}
return false;
}二分查找
/**
* 二分查找：二分查找需要实现数组列表有序，然后每次考察中间元素，排除一半，最好的方法是使用递归实现。
* @param data
* @param min
* @param max
* @param target
* @return
*
* 二分查找方法是递归实现的，如果没有找到目标元素，且有更多待查找数据，则该方法将调用自身，同时传递参数，
* 这些参数缩减了数组内可行候选项的规模。
*
* min和max索引用于确定是否还具有更多的待查找数据，这就是说，如果削减后的查找区间一个元素没有则该方法
* 不会调用其自身且返回一个false值。
*
*
*/
public static boolean binarySearch(T[] data, int min, int max, T target) {
boolean flag= false;
int mid = (max+min)/2;
if(data[mid].compareTo(target)==0){
flag = true;
}else if(data[mid].compareTo(target)>0){//中间大于目标
if(min<=mid-1){
flag = binarySearch(data, min, mid-1, target);
}
}else if(data[mid].compareTo(target)<0){
if(mid+1<=max){
flag = binarySearch(data, mid+1, max, target);
}
}
return flag;
}查找比较
线性查找，最好情形是目标元素刚好是我们考察项目组的第一个项目。最糟糕的情形是出现在目标不再该组的时候，且在我们确定它不在之前不得不考察每一个元素。算法的期望是n/2，因此线性查找算法具有线性时间复杂度O(n)。
二分查找，因为我们每比较一回我们就能够将剩余数据削减一半，所以我们可以更快的找到元素。最好的情况一次找到，最差是排除所有元素，我们不得不进行log2n 次比较。因此，找到位于该查找池中某一元素的预期情形是大约(log2n)/2次比较。线性查找比较简单，编程调试更容易实现。
线性查找无需花费额外成本来排序该查找列表。
二分查找的复杂度是对数级的，这使得它对于大型查找池非常有效率。
JAVA排序
排序：基于某一个标准，将某一组项目按照某个规定顺序排列。
基于效率排序算法通常分为两类：顺序排序和对数排序。
顺序排序：它通常使用一对嵌套循环对n个元素进行排序，需要大约n2 次比较。
对数排序：它对n个元素进行排序大约需要nlog2n 次比较。
在n较小的时候，这两类算法之间几乎不存在任何实际差别。
直接选择排序
设数组为a[0…n-1]。
1. 初始时，数组全为无序区为a[0..n-1]。令i=0
2. 在无序区a[i…n-1]中选取一个最小的元素，将其与a[i]交换。交换之后a[0…i]就形成了一个有序区。
3. i++并重复第二步直到i==n-1。排序完成。
/**
* 选择排序： 选择排序算法通过反复地将某一特定值放到它在列表中的最终已排序位置，从而完成某一列表值的排序。 选择排序的策略：
* 【1】扫描整个列表找到最小值，将这个值与第一个元素交换
* 【2】扫描除了有序列表之外的部分无序列表找到最小值，然后将它与无序列表第1个位置上的元素交换
* 【3】不断重复【2】一直到无序列表只剩一个元素
*
* @param data
*
*/
public static void selectionSort(T[] data) {
int min;
T temp;
for (int i = 0; i < data.length - 1; i++) {
min = i;
// /找出最小的下标
for (int j = i + 1; j < data.length; j++) {
if (data[min].compareTo(data[j]) > 0) {
min = j;
}
}
// 交换位置
swap(data, min, i);
}
}直接插入排序
设数组为a[0…n-1]。首先构造有序区域
1. 初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=1
2. 将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。
3. i++并重复第二步直到i==n-1。排序完成。
/**
* 插入排序: 通过反复的将某一特定值插入到该列表的某个已经排序的子集中完成对列表值的排序。 插入排序的策略：
* 【1】对列表中的开始的两个值依据其相对大小对其进行排序，如果有必要则将它们互换。
* 【2】将列表的第三个值插入到已经有序的列表中的恰当位置
* 【3】然后不断的将无序列表的元素一次取出插入到有序列表的合适位置，继续这一个过程最后实现全部有序。
*
* @param data
*/
public static void insertionSort(T[] data) {
// 从第一个开始比较
for (int i = 1; i < data.length; i++) {
T key = data[i];
int pos = i;//
// /有序列表 当前这个元素是否需要前移 如果当前的待插入元素比有序列表pos位置的小
while (pos > 0 && data[pos - 1].compareTo(key) > 0) {
data[pos] = data[pos - 1];
pos--;
}
data[pos] = key;
}
}
冒泡排序
冒泡排序是非常容易理解和实现，以从小到大排序举例： 设数组长度为N。
1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。
2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。
3．N=N-1，如果N不为0就重复前面二步，否则排序完成。
/**
* 冒泡排序：通过重复的比较相邻元素且在必要时将它们互换，从而完成对某个列表的排序.
* 【1】扫描该列表且比较邻接元素如果他们不是相对顺序排序排列将其互换。这里就是就是将最大值冒泡到列表最后的位置.
* @param data
*/
public static void bubbleSort(T[] data){
/**
* for(int i=1;i<data.length;i++){
///已经有序的部分
for(int j =0;j<data.length-i;j++){
if(data[j].compareTo(data[j+1])>0){
swap(data,j,j+1);
}
}
}
*/
int pos;
int scan;
for(pos = data.length-1;pos>=0;pos--){
for(scan=0;scan<pos;scan++){
if(data[scan].compareTo(data[scan+1])>0){
swap(data,scan,scan+1);
}
}
}
}希尔排序
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
算法步骤：
1）选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2）按增量序列个数k，对序列进行k 趟排序；
3）每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
public class ShellSortO {
public static void main(String[] args) {
int[] data = new int[] { 5, 2, 8, 9, 1, 3, 4, 11, 15, 12, 36, 17, 28,
24, 10, 32, 24, 12, 36 };
System.out.println("未排序前");
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
System.out.println();
ShellSort1(data);
System.out.println("排序后");
for (int i = 0; i < data.length; i++)
System.out.print(data[i] + " ");
}
//希尔排序算法1
public static void ShellSort1(int a[]) {
int i, j, gap;
int n = a.length;
for (gap = n / 2; gap > 0; gap /= 2)
// 步长定义步长 定长步长的设计插入排序
for (i = 0; i < gap; i++) // 对同一分组的数据进行直接插入排序
{
for (j = i + gap; j < n; j += gap)
///如果第j个元素比前面的元素小 那么执行插入算法
if (a[j] < a[j - gap]) {
int temp = a[j];//备份当前的数据
int k = j - gap;
///统一后移
while (k >= 0 && a[k] > temp) {
a[k + gap] = a[k];
k -= gap;
}
a[k + gap] = temp;
}
}
}
}快速排序
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。对挖坑填数进行总结
1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
2．j–由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。 4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。
/**
* 快速排序：通过将列表分区，然后对这两个分区进行递归式排序，从而完成对整个列表的排序
* 快速排序的策略：
* 【1】首先，选择一个列表元素作为作为分区元素。
* 【2】分割该列表，使得小于该分区元素的所有元素位于该元素的左边，所有大于该分区元素的元素位于右边。
* 【3】最后，将该快速排序策略（递归式）应用于两个分区。
* @param data
*/
public static <T extends Comparable<? super T>> void quickSort(T[] data) {
quickSortRec(data,0,data.length-1);
}
/**
* 需要使用递归的快速排序
* @param data
* @param begin
* @param end
*/
private static void quickSortRec(T[] data,int begin,int end) {
if(begin<end){
//int mid = AdjustArray(data, begin, end);//先成挖坑填数法调整data[]
int mid = partition(data, begin, end);//先成挖坑填数法调整data[]
quickSortRec(data, begin, mid - 1); // 递归调用
quickSortRec(data, mid + 1, end);
}
}
/**
* 挖坑填数的快速排序的实现
* @param data
* @param begin
* @param end
* @return
*/
private static int AdjustArray(T[] data,int begin,int end) {
int i = begin, j = end;
T x = data[begin]; //s[l]即s[i]就是第一个坑
///由于是从小到达的排序算法
///因此我们首先找一个比基准小的数放在当前的坑里
while (i < j)
{
//从右向左找小于x的数来填s[i] 这是找小于基准数的过程
while(i < j && data[j].compareTo(x)>0)
j--;
if(i < j)
{
data[i] = data[j]; //将s[j]填到s[i]中，s[j]就形成了一个新的坑
i++;
}
//------------------------------------------------------------------------------//
// 从左向右找大于或等于x的数来填s[j] 这是找大于基准数的过程
while(i < j && data[i].compareTo(x)<0)
i++;
if(i < j)
{
data[j] = data[i]; //将s[i]填到s[j]中，s[i]就形成了一个新的坑
j--;
}
}
//退出时，i等于j。将x填到这个坑中。
data[i] = x;
return i;
}
/**
* 第二种分割方法的实现
* @param data
* @param min
* @param max
* @return
*/
private static int partition(T[] data,int min,int max) {
T pa;
int left,right;
int mid = (min+max)/2;
//将中点的data作为分割元素
pa=data[mid];
//将分割元素前置到min处
swap(data,mid,min);
left=min;
right=max;
while(left<right){
while(left<right&&data[left].compareTo(pa)<=0){
left++;
}
while(data[right].compareTo(pa)>0){
right--;
}
if(left<right)
swap(data,left,right);
}
//分割点置回中间位置
swap(data,min,right);
return right;
}归并排序
归并排序是另一种递归排序算法，通过将列表递归式分成两半直至每一个列表都只含有一个元素，然后将这些子列表按照顺序重组，这样就完成了对列表的排序。
归并排序算法的总结：递归划分子列表合并的方式，子列表有序，然后归并到一个列表中完成对列表的归并排序。
/**
* 归并排序：归并排序是另一种递归排序算法，通过将列表递归式分成两半直至每一个列表都只含有一个元素，
* 然后将这些子列表按照顺序重组，这样就完成了对列表的排序。
* 策略：
* 【1】首先将该列表分成两个大约相等的部分
* 【2】对每一个部分列表递归调用其自身，
* 【3】继续该列表的递归分解，直至达到该递归的基本情形，这是该列表被分割成长度为1的列表
* @param data
* @param min
* @param max
*/
public static void mergeSort(T[] data,
int min, int max) {
if (min < max) {
int mid = (min + max) / 2;
mergeSort(data, min, mid);
mergeSort(data, mid + 1, max);
merge(data, min, mid, max);
}
}
/**
* Merges two sorted subarrays of the specified array.
*
* @param data the array to be sorted
* @param first the beginning index of the first subarray
* @param mid the ending index fo the first subarray
* @param last the ending index of the second subarray
*/
private static void merge(T[] data,
int first, int mid, int last) {
T[] temp = (T[]) (new Comparable[data.length]);
int first1 = first, last1 = mid; // endpoints of first subarray
int first2 = mid + 1, last2 = last; // endpoints of second subarray
int index = first1; // next index open in temp array
// Copy smaller item from each subarray into temp until one
// of the subarrays is exhausted
while (first1 <= last1 && first2 <= last2) {
if (data[first1].compareTo(data[first2]) < 0) {
temp[index] = data[first1];
first1++;
} else {
temp[index] = data[first2];
first2++;
}
index++;
}
// Copy remaining elements from first subarray, if any
while (first1 <= last1) {
temp[index] = data[first1];
first1++;
index++;
}
// Copy remaining elements from second subarray, if any
while (first2 <= last2) {
temp[index] = data[first2];
first2++;
index++;
}
// Copy merged data into original array
for (index = first; index <= last; index++)
data[index] = temp[index];
}快排和归并的区别
快速排序和归并排序有点正好相反的意思。
我们以从小到达排序为例：
【1】快速排序的算法是首先执行找中心点，中间大两边小的分割开，然后不断的将列表规模变小，小的在左，大的在右的原则一直不变。这样慢慢的随着列表越变越小就能够实现全部有序。
【2】归并排序的算法是首先将列表递归的一份为二，知道每一个子列表只有一个元素，然后在就近将两个子列表有序合并，列表规模慢慢扩大，这就实现了局部有序到整体有序的过渡。【3】总之，二者都是递归排序的有效实现，实质上的区别就是，在两个算法的实现过程中一个是先利用分割点通过比较修改表结构，然后再调用递归方法；另一个是先从分割点实现递归调用，然后通过比较实现有序合并。
JAVA类和对象
Java作为一种面向对象语言。支持以下基本概念：
- 多态
- 继承
- 封装
- 抽象
- 类
- 对象
- 实例
- 方法
- 重载
- 对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
- 类：类是一个模板，它描述一类对象的行为和状态。
下图中男孩（boy）、女孩（girl）为类（class），而具体的每个人为该类的对象（object）：
下图中汽车为类（class），而具体的每辆车为该汽车类的对象（object），对象包含了汽车的颜色、品牌、名称等。
Java中的对象
现在让我们深入了解什么是对象。看看周围真实的世界，会发现身边有很多对象，车，狗，人等等。所有这些对象都有自己的状态和行为。
拿一条狗来举例，它的状态有：名字、品种、颜色，行为有：叫、摇尾巴和跑。
对比现实对象和软件对象，它们之间十分相似。
软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。
在软件开发中，方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成。
Java 中的类
类可以看成是创建 Java 对象的模板。
通过上图创建一个简单的类来理解下 Java 中类的定义：
public class Dog {
String breed;
int size; String colour;
int age;
void eat() { }
void run() { }
void sleep(){ }
void name(){ }
}一个类可以包含以下类型变量：
- 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
- 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
- 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。
一个类可以拥有多个方法，在上面的例子中：eat()、run()、sleep() 和 name() 都是 Dog 类的方法。
构造方法
每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
下面是一个构造方法示例：
public class Puppy{
public Puppy(){ }
public Puppy(String name){ // 这个构造器仅有一个参数：name }
}创建对象
对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：
- 声明：声明一个对象，包括对象名称和对象类型。
- 实例化：使用关键字 new 来创建一个对象。
- 初始化：使用 new 创建对象时，会调用构造方法初始化对象。
下面是一个创建对象的例子：
public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public static void main(String[] args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy( "tommy" );
}
}编译并运行上面的程序，会打印出下面的结果：
访问实例变量和方法
通过已创建的对象来访问成员变量和成员方法，如下所示：
/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();下面的例子展示如何访问实例变量和调用成员方法：
public class Puppy{ int puppyAge; public Puppy(String name){
// 这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public void setAge( int age ){ puppyAge = age; }
public int getAge( ){
System.out.println("小狗的年龄为 : " + puppyAge );
return puppyAge;
}
public static void main(String[] args){
/* 创建对象 */
Puppy myPuppy = new Puppy( "tommy" );
/* 通过方法来设定age */
myPuppy.setAge( 2 );
/* 调用另一个方法获取age */
myPuppy.getAge( );
/*你也可以像下面这样访问成员变量 */
System.out.println("变量值 : " + myPuppy.puppyAge );
}
}编译并运行上面的程序，产生如下结果：
源文件声明规则
在本节的最后部分，我们将学习源文件的声明规则。当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。
- 一个源文件中只能有一个 public 类
- 一个源文件可以有多个非 public 类
- 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
- 如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
- 如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
- import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
类有若干种访问级别，并且类也分不同的类型：抽象类和 final 类等。这些将在访问控制章节介绍。
除了上面提到的几种类型，Java 还有一些特殊的类，如：内部类、匿名类。
Java 包
包主要用来对类和接口进行分类。当开发 Java 程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。
import 语句
在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
例如，下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类
import java.io.*;一个简单的例子
在该例子中，我们创建两个类：Employee 和 EmployeeTest。
首先打开文本编辑器，把下面的代码粘贴进去。注意将文件保存为 Employee.java。
Employee 类有四个成员变量：name、age、designation 和 salary。该类显式声明了一个构造方法，该方法只有一个参数。
Employee.java 文件代码：
import java.io.*;
public class Employee{
String name;
int age;
String designation;
double salary;
// Employee 类的构造器
public Employee(String name){
this.name = name;
}
// 设置age的值
public void empAge(int empAge){
age = empAge;
}
/* 设置designation的值*/
public void empDesignation(String empDesig){
designation = empDesig;
}
/* 设置salary的值*/
public void empSalary(double empSalary){
salary = empSalary;
}
/* 打印信息 */
public void printEmployee(){
System.out.println("名字:"+ name );
System.out.println("年龄:" + age );
System.out.println("职位:" + designation );
System.out.println("薪水:" + salary);
}
}程序都是从main方法开始执行。为了能运行这个程序，必须包含main方法并且创建一个实例对象。
下面给出EmployeeTest类，该类实例化2个 Employee 类的实例，并调用方法设置变量的值。
将下面的代码保存在 EmployeeTest.java文件中。
EmployeeTest.java 文件代码：
import java.io.*;
public class EmployeeTest{
public static void main(String[] args){
/* 使用构造器创建两个对象 */
Employee empOne = new Employee("steve");
Employee empTwo = new Employee("knoci");
// 调用这两个对象的成员方法
empOne.empAge(28);
empOne.empDesignation("高级程序员");
empOne.empSalary(12000);
empOne.printEmployee();
empTwo.empAge(19);
empTwo.empDesignation("菜鸟程序员");
empTwo.empSalary(500);
empTwo.printEmployee();
}
}编译这两个文件并且运行 EmployeeTest 类，可以看到如下结果：
$ javac EmployeeTest.java $ java EmployeeTest 名字:steve 年龄:28 职位:高级程序员 薪水:12000.0 名字:knoci 年龄:19 职位:菜鸟程序员 薪水:500.0
Java 方法
在前面几个章节中我们经常使用到 System.out.println()，那么它是什么呢？
- println() 是一个方法。
- System 是系统类。
- out 是标准输出对象。
这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。
什么是方法
Java方法是语句的集合，它们在一起执行一个功能。
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
方法的优点
- 1. 使程序变得更简短而清晰。
- 2. 有利于程序维护。
- 3. 可以提高程序开发的效率。
- 4. 提高了代码的重用性。
方法的命名规则
- 1.方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
- 2.下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test<MethodUnderTest>_<state>，例如 testPop_emptyStack。
方法的定义
一般情况下，定义一个方法包含以下语法：
修饰符 返回值类型 方法名(参数类型 参数名){ ... 方法体 ... return 返回值; }
方法包含一个方法头和一个方法体。下面是一个方法的所有部分：
- 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
- 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
- 方法体：方法体包含具体的语句，定义该方法的功能。
如：
public static int age(int birthday){...}参数可以有多个：
static float interest(float principal, int year){...}注意： 在一些其它语言中方法指过程和函数。一个返回非void类型返回值的方法称为函数；一个返回void类型返回值的方法叫做过程。
实例
下面的方法包含 2 个参数 num1 和 num2，它返回这两个参数的最大值。
/** 返回两个整型变量数据的较大值 */
public static int max(int num1, int num2) {
int result;
if (num1 > num2) result = num1; else result = num2;
return result;
}更简略的写法（三元运算符）：
public static int max(int num1, int num2) { return num1 > num2 ? num1 : num2; }方法调用
Java 支持两种调用方法的方式，根据方法是否返回值来选择。
当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。
当方法返回一个值的时候，方法调用通常被当做一个值。例如：
int larger = max(30, 40);如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：
System.out.println("我是个歌姬！");实例
下面的例子演示了如何定义一个方法，以及如何调用它：
public class TestMax {
/** 主方法 */
public static void main(String[] args) {
int i = 5;
int j = 2;
int k = max(i, j);
System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
}
/** 返回两个整数变量较大的值 */
public static int max(int num1, int num2) {
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
}以上实例编译运行结果如下：
5 和 2 比较，最大值是：5
这个程序包含 main 方法和 max 方法。main 方法是被 JVM 调用的，除此之外，main 方法和其它方法没什么区别。
main 方法的头部是不变的，如例子所示，带修饰符 public 和 static,返回 void 类型值，方法名字是 main,此外带个一个 String[] 类型参数。String[] 表明参数是字符串数组。
void 关键字
本节说明如何声明和调用一个 void 方法。
下面的例子声明了一个名为 printGrade 的方法，并且调用它来打印给定的分数。
示例
public class TestVoidMethod {
public static void main(String[] args) {
printGrade(78.5);
}
public static void printGrade(double score) {
if (score >= 90.0) {
System.out.println('A');
}
else if (score >= 80.0) {
System.out.println('B');
}
else if (score >= 70.0) {
System.out.println('C');
}
else if (score >= 60.0) {
System.out.println('D');
}
else {
System.out.println('F');
}
}
}以上实例编译运行结果如下：
C
这里printGrade方法是一个void类型方法，它不返回值。
一个void方法的调用一定是一个语句。 所以，它被在main方法第三行以语句形式调用。就像任何以分号结束的语句一样。
通过值传递参数
调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。
例如，下面的方法连续n次打印一个消息：
public static void nPrintln(String message, int n) {
for (int i = 0; i < n; i++) {
System.out.println(message);
}
}示例
下面的例子演示按值传递的效果。
该程序创建一个方法，该方法用于交换两个变量。
public class TestPassByValue {
public static void main(String[] args) {
int num1 = 1;
int num2 = 2;
System.out.println("交换前 num1 的值为：" +
num1 + " ，num2 的值为：" + num2);
// 调用swap方法
swap(num1, num2);
System.out.println("交换后 num1 的值为：" +
num1 + " ，num2 的值为：" + num2);
}
/** 交换两个变量的方法 */
public static void swap(int n1, int n2) {
System.out.println("\t进入 swap 方法");
System.out.println("\t\t交换前 n1 的值为：" + n1
+ "，n2 的值：" + n2);
// 交换 n1 与 n2的值
int temp = n1;
n1 = n2;
n2 = temp;
System.out.println("\t\t交换后 n1 的值为 " + n1
+ "，n2 的值：" + n2);
}
}以上实例编译运行结果如下：
交换前 num1 的值为：1 ，num2 的值为：2 进入 swap 方法 交换前 n1 的值为：1，n2 的值：2 交换后 n1 的值为 2，n2 的值：1 交换后 num1 的值为：1 ，num2 的值为：2
传递两个参数调用swap方法。有趣的是，方法被调用后，实参的值并没有改变。
方法的重载
上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点类型数据的最大值呢？
解决方法是创建另一个有相同名字但参数不同的方法，如下面代码所示：
public static double max(double num1, double num2) {
if (num1 > num2) return num1;
else return num2;
}如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；
如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。
Java编译器根据方法签名判断哪个方法应该被调用。
方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。
重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。
变量作用域
变量的范围是程序中该变量可以被引用的部分。
方法内定义的变量被称为局部变量。
局部变量的作用范围从声明开始，直到包含它的块结束。
局部变量必须声明才可以使用。
方法的参数范围涵盖整个方法。参数实际上是一个局部变量。
for循环的初始化部分声明的变量，其作用范围在整个循环。
但循环体内声明的变量其适用范围是从它声明到循环体结束。它包含如下所示的变量声明：
你可以在一个方法里，不同的非嵌套块中多次声明一个具有相同的名称局部变量，但你不能在嵌套块内两次声明局部变量。
命令行参数的使用
有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
命令行参数是在执行程序时候紧跟在程序名字后面的信息。
实例
下面的程序打印所有的命令行参数：
public class CommandLine {
public static void main(String[] args){
for(int i=0; i<args.length; i++){
System.out.println("args[" + i + "]: " + args[i]);
}
}
}如下所示，运行这个程序：
$ javac CommandLine.java $ java CommandLine this is a command line 200 -100 args[0]: this args[1]: is args[2]: a args[3]: command args[4]: line args[5]: 200 args[6]: -100
构造方法
当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。
一旦你定义了自己的构造方法，默认构造方法就会失效。
实例1
下面是一个使用构造方法的例子：
// 一个简单的构造函数
class MyClass {
int x;
// 以下是构造函数
MyClass() {
x = 10;
}
}你可以像下面这样调用构造方法来初始化一个对象：
public class ConsDemo {
public static void main(String[] args) {
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
System.out.println(t1.x + " " + t2.x);
}
}大多时候需要一个有参数的构造方法。
实例2
下面是一个使用构造方法的例子：
// 一个简单的构造函数
class MyClass {
int x;
// 以下是构造函数
MyClass(int i ) {
x = i;
}
}你可以像下面这样调用构造方法来初始化一个对象：
public class ConsDemo {
public static void main(String[] args) {
MyClass t1 = new MyClass( 10 );
MyClass t2 = new MyClass( 20 );
System.out.println(t1.x + " " + t2.x);
}
}运行结果如下：
10 20
可变参数
JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。
方法的可变参数的声明如下所示：
typeName... parameterName在方法声明中，在指定参数类型后加一个省略号(...) 。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
实例
public class VarargsDemo {
public static void main(String[] args) {
// 调用可变参数的方法
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax( double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++){
if (numbers[i] > result) {
result = numbers[i];
}
}
System.out.println("The max value is " + result);
}
}以上实例编译运行结果如下：
The max value is 56.5 The max value is 3.0
finalize() 方法
Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。
在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。
finalize() 一般格式是：
protected void finalize() { // 在这里终结代码 }关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。
当然，Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法。
实例
public class FinalizationDemo {
public static void main(String[] args) {
Cake c1 = new Cake(1);
Cake c2 = new Cake(2);
Cake c3 = new Cake(3);
c2 = c3 = null;
System.gc(); //调用Java垃圾收集器
}
}
class Cake extends Object {
private int id;
public Cake(int id) {
this.id = id;
System.out.println("Cake Object " + id + "is created");
}
protected void finalize() throws java.lang.Throwable {
super.finalize();
System.out.println("Cake Object " + id + "is disposed");
}
}运行以上代码，输出结果如下：
$ javac FinalizationDemo.java $ java FinalizationDemo Cake Object 1is created Cake Object 2is created Cake Object 3is created Cake Object 3is disposed Cake Object 2is disposed
3800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
