JAVA学习小结

GHforworld

在JAVA中一个对象只能启动一个线程
如果一个类要当做线程来使用有两种方法：
（1）：继承Thread类，并重写run函数
（2）：实现Runnable接口，并重写run函数
对于线程同步，处理方法比较简单，只需要在同步的代码段上用synchronized{你要同步的代码}即可

这里附上一个经过自身调试过的java代码，内部包含插入排序，选择排序和快速排序等类，通过更改代码可以选择使用不同的排序方式，经过验证，测定10w个数据选择排序需要2s;而冒泡排序需要15秒;快速排序很震撼，1000w数据量只需要1-2s就可以

package test1;
import java.util.;//打印系统时间多需要的包
import java.io.;//引入这个包是因为需要从控制台读入数据

public class sorts
{

public static void main(String[] args) throws  Exception
{
	int  number=10000000;
	float  arr[]=new  float[number];
	//Math.random可以随机生成0-1之间的double类型数据;并且不会等于1
	for(int i=0;i<number;i++)
	{
		float temp=(float)Math.random()*1000;
		arr[i]=temp;
	}
	
	//Bubble  bubble=new  Bubble();
	//Select select=new  Select();
	//Insert insert=new  Insert();
	Quick quick=new  Quick();
	
	//打印排序前系统时间
	Calendar cal1=Calendar.getInstance();
	System.out.println("排序前"+cal1.getTime());
	
	//bubble.sort(arr);
	//select.sort(arr);
	//insert.sort(arr);
	quick.sort(0,arr.length-1,arr);
	
	//打印排序后系统时间，而且需要重新获取实例，因为它是单态的
	Calendar cal2=Calendar.getInstance();
	System.out.println("排序后"+cal2.getTime());
	
	//打印排序后的结果
	/*for(int i=0;i<arr.length;i++)
	{
		System.out.println(arr[i]+" ");
	}
	*/
	
	
	
	float  b[]= {-1.3f,-0.2f,1.1f,2.3f,3,20};	
	System.out.println("数组中的数据有：");
	for(int i=0;i<b.length;i++)
	{
		System.out.println(b[i]+" ");
	}
	System.out.println("请输入您要查找的数据：");
	InputStreamReader  isr=new  InputStreamReader(System.in);
	BufferedReader   buf=new  BufferedReader(isr);
	//String  s_data=buf.readLine();
	//float  data=Float.parseFloat(s_data);
	
	//BinaryFind  binaryFind=new  BinaryFind();
	//binaryFind.find(0,6,data,b);
	
	
}

}

//二分法查找数据要求数据必须是从小到大排好了的
//但是有个bug，一旦查不到这个数据，就会出现异常
//而且输入的右边界的值是length,而不是length-1,否则不能检索到最右边的数
class BinaryFind
{
public void find(int leftIndex,int rightIndex,float val,
float arr[])
{
int midIndex=(leftIndex+rightIndex)/2;
float midVal=arr[midIndex];

	//需要这个判断条件，否则递归就变成了死归，卡死在里面
	if(leftIndex<=rightIndex)
	{
		if(val<arr[midIndex])
		{
			find(leftIndex,midIndex,val,arr);
		}
		else  if(val>arr[midIndex])
		{
			find(midIndex,rightIndex,val,arr);
		}
		else  if(val==arr[midIndex])
		{
			System.out.println("查找到了,是第"+(midIndex+1)+"个数");
			return;
		}
		return;
	}
	else
	{
		System.out.println("没有这个数据");
		return;
	}
	
	
}

}

//快速排序法需要用到递归，先了解一下
class Quick
{
public void sort(int l,int r,float arr[])
{
if (l<r)
{
//Swap(arr[l], arr[(l + r) / 2]);
//将中间的这个数和第一个数交换参见注1
int i = l, j = r;
float x = arr[l];
while (i < j)
{
// 从右向左找第一个小于x的数
while(i < j && arr[j] >= x)
j--;
if(i < j)
arr[i++] = arr[j];
//从左向右找第一个大于等于x的数
while(i < j && arr[i] < x)
i++;
if(i < j)
arr[j--] = arr[i];
}

        arr[i] = x;  
        sort(l, i - 1,arr); // 递归调用   
        sort(i + 1, r,arr);  
    }  
}

}

class Insert
{
public void sort(float arr[])
{
for(int i=1;i<arr.length;i++)
{
float curData=arr[i];
int Index=i-1;
//假若比Index所指的数大则前面的数一直往后移动；
//一直循环检索直到比Index所指的数小，则插入到Index后面
//每轮for循环中Index均是指向有序数组的最后一位数
//也即每次循环开始时Index都是指向有序数组中最大的那个数
while(Index>=0&&curData<arr[Index])
{
arr[Index+1]=arr[Index];
Index--;
}
//注意这里的+1
arr[Index+1]=curData;
}
}
}

class Select
{
public void sort(float arr[])
{
for(int i=0;i<arr.length;i++)
{
//找到后面最小的数，然后与当前位置的数交换
float min=arr[i];
int minIndex=i;
for(int j=i;j<arr.length;j++)
{
if(arr[j]<min)
{
min=arr[j];
minIndex=j;
}
}
float temp=arr[i];
arr[i]=arr[minIndex];
arr[minIndex]=temp;
}
}
}

class Bubble
{
public void sort(float arr[])
{
//外层循环控制的是循环次数
for(int i=0;i<arr.length-1;i++)
{
//注意内层循环是从0开始的
for(int j=0;j<arr.length-i-1;j++)
{
if(arr[j]>arr[j+1])
{
float temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}