方法与数组

方法概述与定义
方法介绍
就是一个小功能。把一段代码存起来，以后可以重复使用
示例

tatic void printB() {
	System.out.println("b");
	System.out.println("b");
	System.out.println("b");
	System.out.println("b");
}

方法注意点

• 注意点：

  • 1.方法必须声明到类（class）当中
  • 2.创建的方法要定义在其它方法之外（跟其它的方法是兄弟关系）
  • 3.定义方法不分先后顺序
  • 4.如果一个方法前面有static,那么在该方法当中调用其它的方法前面也应该有static
  • 5.一个类当中可以写多个方法
  • 6.两个方法的名称不能相同
  • 7.方法必须得要先定义，再执行。
    示例

  参数
  完整形式

   * 方法的完整形式：
   * [修饰符] 返回值类型 方法名（[形式参数...]）{
   * 	方法体（要重复使用的代码）
   * 	[return 值]
   * }
   * void 返回值为空    什么都不返回 , 如果有返回值 ，里面必须得要有return 
  

示例
方法返回值

		/**
         * 求两个数的和
 		 * @param a   第一个数
		 * @param b   第二个数
		 * 在此处声明的变量，只在方法当中有效。
		 * 出了方法，就没有效果，外界的名称也不会影响里面
		 * return后面是什么 类型，那么 定义返回值时，就要定义什么 类型。
		 * 定义了有返回值 ，接不接收返回值都可以
		 */
		static int sum(int a,int b) {
			 int res =	a + b;
			 return res;
		}

给定两个字符串 把两个字符串拼接到一起 并返回
驼峰命名法：第一个字母小写，后面的每一个单词首字母大写
示例

static String stringConcat(String str1,String str2) {
	//System.out.println(str1 + str2);
	String res = str1 + str2;
	return res;
}

方法重载
概念
在同一个类中，允许方法名称相同，但是方法的参数必须不同
方法的重载----功能相同，参数不同，就不需要定义多个方法名称了

方法的重载的规则：
1）方法名称必须相同。
2）参数列表必须不同。
3）方法的返回类型可以相同也可以不相同。
4）仅仅返回类型不同不足以称为方法的重载。		

数组
概念：它是把相同的数据类型有序的组成在一起， 我们称这样的集合为数组。

格式：数据类型[] 数组的名称 = new 要存放的数据类型[]{存放指定数据类型的内容}

规则
	/**
	 * 数组：帮我们存放相同类型的东西的。
	 *       1.存放 的东西必须得是相同 的数据类型
	 *       2.存放的东西都是有序的。可以通过角标来获取存的内容
	 */

数组初始化
静态初始化：在创建数组时，就已经确定了有多少个元素，并且把元素都放到了数组当中
示例

	//int[] ages = new int[] {21,22,23,21,25};
	String[] names = new String[] {"zs","ls","wc"};
	//先定义，再赋值
	int a;
	//System.out.println(a); 直接使用是错误的
	a=10;
	int[] ages;
	//System.out.println(ages); 直接使用是错误的
	//如果不初始化，数组是不能使用的。
	ages =  new int[] {21,22,23,21,25};
	String name = names[1];
	System.out.println(name);

动态初始化：一开始不知道要存哪些数数据。所以先定义一个指定的空间大小
示例

	String[] allPerson = new String[100];
	allPerson[0] = "zs";
	allPerson[1] = "ls";
	//ArrayIndexOutOfBoundsException:数组越界
	System.out.println(allPerson[101]);

数组长度：获取数组元素的个数： 数组名称.length
示例

	//给定数组按指定格式打印数组:["zs","ls","ww","xm","xh","xq","qq"]	
	static void printArray(String[] array ) {
	String res = "[";
	//1.遍历每一个元素，
	for(int i = 0; i < array.length; i++) {
		//2.与res进行拼接
		res = res + array[i];
		//3.每遍历一个元素拼接后， 在res后再拼接一个","
		// 如果是最一个元素， 就不拼接“,”
		if(i  == array.length - 1) {
			break;
		}
		res = res + ",";
	}
	//4.所 有的元素遍历完毕，再去往res之后拼接“]”
	res = res + "]";
	System.out.println(res);
}

指定格式逆序打印数组

	static void printArray(String[] array) {
	String res = "[";
	//1.倒着遍历每一个元素
	for(int i = array.length-1; i >= 0;i--) {
		//2.与res进行拼接
		res = res + array[i];
		//3.每遍历一个元素拼接后， 在res后再拼接一个","
		// 如果是第一个元素， 就不拼接“,”
		if(i  == 0) {
			break;
		}
		res = res + ",";
	}
	//4.所 有的元素遍历完毕，再去往res之后拼接“]”
	res = res + "]";
	System.out.println(res);
}

