03.函数，数组

来源：互联网发布：java 验证身份证编辑：程序博客网时间：2024/06/10 09:35

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){}

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