第四件事 给一个Java小样例程序

说明一下哈： 这个程序是用Java语言编写了一个小程序，内容包括了算法、虚拟系统机时间读写，IP编程一些七七八八的东西。 

原始文件文件在这里

这个程序采用Eclipse创建， 采用Eclipse集成环境打开（导入），可以修改试着玩玩儿。

看看导入后，运行结果： 哈哈哈哈

导入Java 项目，并运行它

怎么运行-- 来，找到菜单行，压一下（或者说 点鸡 一下 ：）

选择了A 功能 运行后结果如下：

A功能是什么： 答： “每隔1秒打印一次当前操作系统时间，共打印6次，即：6秒打印完毕”

呵呵呵呵~ ， 得， 出来了

如果不想下载项目，自己想试试。 给出Java程序源码 自己读读看看吧！ 爱怎么改 怎么改 随你高兴 ：）

/* JAVA 算法例程源代码
 *  
 * 作者： MT.LIU
 *
 * 功能：选择算法，根据输入通过算法获得输出
 * 
 */

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;
import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.*;

public class JavaExample 
{
	static int[] array=new int[] {3,44,38,5,5000,15,36,26,27,7786,2,46,4,151,50,48,1,65535};
	static int temp[]=new int[array.length];
	static int mval;
	static Socket skt;
	
	private static ServerSocket ss;
	private static Socket s;
	
