包装类跟数组的使用及排序

1. 包装类（Wrapper Class）。针对于原生数据类型的包装。所有的包装类（8个）都位于java.lang包下。Java中的8个包装类分别是：Byte, Short, Integer, Long, Float, Double, Character, Boolean。他们的使用方式都是一样的，可以实现原生数据类型与包装类型的双向转换。 

2. 数组（Array）：相同类型数据的集合就叫做数组。 
3. 如何定义数组。 type[] 变量名 = new type[数组中元素的个数];可以按照下列方式定义长度为10的数组： int[] a = new int[10]; 或者 int a[] = new int[10]; 
4. 数组中的元素索引是从0开始的。对于数组来说，最大的索引==数组的长度 – 1。 
5. 定义数组的第3种方式： type[] 变量名 = {new type[]}{逗号分隔的初始化值列表}; 
6. Java中的每个数组都有一个名为length的属性，表示数组的长度。length属性是public，fina，int的。数组长度一旦确定，就不能改变大小。 
7. int[] a = new int[10]，其中a是一个引用，它指向了生成的数组对象的首地址，数组中每个元素都是int类型，其中仅存放数据值本身。 
8. 二维数组。二维数组是一种平面的二维结构，本质上是数组的数组。二维数组的定义方式：
type[][] a = new type[2][3]; 
9. 三维数组。type[][][] a = new type[2][3][4]; 
10. 冒泡排序。（掌握交换排序，快速排序的原理与实现方式） 

public class BubbleSort
{
	public static void bubbleSort(int[] arr)
	{
		for (int i = 0; i < arr.length - 1; i++)
		{
			for (int j = 0; j < arr.length - i - 1; j++)
			{
				if (arr[j] > arr[j + 1])
				{
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
			System.out.println("第" + (i + 1) + "次排序");
			for (int k = 0; k < arr.length; k++)
			{
				System.out.print(arr[k] + " ");
			}
			System.out.println();
		}
	}

	public static void main(String[] args)
	{
		int[] arr = new int[] { 3, 2, 4, 7, 1 };
		bubbleSort(arr);
	}
}

结果如下：

第一次排序:2 3 4 1 7

第二次排序：2 3 1 4 7

第三次排序：2 1 3 4 7

第四次排序：1 2 3 4 7

掌握排序交换原则

int a=3;

int b=4;

int temp=a;

a=b; 

b=temp;

第二种方法

int a=3;

int b=4;

a=a+b; 

b=a-b; 

a=a-b; 

11. 二分查找（Binary Search）：待查找的数组要有序。

public class BinarySort
{

	public static int search(int[] arr, int value)
	{
		for (int i = 0; i < arr.length; i++)
		{
			if (value == arr[i])
			{
				return i;
			}
		}
		return -1;
	}

	public static int binarySearch(int[] arr, int value)
	{
		int low = 0;
		// 算出数组长度
		int high = arr.length - 1;
		// 定义中间位
		int middle;
		while (low <= high)
		{
			// 计算中间位置
			middle = (low + high) / 2;
			// 遍历数组，找出中间位
			for (int i = 0; i < arr.length; i++)
			{
				System.out.print(arr[i]);
				if (i == middle)
				{
					System.out.print("--");
				}
				System.out.print(" ");
			}
			System.out.println();
			// 如果中间的数字直接等于要查找的数字
			if (arr[middle] == value)
			{
				return middle;
			}
			// 如果要查找的数小于这个中间的值，去掉小的那边
			if (value < arr[middle])
			{
				high = middle - 1;
			}
			// 如果要查找的数小于这个中间的值，去掉大的那边
			if (value > arr[middle])
			{
				low = middle + 1;
			}
		}
		return -1;
	}

	public static void main(String[] args)
	{
		int a[] = new int[] { 1, 3, 5, 7, 9, 10, 23 };
		// 定义查找的数字
		int value = 10;
		int index = search(a, value);
		System.out.println(index);
		int b[] = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
		int index2 = binarySearch(b, 10);
		System.out.println(index2);
	}
}

结果如下：（--表示二分查找取值范围，是左边还是右边)

5

1 2 3 4 5 6 7-- 8 9 10 11 12 13 14 

1 2 3 4 5 6 7 8 9 10 11-- 12 13 14

 1 2 3 4 5 6 7 8 9-- 10 11 12 13 14

 1 2 3 4 5 6 7 8 9 10-- 11 12 13 14

 9