03.函数，数组

 

1.数组

  定义：同一种数据类型的集合。相当于一个容器。

  好处：可以自动给数组元素编号，数据量大的时候，方便操作。

  格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度]。

      （注：一点建立数组，就必须明确长度。）

    如：int[]arr = new int[3];

  格式2：元素类型[] 数组名 = new 元素类型[元素，元素，元素，...]。

 

2.数组的常见操作

  （1）遍历

    

<span style="font-size:18px">public class Demo1 {

	public static void main(String[] args) {
		
		int[] arr = {67,54,32,123,19};
		
		//正向遍历
		for (int i = 0; i < arr.length; i++) {
			System.out.println("arr["+i+"]="+arr[i]);
		}
		
		//反向遍历
		for (int i = arr.length-1; i >= 0; i--) {
			System.out.println("arr["+i+"]="+arr[i]);	
		}
	}

}
</span>

  （2）获取最值

<span style="font-size:18px">public class ZuiZhi {

	public static void main(String[] args) {
		int[] arr = {67,54,32,123,19};
		int max = 0;
		
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > arr[max]) {
				max = i;
			}
			System.out.println("该数组最大值为：" + arr[max]);
		}
	}

}
</span>

  （3）对数组排序

    选择排序

<span style="font-size:18px">public class Demo2 {

	public static void main(String[] args) {
		int[] arr = { 67, 54, 32, 123, 19 };
		// selectSort(arr);
		selectSort2(arr);
		for (int j = 0; j < arr.length; j++) {
			System.out.println("arr[" + j + "]=" + arr[j]);
		}
	}

	// 选择排序，效率更高	</span>

<span style="font-size:18px">public static void selectSort2(int[] arr) {
	// 思路二：外圈每次循环记住某位置，与后续的元素比较，全部比较完之后记住内圈得到的最小元素及其角标，再交换，这样不用每次比较都要交换		for (int i = 0; i < arr.length - 1; i++) {
			int num = arr[i];
			int index = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (num > arr[j]) {
					num = arr[j];
					index = j;
				}
			}
			if (index != i) {//防止跟自己交换位置，没意义
				int temp = arr[i];
				arr[i] = arr[index];
				arr[index] = temp;
			}

		}
	}

	// 选择排序1，
	public static void selectSort(int[] arr) {
		// 从小到大排列，比较一次，交换一次
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}

}
</span>

 

   冒泡排序

    

public class bubbleSort {

	public static void main(String[] args) {
		int[] arr = { 67, 54, 32, 123, 19 };
		bubbleSort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	/*
	 * 冒泡排序：
	 * -1是伪了避免角标越界
	 * -x是为了让外循环增加一次，内循环参数与比较的元素个数递减。
	 */
	public static void bubbleSort(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;
				}
			}
		}
	}

}

 （4）折半查找法（二分查找法）

     数组一有序，并且涉及查找时，首选折半查找。

     前提条件：被查找的数组元素必须是有序的，元素从大到小，或者从小到大。

 注意：找中间角标时，若除不整，如：0~7，中间角标mid =(0+7)/2=3.还是取整数。

    需要三个变量：min,mid,max.
   要找的数比中间角标的值大，min = mid+1;
   要找的数比中间角标的值小，max = mid-1;
   变化完之后，mid值也跟着变化，mid = (max+min)/2.

 

   功能实现：

public class HalfSearchDemo {

	public static void main(String[] args) {
		int[] arr = { 19,28,37,46 ,55};
		int key = 55;   //要查找的数字。
		int index = halfSearch(arr,key);
		
		if(index!=-1)
			System.out.println(key+"在数组重的位置："+index);
		else 
			System.out.println("不存在此元素！");
		
	}

	public static int halfSearch(int[] arr, int key) {
		int min = 0;
		int max = arr.length-1;
		int mid = (min + max)/2;
		
		//循环查找
		while(arr[mid]!=key){
			if(arr[mid]>key){
				max = mid - 1;
			}
			else if(arr[mid]<key){
				min = mid + 1;
			}
			if(max<min){
				return -1;   //不存在此元素
			}
			mid = (min + max)/2;
		}
		
		return mid;
	}

	
}