排序算法:
冒泡排序

//升序为例
	//第1步
		//从头开始比较每一对象元素,如果第1 个比第2个大就交换他们的位置
		//执行完一轮后, 最大的元素 在最后.
	//第2 步
		//当执行完一轮后, 最大的元素,在后面	
		//还要继续执行和第1轮相同的操作,索引的最大值要-1
					
					
int arr[] ={7,4,3,6,9};
    for (int end = arr.length; end > 0; end--){
        for (int begin = 1; begin < end; begin++){
            if (arr[begin] < arr[begin -1]){ //左边的数比右边的大
                //交换两个数的位置
                int temp = arr[begin];
                arr[begin] = arr[begin -1];
                arr[begin-1] = temp;
            }
        }
    }
    System.out.println(Arrays.toString(arr));

选择排序:从序列中找出最小的元素,然后与第一个元素进行交换执行完一轮后, 第一个元素就是最小的

	//每交换一次最小的值,位置向后移动一个
			
	for (int start = 0; start < arr.length; start++) {
        //定义一个变量  记录最小值的角标
        int minIndex = start;
        for (int next = start + 1;next <= arr.length - 1; next++)
        {
            if ( arr[next] < arr[minIndex]){
                minIndex = next;
            }
        }
        //拿最小的值 , 与第一个元素进行交换
        int temp = arr[start];
        arr[start] = arr[minIndex];
        arr[minIndex] = temp;
    }

二分查找算法:二分查找（binary search）又叫折半查找，它是一种在有序数组中查找某一特定元素的搜索算法。

二分查找必要条件：
1）必须为顺序存储结构
2）必须按关键字大小有序排列
原理：
将有序数组分为三个部分
中间值前（中间值数之前的一组数据）
中间值
中间值后（中间值之后的一组数据）
将要查找的数与中间值的数相比较
等于则退出查找
小于则在中间值前进行比较
大于在在中间值后进行比较，依次循环操作，直至查找到对应的值为止；
当要查找数据结构为偶数时，中间值mid应向下取整处理；
代码实现

public static int binarySearch(int[] nums, int target) {
    int low = 0;
    int high = nums.length - 1;
    if (low > high || target > nums[high] || target < nums[low]){
        return -1;
    }
    while(low <= high) {
        //取中间值
        int mid = (high + low) / 2;
        //等于则退出查找
        if(nums[mid] == target)
            return mid;
        else if (nums[mid] < target)
            //小于则在中间值前进行比较
            low = mid + 1;
        else if (nums[mid] > target)
            //大于在在中间值后进行比较
            high = mid - 1;
    }
    return -1;
}

二维数组
概念：在数组当中存放 的每一个元素又是一个数组
格式:

	int[] classAge1 =  {18,19,20,17};
	int[] classAge2 =  {18,19,20};
	int[] classAge3 =  {18,19};
	//整个年级的年龄
	//int[][] allClassAges = new int[][] {classAge1,classAge2,classAge3};
	int[][] allClassAges =  new int[][] {
		{18,19,20,17},
		{19,19,20},
		{30,19}
	};

二维数组遍历

	for(int i = 0; i <  allClassAges.length; i++) {
		int[] array = allClassAges[i];
		for(int j = 0; j < array.length; j++) {
			System.out.println(array[j]);
		}
	}

快速遍历
普通遍历

	int[] ages = {10,20,30};
	//遍历数组
	for(int i = 0; i < ages.length; i++) {
		System.out.println(i);
		System.out.println(ages[i]);
	}

快速遍历

	//遍历数组foreach
	//for (数组类型  遍历出来的元素 : 数组的名称)
	for (int i : ages) {  //是一个语法糖
		System.out.println(i);
	}
	String[] names = {"zs","ls","xq","123"};
	for (String name : names) {
		System.out.println(name);
	}

可变参数
数组当作参数传递

static void sum(int[]args) {  //把数组当作参数进行传递
	int res = 0;
	for(int i  = 0; i < args.length; i++) {
		res = res + args[i];
	}
	System.out.println(res);

可变参数

static void sum(int...args) {  //语法糖
	int res = 0;
	for(int i  = 0; i < args.length; i++) {
		res = res + args[i];
	}
	System.out.println(res);
}
	
public static void main(String[] args) {
	int[] params = {1,2,3,4};
	sum(params);
	sum(1,2,3,4);
}

变量作用域
什么是作用域
生效（能使用的范围）的范围
变量作用域
生效范围是：在创建变量的大括号当中生效。超过了大括号就不生效(不能再使用了)
在方法内部定义的变量，跟外界没有任何关系
示例

	test();
	int a  = 10;
	System.out.println(a);
	{  //代码块
		int b = 20;
		System.out.println(b);
	}//b过完大括号就没有了
	int b = 30;