Java学习摘要--基础语法

Java基础语法–冒泡排序

/*
冒泡排序
原理：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这之后，最后的元素应该是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

 升序排列的口诀:
 N个数字来排队 两两相比小靠前,
 外层循环length-1
 内层循环length-i-1

 降序排序的口诀:
 N个数字来排队 两两相比大靠前,
 外层 循环length-1
*/
public class Demo01MaoPao {
    public static void main(String[] args) {
        //定义一个int类型的数组，长度为15，用于存储随机生成的15个int数字
        int[] array = new int[15];
        //使用循环随机生成15个int数字，并将每次生成的数字添加到数组当中
        for (int i = 0; i < array.length; i++) {
            array[i] = new Random().nextInt(100) + 1;
            //随机生成的数字在1-100之间，左右都包括
        }
        //遍历随机数组
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        //对随机数组进行升序排序
        //外层循环控制一共进行多少轮比较：每轮比较都会产生一个最大值并放在数组末端
        //数组长度为15
        //第1（i = 0）轮比较过后，还剩14个数据需要比较
        //第2（i = 1）轮比较过后，还剩13个数据需要比较
        //...
        //第14轮比较过后，还剩1个数据需要比较        
        //所以外层循环一共进行 array.length - 1 次
        for (int i = 0; i < array.length - 1; i++) {//i从0开始，所以循环次数应该是array.length - 1次
            //内层循环控制每1轮的比较次数
            //第1轮（i = 0），一共有15个数据，需要比较14次 15 - 0 - 1
            //第2轮（i = 1），一共有14个数据，需要比较13次 15 - 1 - 1
            //...
            //第14轮（i = 13），一共有2个数据，需要比较1次 15 - 13 - 1
            //所以内层循环每次循环arry.length - i - 1次
            for (int j = 0; j < array.length - i - 1; j++) {
                //判断进行比较的两个数的大小
                if (array[j] > array[j + 1]) {
                    int temp;
                    //临时存储较大的数据，用于数据的交换
                    temp = array[j];
                    array[j] = array[j + 1];
                    //将较小的数据移动到数组的前端
                    array[j + 1] = temp;
                    //将较大的数据移动到数组的末端
                }
            }
        }
   }                       

Java基础语法–二分查找

import java.util.Random;
import java.util.Scanner;

/*
二分查找
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。
但是，二分查找要求数组数据 必须采用顺序存储结构有序排列。
首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；
否则利用中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组,否则进一步查找后子数组。
重复以上过程，直到找到满足条件的数据，则表示查找成功， 直到子数组不存在为止，表示查找不成功。
*/
public class Demo02BinarySearch {
    public static void main(String[] args) {
        int[] array = new int[100];
        for (int i = 0; i < array.length; i++) {
            array[i] = new Random().nextInt(100) + 1;
        }    
        //创建一个长度为100的数组，并随机生成15个1-100的整数放入数组内；
        
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        //遍历随机数组
        
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i -1; j++) {
                int temp;
                if (array[j] > array[j + 1]) {
                    temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }        
        //将随机数组按照大小升序排序
        
	for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "第" + i + "号索引 ");
        }
        //遍历排序好的数组
        
        System.out.println("请输入您想要找的数字！");
        int findNum = new Scanner(System.in).nextInt();
        //获取键盘输入的一个int数字
        int firstIndex = 0;
        //创建一个int数字，用于表示数组的第1号索引
        int lastIndex = array.length - 1;
        //创建一个int数字，用于表示数组的最后一号索引
        int centerIndex = (firstIndex + lastIndex) / 2;
        //创建一个int数字，用于表示数组的中间号索引
        while(true){	
	  if (findNum > array[centerIndex]) {
		firstIndex = centerIndex + 1;
		centerInder = (firstIndex + lastIndex) / 2;
		//如果要找的数字大于中间索引指的数字
		//重新定义1号索引和中间索引
		//将在数组的后半部分找
	    } else if (findnum < array[centerIndex]) {
		lastIndex = centerIndex - 1;
		centerIndex = (firstIndex + lastIndex) / 2;
		//如果要找的数字小于中间索引所指的数字
		//重新定义最后一号索引和中间索引
		//将在数组的前半部分找
	    } else {
	   	System.out.println(""找到了，在第" + centerIndex + "号索引出"");
	   	break;
	   	//找到就break退出循环
	    }
	  if (firstIndex > lastIndex) {
		System.out.println("没有找到");
		break;
		//当出现1号索引大于最后一号索引的时候，说明数组内的元素被排除完了，并没有找到相应的数字
		//此时退出循环
	    }
	}
    }
}