	public static void main(String[] args) throws InterruptedException, Exception 
	{
		char[] OptionChar=new char[100];												//定义选择的字符数组1个字符
		String Inputdata=null;															//定义一个空字符串
		Scanner scan = new Scanner(System.in);											//创建键盘输入对象 从键盘接收数据
		
		System.out.print("《采用JAVA语言实现常用简单算法例程》\n\n");						//打印例程标题
		
		System.out.println("A - 每隔1秒打印一次当前操作系统时间，共打印6次，即：6秒打印完毕");		
    	System.out.println("B - 打印当前计算机操作系统的IP地址");	
    	System.out.println("C - 打印整数数组里的最大值");	
    	System.out.println("D - 基本冒泡排序法");		
    	System.out.println("E - 优化冒泡排序法");	
    	System.out.println("F - 选择排序法");		
    	System.out.println("G - 插入排序法");	
    	System.out.println("H - 希尔排序法");	
    	System.out.println("I - 快速排序法");		
    	System.out.println("J - 合并排序法");		
    	System.out.println("K - 堆排序法");	
    	System.out.println("L - 计数排序法");
    	System.out.println("M - 基数排序法");
    	System.out.println("N - 获取网络文件内容、大小、修改日期");	
    	System.out.println("O - 获取域名信息");
    	System.out.println("P - 解析URL信息");
    	System.out.println("Q - 指定服务器PORT检查");
    	System.out.println("R - 打印倒三角");
    	System.out.println("S - 打印 99乘法表 99加法表");
    	System.out.println("T - 服务器端");
    	System.out.println("U - 客户端");
    	System.out.println("V - 欧几里德算法(求两个正整数的最大公约数)");
    	System.out.println("W - 斐波那契数列\n\n");

        System.out.println("请输入算法选项：");
        
        try 																			//判断是否还有输入
        {
        	if (scan.hasNext()) 														//next方式接收字符串
        	{	
        		Inputdata = scan.next();
        		System.out.println("您选择的是" + Inputdata +"算法");
        	}
        	scan.close();
        	Inputdata.getChars(0, 1, OptionChar, 0);									//只选取第一个字符
        }
        catch( Exception ex) 															//输入字符错误
        {
            System.out.println("输入数据触发异常...");
        }
        
        switch(OptionChar[0])
	    {
	        case 'A' :
	        	PrintDatatime();														//调用获取操作系统时间算法
	           	break;
	        case 'B' :						
	        	LocalIPAddress();														//调用获取操作系统网络IP地址算法
	        	break;
	        case 'C' :
	        	System.out.println("数组内的整数：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("打印整数数组里的最大值");								
	        	maxval(array);			    											//调用获取数组最大值函数
	        	break;
	        case 'D' :
	        	System.out.println("基本冒泡排序法");					
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
	     	    BubbleSort(array);														//调用基本冒泡排序算法
	     	    break;
	        case 'E' :
	        	System.out.println("优化冒泡排序法");		
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
	    	    BubbleSort_Opt(array);													//调用优化冒泡排序算法
	        	break;
	        case 'F' :
	        	System.out.println("选择排序法");									
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
	     	    SelectSort(array);														//调用选择排序算法
	     	    break;
	        case 'G' :
	        	System.out.println("插入排序法");									
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
		     	InsertSort(array);														//调用优化插入排序算法
	        	break;
	        case 'H' :
	        	System.out.println("希尔排序法");										//调用希尔排序算法
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
	    	    ShellSort(array);
	        	break;
	        case 'I' :
	        	System.out.println("\n快速排序法");		
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
	     		quicksort(array,0,array.length-1);										//调用快速排序算法
	     		System.out.println(Arrays.toString(array));
	        	break;
	        case 'J' :
	        	System.out.println("\n合并排序法");			
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
	    		mergesort(array,0,array.length-1,temp);									//调用合并排序算法
	    		System.out.println(Arrays.toString(array));
	        	break;
	        case 'K' :
	        	System.out.println("\n堆排序法");		
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
	    		sort(array);															//调用堆排序算法
	    		System.out.println(Arrays.toString(array));
	        	break;
	        case 'L' :
	        	System.out.println("计数排序法");
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
	        	int max = findMaxElement(array);	
	    		int[] sortedArr = countingSort(array, max + 1);						//调用计数排序算法
	    		System.out.println(Arrays.toString(sortedArr));	
	     	   	break;
	        case 'M' :
	        	System.out.println("\n基数排序法");	
	        	System.out.println("排序前数组内容：");	
	        	System.out.println(Arrays.toString(array));
	        	System.out.println("排序后数组内容：");	
	    		RaixSort(array);													//调用基数排序算法
	        	break;
	        case 'N' :	        	
	        	GetUrlContent();
	        	GetRemoteFileSize();
	        	GetRemoteFileMDdate();
	        	System.out.println("查询完毕");
	        	break;
	        case 'O' :
	        	GetDNSAddress();
	        	System.out.println("查询完毕");
	        	break;
	        case 'P' :
	        	PaserURL();
	        	break;
	        case 'Q' :
	        	LocalPort();
	        	System.out.println("查询完毕");
	        	break;
	        case 'R' :
	        	PrintTriangle();
	        	break;
	        case 'S' :
	        	 System.out.println();
	        	MultiTable();
	        	 System.out.println();
	        	AddTable();
	        	break;
	        case 'T' :
	        	Server();
	        	break;
	        case 'U' :
	        	Client();
	        	break;
	        case 'V' :
	        	System.out.println(gcd(481,221));
	        	break;
	        case 'W' :
	        	System.out.println("《斐波那契数列》");
	        	long alpha=0;
	    	    for (long counter = 0; counter <= 20; counter++)
	    		{
	    	    	//alpha=(counter + 50) % 200;
	    	    	//System.out.print(counter);
	    	    	//System.out.print("	");
	    	    	alpha=counter;
	    	    	System.out.print(alpha+"\t\t");
	    	    	System.out.println(factorial(counter));									//打印斐波那契数列
	    		}
	    	    System.out.println("\n");
	        	break;
	        case 'X' :
	        	break;
	        case 'Y' :
	        	break;
	        case 'Z' :
	        	System.out.println("你需要再努力努力哟！");
	        	break;
	        default :
	        	System.out.println("未定义算法");
	    }
	}
	//1.打印操作系统当前时间算法
	public static void PrintDatatime() throws InterruptedException
	{
		boolean j =true;
		long i=0;
		if(j)
		{
		for (i=0;i<6;i++) 
		{
			Date dNow = new Date( );
			SimpleDateFormat ft = new SimpleDateFormat ("G \tyyyy-MM-dd HH:mm:ss:SSS \tE \t本年的第D天 \t本月的第F周 \t本年的第w周 \ta \t时区z");
			System.out.println("当前系统时间: " + ft.format(dNow));
			Thread.sleep(1000);															//延时1秒
		}
		}
	}
	//2.打印操作系统获取的IP地址算法
	public static void LocalIPAddress()
	{
		try	
		{
			
			InetAddress addr = InetAddress.getLocalHost();
		    System.out.println("本地系统IP地址:\t"+addr.getHostAddress());
		    String hostname = addr.getHostName();
		    System.out.println("本地系统主机名:\t"+hostname);
		    
			//InetAddress ip4 = Inet4Address.getLocalHost();
			//System.out.print("本机IP地址:\n");
			//System.out.println(ip4.getHostAddress());
		} 
		catch (UnknownHostException e) 
		{
			e.printStackTrace();
		}		
		System.out.print("\n");
	}
	//3.获取数组中最大值算法
	public static void maxval(int array[])
    {
    	for (int i = 0; i < array.length; i++)
    	{
    		if (array[i] > mval)
    			mval = array[i];
    	}
    	System.out.println("数组中的最大值是 " + mval+"\n");
    }
	//4.冒泡排序法
	public static void BubbleSort(int array[])
	{
		//记录比较次数
		int count=0;
		//i=0,第一轮比较
		for (int i = 0; i < array.length-1; i++) {
			//第一轮，两两比较
			for (int j = 0; j < array.length-1-i; j++) {
				if (array[j]>array[j+1]) {
					int temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
				}
				count++;
			}
		}
		System.out.println(Arrays.toString(array));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
		System.out.println("一共比较了："+count+"次\n");//一共比较了：105次
	}
	//5.优化冒泡排序法
	public static void BubbleSort_Opt(int array[])
	{
		int count=0;
		for (int i = 0; i < array.length-1; i++) {
			boolean flag=true;
			for (int j = 0; j < array.length-1-i; j++) {
				if (array[j]>array[j+1]) {
					int temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
					flag=false;
				}
				count++;
			}
			if (flag) {
				break;
			}
		}
		System.out.println(Arrays.toString(array));// [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
		System.out.println("一共比较了："+count+"次\n");//一共比较了：95次
	}
	//6.选择排序法
	public static void SelectSort(int array[])
	{

		for (int i = 0; i < array.length-1; i++) {
			int index=i;//标记第一个为待比较的数
			for (int j = i+1; j < array.length; j++) { //然后从后面遍历与第一个数比较
				if (array[j]<array[index]) {  //如果小,就交换最小值
					index=j;//保存最小元素的下标
				}
			}
			//找到最小值后，将最小的值放到第一的位置，进行下一遍循环
			int temp=array[index];
			array[index]=array[i];
			array[i]=temp;
		}
		System.out.println(Arrays.toString(array));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
	}
	//7.插入排序法
	public static void InsertSort(int array[]) 
	{
		for (int i = 0; i < array.length; i++) {  //长度不减1，是因为要留多一个位置方便插入数
			//定义待插入的数
			int insertValue=array[i];
			//找到待插入数的前一个数的下标
			int insertIndex=i-1;
			while (insertIndex>=0 && insertValue <array[insertIndex]) {//拿a[i]与a[i-1]的前面数组比较
				array[insertIndex+1]=array[insertIndex];
				insertIndex--;
			}
			array[insertIndex+1]=insertValue;
		}
		System.out.println(Arrays.toString(array));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
	}
	//8.希尔排序法
	public static void ShellSort(int array[]) 
	{
		int count=0;//比较次数
		for (int gap=array.length / 2; gap > 0; gap = gap / 2) {
			//将整个数组分为若干个子数组
			for (int i = gap; i < array.length; i++) {
				//遍历各组的元素
				for (int j = i - gap; j>=0; j=j-gap) {
					//交换元素
					if (array[j]>array[j+gap]) {
						int temp=array[j];
						array[j]=array[j+gap];
						array[j+gap]=temp;
						count++;
					}
				}
			}
		}
		System.out.println(Arrays.toString(array));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
		System.out.println("一共比较了："+count+"次\n");//16
	}
	//9.快速排序法
	public static void quicksort(int[] a, int low, int high) 
	{
		int i,j;
		if (low>high) {
			return;
		}
		i=low;
		j=high;
		int temp=a[low];//基准位,low=length时，会报异常，java.lang.ArrayIndexOutOfBoundsException: 4 ，所以必须在if判断后面,就跳出方法。
		while(i<j){
			//先从右边开始往左递减，找到比temp小的值才停止
			while ( temp<=a[j] && i<j) {
				j--;
			}
			//再看左边开始往右递增，找到比temp大的值才停止
			while ( temp>=a[i] && i<j) {
				i++;
			}
			//满足 i<j 就交换,继续循环while(i<j)
			if (i<j) {
				int t=a[i];
				a[i]=a[j];
				a[j]=t;
			}
		}
		//最后将基准位跟  a[i]与a[j]相等的位置，进行交换,此时i=j
		a[low]=a[i];
		a[i]=temp;
		//左递归
		quicksort(a, low, j-1);
		//右递归
		quicksort(a, j+1, high);	
	}
	//10.合并排序法；
	public static void mergesort (int[] a, int left, int right, int[] temp) 
	{
		//分解
		if (left<right) 
		{
			int mid=(left+right)/2;
			//向左递归进行分解
			mergesort(a, left, mid, temp);
			//向右递归进行分解
			mergesort(a, mid+1, right, temp);
			//每分解一次便合并一次
			merge(a,left,right,mid,temp);
		}
	}
	/**
	 *
	 * @param a  待排序的数组
	 * @param left  左边有序序列的初始索引
	 * @param right 右边有序序列的初始索引
	 * @param mid	中间索引
	 * @param temp	做中转的数组
	 */
	public static void merge(int[] a, int left, int right, int mid, int[] temp) 
	{
		int i=left; //初始i，左边有序序列的初始索引
		int j=mid+1;//初始化j，右边有序序列的初始索引（右边有序序列的初始位置即中间位置的后一位置）
		int t=0;//指向temp数组的当前索引，初始为0
		
		//先把左右两边的数据（已经有序）按规则填充到temp数组
		//直到左右两边的有序序列，有一边处理完成为止
		while (i<=mid && j<=right) 
		{
			//如果左边有序序列的当前元素小于或等于右边的有序序列的当前元素，就将左边的元素填充到temp数组中
			if (a[i]<=a[j]) {
				temp[t]=a[i];
				t++;//索引向后移
				i++;//i后移
			}else {
				//反之，将右边有序序列的当前元素填充到temp数组中
				temp[t]=a[j];
				t++;//索引向后移
				j++;//j后移
			}
		}
		//把剩余数据的一边的元素填充到temp中
		while (i<=mid) 
		{
			//此时说明左边序列还有剩余元素
			//全部填充到temp数组
			temp[t]=a[i];
			t++;
			i++;
		}
		while (j<=right) 
		{
			//此时说明左边序列还有剩余元素
			//全部填充到temp数组
			temp[t]=a[j];
			t++;
			j++;
		}
		//将temp数组的元素复制到原数组
		t=0;
		int tempLeft=left;
		while (tempLeft<=right) 
		{
			a[tempLeft]=temp[t];
			t++;
			tempLeft++;
		}
	}
	//11.堆排序法
    public static void sort(int[] arr) {
        int length = arr.length;
        //构建堆
        buildHeap(arr,length);
        for ( int i = length - 1; i > 0; i-- ) {
            //将堆顶元素与末位元素调换
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            //数组长度-1 隐藏堆尾元素
            length--;
            //将堆顶元素下沉 目的是将最大的元素浮到堆顶来
            sink(arr, 0,length);
        }
    }
    public static void buildHeap(int[] arr, int length) {
        for (int i = length / 2; i >= 0; i--) {
            sink(arr,i, length);
        }
    }
    public static void sink(int[] arr, int index, int length) {
        int leftChild = 2 * index + 1;//左子节点下标
        int rightChild = 2 * index + 2;//右子节点下标
        int present = index;//要调整的节点下标
        //下沉左边
        if (leftChild < length && arr[leftChild] > arr[present]) {
            present = leftChild;
        }
	        //下沉右边
        if (rightChild < length && arr[rightChild] > arr[present]) {
            present = rightChild;
        }
	        //如果下标不相等 证明调换过了
        if (present != index) {
            //交换值
            int temp = arr[index];
            arr[index] = arr[present];
            arr[present] = temp;
	            //继续下沉
            sink(arr, present, length);
        }
    }
    //12.计数排序法
   	public static int findMaxElement(int[] array)
   	{
    	int max = array[0];
    	for (int val : array) {
    		if (val > max)
    			max = val;
    	}
    	return max;
    }
    public static int[] countingSort(int[] array, int range) 
    { //range:8+1
    	int[] output = new int[array.length]; 
    	int[] count = new int[range];
    	//初始化： count1数组
    	for (int i = 0; i < array.length; i++) {
    		count[array[i]]++;
    	}
    	//计数： count2数组，累加次数后的，这里用count2区分
    	for (int i = 1; i < range; i++) {
    		count[i] = count[i] + count[i - 1];
    	}
    	//排序：最后数组
    	for (int i = 0; i < array.length; i++) {
    		output[count[array[i]] - 1] = array[i];
    		count[array[i]]--;
    	}
    	return output;
    }
    //13.桶排序法
    public static void bucketsort(int[] arr)
    {
    	//最大最小值
    	int max = arr[0];
    	int min = arr[0];
        int length = arr.length;
        for(int i=1; i<length; i++) {
            if(arr[i] > max) {
                 max = arr[i];
             } else if(arr[i] < min) {
            	 min = arr[i];
    	        }
    	}
        //最大值和最小值的差
    	int diff = max - min;
        //桶列表
        ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();
        for(int i = 0; i < length; i++){
        	bucketList.add(new ArrayList<>());
        }
        //每个桶的存数区间
        float section = (float) diff / (float) (length - 1);
        //数据入桶
        for(int i = 0; i < length; i++){
        //当前数除以区间得出存放桶的位置 减1后得出桶的下标
        	int num = (int) (arr[i] / section) - 1;
        	if(num < 0){
        		num = 0;
        	}
        	bucketList.get(num).add(arr[i]);
        }
       //桶内排序
       for(int i = 0; i < bucketList.size(); i++){
       //jdk的排序速度当然信得过
            Collections.sort(bucketList.get(i));
       }
       //写入原数组
       int index = 0;
       for(ArrayList<Integer> arrayList : bucketList){
    	   for(int value : arrayList){
    		   arr[index] = value;
               index++;
            }
        }
    }
    //14.基数排序法
    public static void RaixSort(int array[]) 
    {
    	// 得到数组中最大的数
    	int max = array[0];									// 假设第一个数就是数组中的最大数
    	for (int i = 1; i < array.length; i++) 
    	{
    		if (array[i] > max) {
    			max = array[i];
    		}
    	}
    	// 得到最大数是几位数
    	// 通过拼接一个空串将其变为字符串进而求得字符串的长度，即为位数
    	int maxLength = (max + "").length();
   		// 定义一个二维数组，模拟桶，每个桶就是一个一维数组
    	// 为了防止放入数据的时候桶溢出，我们应该尽量将桶的容量设置得大一些
    	int[][] bucket = new int[10][array.length];
    	// 记录每个桶中实际存放的元素个数
    	// 定义一个一维数组来记录每个桶中每次放入的元素个数
    	int[] bucketElementCounts = new int[10];

    	// 通过变量n帮助取出元素位数上的数
    	for (int i = 0, n = 1; i < maxLength; i++, n *= 10) 
    	{
    		for (int j = 0; j < array.length; j++) 
    		{
    			// 针对每个元素的位数进行处理
    			int digitOfElement = array[j] / n % 10;
    			// 将元素放入对应的桶中
    			// bucketElementCounts[digitOfElement]就是桶中的元素个数，初始为0，放在第一位
    			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = array[j];
    			// 将桶中的元素个数++
    			// 这样接下来的元素就可以排在前面的元素后面
    			bucketElementCounts[digitOfElement]++;
    		}
    		// 按照桶的顺序取出数据并放回原数组
    		int index = 0;
    		for (int k = 0; k < bucket.length; k++) 
    		{
    			// 如果桶中有数据，才取出放回原数组
    			if (bucketElementCounts[k] != 0) {
    			// 说明桶中有数据，对该桶进行遍历
    				for (int l = 0; l < bucketElementCounts[k]; l++) {
    					// 取出元素放回原数组
    					array[index++] = bucket[k][l];
    				}
    			}
    			// 每轮处理后，需要将每个bucketElementCounts[k]置0
    			bucketElementCounts[k] = 0;
    		}
    		if (i==maxLength-1) 
    			System.out.println(Arrays.toString(array));//[3, 14, 53, 214, 542, 748]
    	}
    }
    //获取URL内容算法
    public static void GetUrlContent() throws Exception 
    {
    	URL url = new URL("https://www.msn.cn/");
    	BufferedReader reader = new BufferedReader
    	(new InputStreamReader(url.openStream()));
    	BufferedWriter writer = new BufferedWriter (new FileWriter("content_12641605.shtml"));
    	String line;
    	while ((line = reader.readLine()) != null) 
    	{
    		System.out.println(line);
    		writer.write(line);
    		writer.newLine();
    	}
    	reader.close();
    	writer.close();
    }
    //获取远程文件大小
    public static void GetRemoteFileSize() throws Exception 
    {
        int size;
        URL url = new URL("https://www.msn.cn/");
        URLConnection conn = url.openConnection();
        size = conn.getContentLength();
        if (size < 0)
            System.out.println("无法获取文件大小。");
        else
          System.out.println("文件大小为：" + size + " bytes");
        conn.getInputStream().close();
    }
    //获取远程文件最后修改时间
    public static void GetRemoteFileMDdate() throws Exception {
        URL u = new URL("https://www.msn.cn/");
        URLConnection uc = u.openConnection();
        SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
        uc.setUseCaches(false);
        long timestamp = uc.getLastModified();
        System.out.println("该文件最后修改时间 :" + ft.format(new Date(timestamp)));
    }
    //获取URL内容算法
    public static void GetDNSAddress() {
        InetAddress address = null;
        try {
            address = InetAddress.getByName("https://www.msn.cn/");
        }
        catch (UnknownHostException e) {
            System.exit(2);
        }
        System.out.println(address.getHostName() + "=" + address.getHostAddress());
        System.exit(0);
    }
    //解析URL算法
    public static void PaserURL() throws Exception 
    {
    	URL url = new URL("https://www.msn.cn/");
    	System.out.println("URL 是 " + url.toString());
    	System.out.println("协议是 " + url.getProtocol());
    	System.out.println("文件名是 " + url.getFile());
    	System.out.println("主机是 " + url.getHost());
    	System.out.println("路径是 " + url.getPath());
    	System.out.println("端口号是 " + url.getPort());
    	System.out.println("默认端口号是 " + url.getDefaultPort());
    }
    //获取本机开放的端口
    public static void LocalPort()
    {
        String host = "localhost";
        //if (args.length > 0) {
           host = "119.28.134.35";
        //}
        for (int i = 8080; i < 8082; i++) {
           try {
              System.out.println("查看 "+ i);
              skt = new Socket(host, i);
              System.out.println("端口 " + i + " 已被使用");
           }
           catch (UnknownHostException e) {
              System.out.println("Exception occured"+ e);
              break;
           }
           catch (IOException e) {
           }
        }
    }
    //打印倒立三角形算法
    public static void PrintTriangle() {
        //打印倒立的三角形
       for (int m = 1; m <= 50; m++){
           //打印空格
           for (int n = 0; n <= m; n++) 
           {
               System.out.print(" ");
           }
           //打印*
           for (int x = 1; x <= 49 -2 * (m - 1); x++) {
               System.out.print("$");
           }
           System.out.println();
       }        
    }
    //打印9*9乘法表
    public static void MultiTable() 
    {
        for(int i=1;i<=9;i++) 
        {
            for(int j=1;j<=i;j++) 
            {
                System.out.print(j+"×"+i+"="+String.valueOf(j*i)+"\t");							// \t 跳到下一个TAB位置
            }
            System.out.println();
        }
    }
    //打印9*9加减法表
    public static void AddTable() 
    {
        for(int i=1;i<=9;i++) 
        {
            for(int j=1;j<=i;j++) 
            {
                System.out.print(j+"+"+i+"="+String.valueOf(j+i)+"\t");							// \t 跳到下一个TAB位置
            }
            System.out.println();
        }
        System.out.println();
        for(int i=1;i<=9;i++) 
        {
            for(int j=1;j<=i;j++) 
            {
                System.out.print(j+"-"+i+"="+String.valueOf(j-i)+"\t");							// \t 跳到下一个TAB位置
            }
            System.out.println();
        }
    }
    //服务器端
    public static void Server() 
    {
    	try 
        {
    	   //ServerSocket
    	   ss = new ServerSocket(8888);
  
           System.out.println("启动服务器....");
           Socket s = ss.accept();
           s.getInetAddress();
           System.out.println("客户端:"+InetAddress.getLocalHost()+"已连接到服务器");
           
           BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
           //读取客户端发送来的消息
           String mess = br.readLine();
           System.out.println("客户端："+mess);
           BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
           bw.write(mess+"\n");
           bw.flush();
        } 
    	catch (IOException e) 
    	{
           e.printStackTrace();
        }
     }
    //客户端
    public static void Client() 
    {
    	try 
    	{
        	s = new Socket("127.0.0.1",8888);
        	//构建IO
        	InputStream is = s.getInputStream();
        	OutputStream os = s.getOutputStream();
           
        	BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
        	//向服务器端发送一条消息
        	bw.write("测试客户端和服务器通信，服务器接收到消息返回到客户端\n");
        	bw.flush();
           
        	//读取服务器返回的消息
        	BufferedReader br = new BufferedReader(new InputStreamReader(is));
        	String mess = br.readLine();
        	System.out.println("服务器："+mess);
        } 
    	catch (UnknownHostException e) 
    	{
           e.printStackTrace();
        } 
    	catch (IOException e) 
    	{
           e.printStackTrace();
        }
     }
     //欧几里德算法
     public static int gcd(int m,int n)
     {   
    	 if(n == 0){
            return m; 
        }
        int r = m%n;
        System.out.println(r);
        return gcd(n,r);
     }
     //1.斐波那契数列计算函数
 	 public static long factorial(long number) 
 	 {
 		 if (number <= 1)
 			 return 1;
 		 else
 	        return number * factorial(number - 1);	
 	 }
 	//2.交流电电压波形数据函数 V_AM 电压有效值值 number 相位
 	public static double usine(double V_Am,double number) 
 	{										
 		return V_Am*Math.sqrt(2)*Math.sin(number);
 	}
     //3.交流电电流波形数据函数  I_AM 电流有效值值 number 相位 order 表示阶次 fi 表示滞后或超前角度 
 	public static double isine(double I_Am,double number,int order, double fi) 
 	{
 		return I_Am*Math.sqrt(2)*Math.sin(order*number+fi);
 	}
}