Java基础学习笔记《六》_o1 > o2 ? -1 : (o1

本文链接：https://blog.csdn.net/u013075268/article/details/89683060

一：数组

声明格式：数据类型[] 数组名=new 数据类型[数组长度（元素个数）]；

数组的遍历

int[] arr=new int[10];
//遍历方式一
for(int i=0;i<arr.length;i++){
     //todo
}
//遍历方式二
for(int i:arr){
   //todo
}

二、Scanner类(java.util.Scanner)

Scanner sc =new Scanner(System.in);

nextInt():获取输入的整数

nextLine():获取输入的字符串

注意事项：a、获取两个int类型正常获取

b、获取两个字符串类型正常获取

c、先获取一个字符串类型，后获取一个int类型正常获取

d、先获取一个int类型，后获取一个字符串类型获取不到字符串，因为有默认的回车换行，所以获取字符串时，获取的是回车换行；

针对第四种情况，具体的解决方法有两种：

a、重新创建Scanner对象

b、都用字符串nextLine接收，然后把相应的字符串转换成int类型

Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
String s2=sc.nextLine();
int x=Integer.paseInt(s);//或用Integer.valueOf(s),返回的是Integer类型

三、常见的几种排序算法

package com.common.utils;

import java.util.Comparator;

public class CommonUtils {
	
	public static int getMax(int num1,int num2)
	{
		int result=(num1>=num2)?num1:num2;
		return result;
	}
	/**
	 * 二分查找是否存在
	 * @param leftIndex 开始下标
	 * @param rightIndex 结束下标
	 * @param searchVal  查询的值
	 * @param arr  查找的数组源
	 * @return 返回超找的索引下标  -1 未找到
	 */
	public static<T extends Number> int binarySearch(int leftIndex,int rightIndex,T searchVal,T[] arr,Comparator<T> comparator)
	{
		//排序
		quickSort(0, arr.length-1, arr,comparator);
		int midIndex=(leftIndex+rightIndex)/2;
		T midVal=arr[midIndex];
		if(rightIndex>=leftIndex) {
			if(comparator.compare(midVal, searchVal)>0)
				binarySearch(leftIndex, midIndex-1, searchVal, arr,comparator);
			else if(comparator.compare(midVal, searchVal)<0)
				binarySearch(midIndex+1, rightIndex, searchVal, arr,comparator);
			else if(comparator.compare(midVal, searchVal)==0)
				return midIndex;
		}
		return -1;
	}
	/**
	 * 泛型快速排序
	 * @param arr
	 * @param left 开始下标
	 * @param right 结束下标
	 * @param comparator 比较器
	 */
	public static<T> void quickSort(int left,int right,T arr[],Comparator<T>comparator)
	{
		int l=left;
		int r=right;
		T pivot=arr[(left+right)/2];
		T temp;
		
		while(l<r) {
			while(comparator.compare(arr[l],pivot)<0) l++;
			while(comparator.compare(arr[r],pivot)>0) r--;
			
			if(l>=r) break;
			temp=arr[l];
			arr[l]=arr[r];
			arr[r]=temp;
			
			if(arr[l]==pivot) --r;
			if(arr[r]==pivot) ++l;
		}
			if(l==r)
			{
				l++;
				r--;
			}
			if(left<r) quickSort(left,r,arr,comparator);
			if(right>l) quickSort(l, right, arr,comparator);
		
	}
	/**
	 * 插入排序
	 * @param arr
	 */
	public static<T> void insertSort(T arr[],Comparator<T> comparator)
	{
		for(int i=1;i<arr.length;i++)
		{
			T insertVal=arr[i];
			//insertVal准备和前一个数比较
			int index=i-1;
			while(index>=0&& comparator.compare(insertVal,arr[index])<0 ) {
				//将把arr[index]向后移动
				arr[index+1]=arr[index];
				index--;
			}
			//将insertVal插入适当位置
			arr[index+1]=insertVal;
		}
	}
	/**
	 * 选择排序
	 * @param arr
	 */
	public static<T> void selectSort(T arr[],Comparator<T> comparator) {

		T temp;
		for(int i=0;i<arr.length-1;i++)
		{
			T min=arr[i];
			//记录最小数的下标
			int minIndex=i;
			for(int j=i+1;j<arr.length;j++)
			{
				if(comparator.compare(min, arr[j])>0)
				{
					min=arr[j];
					minIndex=j;
				}					
			}
			
			temp=arr[i];
			arr[i]=arr[minIndex];
			arr[minIndex]=temp;
		}
	}
	/**
	 * 冒泡排序
	 * @param arr
	 */
    public static<T> void bubbleSort(T[] arr,Comparator<T> comparator) {
    	for(int i=0;i<arr.length-1;i++){
    		for(int j=0;j<arr.length-1-i;j++){
    			if(comparator.compare(arr[j], arr[j+1])>0) {
    			T temp=arr[j];
    			arr[j]=arr[j+1];
    			arr[j+1]=temp;
    			}
    		}
    	}
    }
}

测试类：

package com.common.utils;

import java.util.Calendar;
import java.util.Comparator;

public class JavaTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//int x=CommonUtils.getMax(1, 2);
        //System.out.println(x);
          Integer arr[]={1,3,2,4,7,5,6,8,10,9};//new int [100000];//
		/*
		 * for(int i=0;i<100000;i++) { //让程序随机产生一个1-10000的随机数 //math.random
		 * 会随机产生一个[0-1)的数 int t=(int)(Math.random()*100000); arr[i]=t; }
		 */
          Comparator<Integer> comparator=new Comparator<Integer>() {
			
			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return o1 < o2 ?- 1 : (o1 == o2 ? 0 :1);
			}
		};
        Calendar cal=Calendar.getInstance();
        System.out.println("排序前:"+cal.getTime());
		//排序
        int isflag=CommonUtils.binarySearch(0, arr.length-1, 6, arr, comparator);
        System.out.println(isflag);
        /*
       CommonUtils.bubbleSort(arr,new Comparator<Integer>() {
           

   			@Override
   			public int compare(Integer o1, Integer o2) {
   				// TODO Auto-generated method stub
   				return o1 < o2 ?- 1 : (o1 == o2 ? 0 :1);
   			}
   		});
   		*/
        /*
         CommonUtils.selectSort(arr,new Comparator<Integer>() {
        

			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return o1 < o2 ?- 1 : (o1 == o2 ? 0 :1);
			}
		});
		 */
       /*
       CommonUtils.insertSort(arr,new Comparator<Integer>() {

		@Override
		public int compare(Integer o1, Integer o2) {
			// TODO Auto-generated method stub
			return o1 < o2 ?- 1 : (o1 == o2 ? 0 :1);
		}
	});
	*/
        /*
        CommonUtils.quickSort(0, arr.length-1, arr,new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				return o1 < o2 ?- 1 : (o1 == o2 ? 0 :1);
			}
		});
		*/
        cal=Calendar.getInstance();
        System.out.println("排序后："+cal.getTime());
        for(int a:arr)
          System.out.println(a);
	}

}