3.内存划分：

         寄存器； 本地方法区；   方法区；    栈内存；    堆内存。

   （1）栈内存：存储的是局部变量。

         特点：变量所属作用域一旦结束，该变量就自动释放。

   （2）堆内存：存储的是数组和对象，凡是带关键字 new的，都是建立在堆内存中。

        特点：①每个实体都有首地址值。

                  ②堆内存中的每一个变量都有默认的初始化值，根据类型的不同而不同。

                     整数是0，小数是0.0或者0.0f，boolean是false，char是 '\u0000'。

                 ③垃圾回收机制。

           垃圾回收的例子：在堆内存中建立数组后，若执行语句arr=null；后，arr与堆内存中的数组地址断开联系，此时数组已无用处，但不会像栈内存一样立刻释放，而是有自己的垃圾收集机制来释放。

 

4.局部代码块。

  作用：限定局部变量的生命周期。

 

public class Test {

	public static void main(String[] args) {

		/*
		 * 局部代码块：用于限定局部变量的生命周期
		 * 该例子中num只能在所处的局部代码块中有效。
		 */
		
		//局部代码块
		{
			int num = 3;
			System.out.println(num);
		}
		System.out.println(num);//编译报错
	}

}<span style="font-size:18px; color:#ed1c24"><strong></strong></span>

<span style="font-size:18px; color:#ed1c24"><strong>5.数组常见的问题：</strong></span>

 （1）当访问到数组中不存在的角标时，就会发生该异常。

//异常
		int[] arr = {12,3,65,65};
		//访问到不存在的角标时，就会发生角标越界异常
		System.out.println(arr[8]);//ArrayIndexOutOfBoundsException

 

 （2）当引用型变量没有任何实体指向时，还在用其操作实体。就会发生该异常。

    arr = null;
    System.out.println(arr[0]);//NullPointerException  

 （3）System.out.println(arr);// [I@c17164

     打印实体，没有意义。

6.函数

  格式：
    修饰符 返回值类型 函数名（参数类型(如int类型) 形式参数1，参数类型 形式参数2，。。。。。。）
    {
        执行语句；
         return返回值；
    }
  
  return还有结束函数的功能，return之后的语句没有执行。

  函数名一定要有意义，提高阅读性。
  规范：函数名需要用到两个以上的单词，第一个单词首字母是小写的，之后每个单词的首次母要大写。这是一种规范。

 

7.函数的特点。

   （1）定义函数可以将功能进行封装。

   （2）函数的出现提高了代码的复用性。

   （3）没有具体返回值时，返回类型用void来表示。如果返回值类型是void，函数的return语句可省略不写。

8.函数-细节 void

   特殊情况：
    功能没有具体的返回值。

  这时return的后面直接用分号结束。return ；
  返回值类型怎么体现呢？ 答：所以不可以写具体的数据类型。
  在java中只能用一个关键字来表示这种情况。关键字是：void。

  总结：没有具体返回值时，返回类型用void来表示。

  注意:如果返回值类型是void，那么函数中的return语句可以省略不写。

 

9.函数-重载

 重载：在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。

  特点：与返回值类型无关，只看参数列表。

 

  例如：

   

/*
	函数的重载。

	1，同一个类，
	2，同名。
	3，参数个数不同。or 参数类型不同。
	4，函数重载和返回值类型无关。
	5，java是严谨性语言，如果函数出现的调用的不确定性，会编译失败。


	*/

	//加法运算。两个整数的和。
	public static int add(int a,int b)
	{
		return a+b;
	}
	

	//加法运算。两个小数的和。
	public static double add(double a,double b)
	{
		return a+b;
	}

	//加法运算，三个整数的和。 
	public static int add(int a,int b,int c)
	{
		return add(a,b)+c;
	}

 但是，如果函数出现的调用的不确定性，会编译失败。

      publicstatic int add(int a,int b){}

     public static double add(inta,int b){}

  以上的情况会产生调用的不确定性，应该要避免。