系统学习JAVA第七天（流程控制语句、方法、冒泡排序、二分查找）

系统学习JAVA第七天

复习： 语言基础

一、流程控制语句

1、分支

判断 if 和switch case 具体值匹配

2、循环

一段重复功能的代码多次出现-----------循环（三要素，初始值，判断条件， 更新初始值）

三大循环：for————while————do {} while();
结束循环关键词：continue————break————return (用javap -c在控制台查看过)

二、数组

一个变量 保存多个数据————一组数————数组
定义方式：

int[] arr = {}; ————定义时知道每个位置上的值
int[] arr = new int[20];————定义时 不知道每个位置上的值，默认值看数据的类型是什么
int[] arr = new int[]{};—————不常用

arr 数组是在内存中存放的地址

取数据：根据编号（下标 索引）进行数据获取 （0----arr.length-1）例如：arr[0]
修改某个位置上的值  :  arr[0]=10;    0----length-1   for 进行数组中所有数据的遍历（查看）

三、冒泡排序、二分查找

数组中多个数据之间的顺序 ，数据按照从小到大排序
冒泡排序 相邻之间进行的数据存放，两两相邻之间的数据的比较
冒泡排序 可以对数组进行正常的排序但是多个数组都需要使用冒泡排序 问题：冒泡排序的代码，重复多次出现

	int[] arr = {0,12,5,8,4,45};	
	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]){
	             int temp = arr[j];
	             arr[j]=arr[j+1];
	             arr[j+1]=temp;
	         }
	     }
	}
	/*for (int i = 0; i < arr.length; i++) {
	    System.out.println(arr[i]);
	}*/
	//增强for循环
    for(int i:arr){
        System.out.println(i);
    }

数据查找 如果按顺序在一个数据量少的数据中进行了查找速度比较快，如果要找一个数据是在一个数据量比较大的范围内进行查找效率就比较低，于是就有了二分查找

二分查找————一半一半的进行查找（建立再已有顺序的数组基础上）

	int[] arr = {0,1,2,3,4,5};
	int a = 3;
    int start = 0;
    int end = arr.length-1;
    while (start<=end){
        int middle= (end+start)/2;
        if (arr[middle]==a){
            System.out.printf("找到了%d它的下标为%d",a,middle);
            break;
        }else if(a>arr[middle]){
            start=middle+1;
        }else if (a<arr[middle]){
            end=middle-1;
        }
    }

四、方法

main方法(java程序的入口) 具有程序入口功能的方法————方法具有某些功能可以把自己的具有某种功能的代码，写到方法里（java中不允许方法套方法，例如 public static void main(){public static void a(){}}）方法可以写在class的文件中

1、定义方法时方法可以分类：

1 方法的（）是否有形参 有参方法（形参）和无参方法（空）
2 方法是否有返回值，有返回值和无返回值方法

方法名前面的单词是不是void，如果是就是无返回值方法；如果有数据类型（int）方法就是有返回值的方法，在有返回值方法中一定要加return

2、实现一次定义：

方法定义：方法定义后不会执行
缺点：方法定义，每次再调用前都需要修改一次
定义方法时，具有通用性（只要完成某个功能可以直接使用）

具有某种功能的代码,放到一个方法中进行定义————现在的方法 实现了一次定义，并且具有了指定的功能定义方法时，如果有需要动态传入的每次操作时不同的数据，可以在方法的小括号中写变量的声明（数据类型 变量名, 数据类型 变量名………）————形式参数——形参

//将冒泡排序做成了一个方法
public static void sort(int[] arr){//方法定义 方法定义后 不会执行
        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]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

//将二分查找做成了一个方法
    public static int search(int[] arr,int a){
        int start = 0;
        int end = arr.length-1;
        while (start<=end){
            int middle= (end+start)/2;
            if (arr[middle]==a){
//                System.out.println(a);
//                break;
                return middle;
            }else if(a>arr[middle]){
                start=middle+1;
            }else if (a<arr[middle]){
                end=middle-1;
            }
        }
        return -1;
    }

3、实现多次使用：

方法调用：

方法调用时，方法才会执行（方法调用 实际就是执行了方法定义时的方法体中的代码）
再要使用方法的功能的位置进行方法的调用，方法调用时，确定方法名（不要写错），方法定义时有没有形参，如果有在调用时，需要给形参赋值
（赋实际要操作的值） 赋值时要注意：形参的个数，顺序，类型

调用格式：

方法名(实际的参数 实际值 实参);————实参的意义就是给形参赋值
方法定义时是否有返回值，如果有可以使用对应类型的变量接收方法的返回值

//在main函数中调用方法
    public static void main(String[] args) {
        int[] arr = {1,44,62,5,33,0};
        sort(arr);// 方法调用时 才进行方法的执行

//        int[] arr2 = new int[10000];
        int a=9999;
//        直接查找太耗费时间了
//        for (int i = 0; i < arr2.length; i++) {
//            if(arr2[i]==a){
//                System.out.println("找到了，在序号"+arr[i]);
//            }
//        }
//        用二分查找就很快
        int r = search(arr2,a);
        System.out.println(r);
   }