集合工具类和排序

一、Collections类集合工具类

    1.Collections类里面全部都是静态方法，其中的sort(List<T> list)方法可以实现对List对象排序，前提是list里面的所有元素都必须实现了Comparable接口，也就是实现了接口里面的compareTo(Object o)方法。（Arrays的sort（Object[ ] object）要求一样）

   2.compareTo(Object o)方法的实现：如果对象大于要比较的对象返回正数，如果是等于返回0如果小于就返回一个负数.

如下面的类实现了compareTo(Object o)方法，以学生的学号比较：

class Student implements Comparable

{

  int num;

  String name;   

  public int compareTo(Object o)

  {

      Students=(Student)o;

      returnnum > s.num ? 1 : (num==s.num ? 0 : -1);

  }

  public String toString()

  {

      returnnum+":"+name;

  }

}

    3.Collections对象还有一个方法就是可以传入一个比较器按照比较器进行比较sort(List<T> list, Comparator<T>c).举例如下：由于比较器都是与特定类相关的也就是为某个类指定比较器，所以我们把它定义为所要比较类的内部类。

 class Student

{

     …

 

     staticclass StudentComparator implements Comparator

  {

      public int compare(Object o1,Object o2)

      {

          Students1=(Student)o1;

          Students2=(Student)o2;

          intresult=s1.num > s2.num ? 1 : (s1.num==s2.num ? 0 : -1);

          if(result==0)

          {

              result=s1.name.compareTo(s2.name);//由于s1.name是String类型已经实现了//Comparable接口可以直接用compareTo（）方法进行比较

 

          }

          returnresult;

      }

  }

 

…

}

    由于内部类是静态的所以可以用外部类的类名直接使用，new Student.StudentComparator()相当于一个内部类的对象

    4.Collections类还有public static  Comparator reverseOrder()方法返回一个按照反序排列的比较器，前提是要排序的对象要实现Comparable接口。

    5.由上例子可以知道只要是要进行比较的对象，要么是已经实现了Comparable接口也就是compareTo(Object o)方法，要么就是有一个相关的比较器。

     Collections. max(Collection coll)方法取集合中的最大元素

     Collections. min(Collection coll)方法取集合中的最小元素

    二、排序方法

// 插入排序(把数组看成一个有序数组和一个无序数组)
class Insert {
	public void sort(int arr[]) {
		// 每次取后面无序数组的第一个向前一个数组插入
		int n = 0;
		for (int i = 1; i < arr.length; i++) {
			int insertVal = arr[i];
			// index用于控制有序数组中比insertVal大的数向后移一位
			int index = i - 1;
			// 在没有比到有序数组的第一位之前只要前一位比insertVal大就交换位置
			while (index >= 0 && insertVal < arr[index]) {
				arr[index + 1] = arr[index];
				// 向前移一位
				index--;

				n++;
			}
			arr[index + 1] = insertVal;
			n++;
		}
		System.out.println(n);
	}
}

// 选择排序 先记录最小的当全部比较过后再交换 比冒泡交换的次数少
class Select {
	public void sort(int arr[]) {
		int n = 0;
		int temp = 0;
		// 每次从j后面的数据中选出最小的数给arr[j]
		for (int j = 0; j < arr.length - 1; j++) {
			n++;
			int min = arr[j];
			int minIndex = j;
			// 那min与j后面的数相比取出最小的数据给min
			for (int i = j + 1; i < arr.length; i++) {
				if (min > arr[i]) {
					min = arr[i];
					minIndex = i;

				}
				n++;
			}
			// 把找到最小数与arr[j]换位
			temp = arr[j];
			arr[j] = arr[minIndex];
			arr[minIndex] = temp;
		}
		System.out.println(n);
	}
}

// 冒泡排序法
class Bubble {

	public void sort(int arr[]) {
		int temp = 0;
		int n = 0;
		// 外层循环确定走了几趟
		for (int i = 0; i < arr.length - 1; i++) {
			// 内层循环开始逐个比较如发现那个比后面的数大就交换位置
			// 每趟结束都会送到后面一个大的值则下趟这些值不用再比较
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					// 换位
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;

				}
				n++;
			}
			n++;
		}
		System.out.println(n);
	}
}

    三、查找

// 二分查找(递归思想)
class Find {
	public void binFind(int leftIndex, int rightIndex, int val, int arr[]) {
		// 先找到数组中间数的大小
		int midIndex = (leftIndex + rightIndex) / 2;
		int midVal = arr[midIndex];
		System.out.println(midVal);
		System.out.println(midIndex);
		//
		if (leftIndex <= rightIndex) {
			// 用要查找的数与中间数相比确定查找的范围
			if (val < midVal) {
				binFind(leftIndex,midIndex - 1, val, arr);
			} else if (val > midVal) {
				binFind(midIndex + 1, rightIndex, val, arr);
			} else if (val == midVal) {
				System.out.println("找到下标" + midIndex);
			}
		}
	}
}