java学习笔记——函数（方法）和数组

函数和数组

---

函数（方法）

方法定义

​ 现实生活中完成某件事的步骤我们叫方法。

​ Java中，方法是一段能完成独立功能的代码块。函数又被称为方法 。

​ 我们只需要写一次方法，可以被多次调用，提高了代码的复用性。

​ 函数都是在栈内存中运行；运行的函数处在栈顶。

​ 语法：

修饰符  返回值类型[void]  方法名（[数据类型 变量名, 数据类型1 变量名1，…..]）{
	//方法体
	[return  结果值];
}

​ 说明：

• 修饰符：可以是访问修饰符，也可以说是函数修饰符（abstract、final、 static、synchronized），还可以是两者的组合。

• 返回值类型[void]：方法给调用者返回的数据类型，如果方法没有返回值，我们就使用void

• 方法名: 见名之意，使用驼峰模式来规范方法名：xxxYyyZzz

• 参数列表：方法的参数可有可无，参数列表中可以有多个参数，先指定参数数据类型，再指定参数的变量名，多个参数用逗号分隔。

• return：在方法有返回值的情况，返回的具体数据。

  main方法属于一个特殊的方法，被虚拟机调用执行main中的语句。

方法定义一般规律

1.什么时候定义方法的形参？

​ 当方法中需要的数据是变化的值，我们一般在方法的形参上定义变量。

​ 当方法中没有变化的数据，我们可以把方法定义为空参。

2.什么时候定义方法的返回值？

​ 当方法中有计算结果，而我们也需要调用这个方法的时候获得这个运算结果。

方法的调用（使用）

调用格式：方法名（实参）；（实参就是具体的数值）

​ 方法名（实参1，实参2，···）；

注意：

• 方法定义在类中和其它方法并列，不能方法套方法

• 方法形参上定义的变量也是局部变量。（只在该方法内有效）

• 可以直接打印有返回值的方法。

• 调用方法传参的时候支持类型的自动提升

• 实参：方法在调用时实际输入的参数值，不包括数据类型。

• 形参：方法在定义的时候的参数名，包括参数的数据类型和参数名

• 静态方法（static修饰的方法）只能调用静态方法

  如果在本类调用本类的其它静态方法，可以直接调用，不需要用类名.静态方法名（实参）;如果在本类调用其它类的静态方法，必须采用其它方法的类名.静态方法名（实参）;

• 参数的传递：基本数据类型（值传递），引用数据类型（内存地址值）

  • 当调用方法时，如果传入的数值为基本数据类型（包含String类型），形式参数的改变不影响实际参数。
  • 当调用方法时，如果传入的数值为引用数据类型（不包含String类型），形式参数的改变影响实际参数。

jvm内存划分

栈：当方法被调用的时候会入栈，方法中的局部变量就会存在栈中。
堆：存new出来的东西，数组对象

​ “int a = 10；和int b = 19；”中的a，b叫做实参，compareNum方法参数列表中的a和b是形参，这两个a和b的地址是不同的。只不过是通过值传递的方式放实参的值传递给形参，所以参数列表中的数据类型必须匹配，变量名可以随意。

​ 注意：当前语句块中return 语句下不能再有代码。如果返回值类型是void 就不需要return语句

方法的重载

​ 在同一个类中函数（方法）名字相同，参数列表不一样（参数个数不一样，或者对应索引位类型不一样，顺序不一样）的两个方法是重载关系，跟返回值一点关系没有。

​ 目的：为了节约方法的功能命名和提高代码的可读性。

public static int add(int a, int b){
	return a+b;
}
	
public static double add(int a, double b){
	return a+b;
}

数组

数组的定义

​ 在java中，数组是用来存储一组相同数据类型的数据结构，它属于引用数据类型。

语法：

​ 定义数组:

• 数据类型[] 数组名 = new 数据类型[数组长度];

• 数据类型 数组名[] = new 数据类型[数组长度];

  ​ 获得数组的长度使用数组的属性length。我们通过数组的变量名（数组的整地址），通过数组的变量名加上数组的下标或者索引可以对数组的每一个值进行操作。

数组元素分配的初始值

数组元素类型	默认初始值
byte、short、int、long	0
float、double	0.0
char	‘\u0000’
boolean	false
引用数据类型	null

数组元素的表示与赋值

​ 由于定义数组时内存分配的是连续的空间，所以数组元素在数组里顺序排列编号。

该编号即元素下标。首元素编号为0，因此数组的下标依次是0、1、2、3、···

​ 访问数组中的元素可以通过下标：数组名[下标值]

​ 如名为scores的数组

​ scores[0]=65；//表示scores数组中的第一个元素赋值为65

数组的初始化

​ 定义数组并初始化：数组的长度由value的数量来决定

• 数据类型[] 数组名 = {值1， 值2，……}

• 数据类型[] 数组变量名 = new 数据类型[]{值1，值2，值3，……}

  		//定义数组并初始化数组
          //创建一个长度为4的整型数组
          int scores[] = {75,58,78,96};
          int score[] = new int[]{75,58,78,96};
  

数组问题

• 索引越界

注意：在数组的操作过程中常见的问题就是数组的越界问题

class Demo{	
	public static void main(String[] args){
		//定义了一个不定长度的int类型的数组
		int[] array = {12,4,5,24,78,94};
		//获得数组的长度
		System.out.println("数组的长度："+array.length);
		System.out.println("打印指定数组的值："+array[6]);
		
	}
}

​ 此时数组长度为6，下标最大为5，而打印了数组下标为6的值，没有这个值。

• 空指针异常

  public static void main(String[] args) {
          int[] arr = {1,3,5};
          System.out.println(arr[0]);//1
          //null只能赋值给引用变量，null覆盖掉了原有的地址值
          //一旦覆盖掉地址值，就无法通过arr找到这个数组
          //数组都找不到了，无法访问里面的元素
          arr = null;
          System.out.println(arr[0]);//空指针异常 			   //java.lang.NullPointerException
          
      }
  

数组在内存中的划分

内存区分配：

​ 栈内存：容量小，速度快，数据的生命周期短，先进后出，保存局部变量（函数里面的变量，语句块中的变量）

​ 堆内存：容量大，速度慢，保存引用数据类型的数据。

​ 方法区：保存所有对象的共享数据。

​ 栈中存储堆中数组的首地址

数组的常用操作

• 遍历：把整个数组每个数都访问一遍

  • for循环

     int[] array = {12,4,5,24,78,94};
     for (int i=0；i<array.length;i++) {
     	System.out.println(array[i]);
      }
    

  • 增强for

    jdk1.5之后提供了增强for循环语句，用来实现对数组或集合中元素的访问。

    语法：for(元素类型 变量名：要循环的数组或集合名){···}

    ​ 第一个元素类型是数组或集合中元素的类型，变量名在循环时用来保存每个元素的值，冒号后面是要循环的数组或集合名称。

    int[] array = {12,4,5,24,78,94};
     for (int i:array) {
     	System.out.println(i);
      }
    

• 求极值

  public static void main(String[] args) {
          //求12,4,5,24,78,94中的最大值和最小值
          int[] array = {12,4,5,24,78,94};
          int max = array[0];//存储最大值
          int min = array[0];//存储最小值
          //判断最值
          for (int i=0;i<array.length;i++) {
              //最大
              if (array[i]>max){
                  max = array[i];
              }
              //最小
              if (array[i]<min) {
                  min = array[i];
              }
          }
          System.out.println("最大值："+max);
          System.out.println("最小值："+min);
      }
  

• 排序

  • 冒泡排序（Bubble sort）：相邻的两个数逐个的做比较，如果前一个数比后一个数小那么就交换过来，当第一轮比较完毕后最小的值一定产生在末尾。
    

    	public static void main(String[] args) {
            int[] array = {23,25,12,7,51};
            int temp;//使用temp交换两个数的位置
            for(int i=0; i<array.length-1; i++) {
                for (int j = 0; j < array.length - 1 - i; j++) {
                    if (array[j] > array[j + 1]) {
                        temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
            //增强for遍历数组
            for (int i:array) {
                System.out.println(i);
            }
            //结果为：7  12  23  25  51
        }
    

  • 选择排序
    ​ 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

	public static void main(String[] args) {
/*        数组：{23,25,12,7,51}
                23,25,12,7,51
                假设min=23，用min与25,12,7,51比较，最后min=7
                7,23,25,12,51
                7,12,23,25,51
                7,12,23,25,51
                7,12,23,25,51
                7,12,23,25,51
                第一次:arr[0]分别与arr[1-4]比较,比较4次
                第二次:arr[1]分别与arr[2-4]比较,比较3次
                第三次:arr[2]分别与arr[3-4]比较,比较2次
                第四次:arr[3]与arr[4]比较,比较1次
*/
        int[] array = {23,25,12,7,51};
        for(int i=0;i<array.length-1;i++) {
            for(int j=i+1;j<array.length;j++) {
                if(array[i] > array[j]) {
                    int temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }

        }
        //增强for遍历数组
        for (int i:array) {
            System.out.println(i);
        }
        //7  12  23  25  51
    }

• 倒置
  
  ​ 1.获得数组中间的索引length/2;
  ​ 2.获得中间索引前的索引的对称端的索引ength -1 – i

	public static void main(String[] args) {
        int[] array = {11,2,3,4,5,66,55};
        for (int i = 0; i < array.length / 2; i++) {
            int temp = array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

• 添加

  	//String[] str = {"aaa","bbb","ccc",null}
      //String[] str = {"aaa","bbb","ccc","ddd"}
      public static void main(String[] args) {
          int index = -1;
          String[] str = {"aaa","bbb","ccc",null};
          for (int i = 0; i < str.length; i++) {
              if (str[i]==null){
                  index = i;
                  break;
              }
          }
          if (index!=-1){//数组中存在元素为null
              str[index] = "ddd";
              for (int i = 0;i<str.length;i++){
                  System.out.println(str[i]);
              }
          }else {
              System.out.println("数组已满");
          }
      }
  

• 修改

  	//String[] str = {"aaa","bbb","ccc","eee"}
      //String[] str = {"aaa","bbb","ccc","ddd"}
      public static void main(String[] args) {
          int index = -1;
          String[] str = {"aaa","bbb","ccc","eee"};
          for (int i = 0; i < str.length; i++) {
              if (str[i].equals("eee")){//比较值是否相等
                 index = i;
                 break;
              }
          }
          if (index!=-1){
              str[index] = "ddd";
              for (int i = 0;i<str.length;i++){
                  System.out.println(str[i]);
              }
          }else {
              System.out.println("不存在eee");
          }
      }
  

• 删除

  思路：找到删除的位置，删除后把后面的数据依次前移将最后一位设置为null。

  	//String[] str = {"aaa","zzz","bbb","ccc"}
      //String[] str = {"aaa","bbb","ccc",null}
      public static void main(String[] args) {
          int index = -1;
          String[] str = {"aaa","zzz","bbb","ccc"};
          for (int i = 0; i < str.length; i++) {
              if (str[i].equals("zzz")){//比较值是否相等
                  index = i;
                  break;
              }
          }
          if (index!=-1){
              for (int i = index;i<str.length-1;i++){
                  str[i] = str[i+1];
              }
              str[str.length-1] = null;
          }else {
              System.out.println("没有找到要删除的元素zzz");
          }
          for (int j = 0; j <str.length ; j++) {
              System.out.println(str[j]);
          }
      }
  

二维数组

• 定义

  ​ java中定义和操作多维数组的语法和一维数组类似。在实际应用中，三维及以上的数组很少使用，主要使用二维数组。

  		//数据类型[][] 数组名;
          //数据类型 数组名[][];
  

  		int[][] num;//定义二维数组
          num = new int[3][4];//分配内存空间
          //或者 int[][] num = new int[3][4];
  
  

• 存储方式

​ 二维数组实际上是一个一维数组，它的每个元素又是一个一维数组。

• 初始化

  		//定义二维数组并初始化
          //方法一
          int[][] scores = new int[][]{{90,78,54},{45,86},{96}};
          //方法二
          int[][] score = {{90,78,54},{45,86},{96}};
  

• 遍历

  		int[][] scores = {{90,78,54},{45,86},{96}};
          for (int i = 0; i <scores.length ; i++) {
              for (int j = 0; j <scores[i].length ; j++) {
                  System.out.println(scores[i][j]);
              }
          }
          //90 78 54 45 86 96
  

Arrays类

• Arrays类及常用方法

  ​ jdk中提供了一个专门用于操作数组的工具类，及Arrays类，位于java.util包中。该类提供了一系列的方法来操作数组，用户直接调用这些方法即可。

  返回类型	方法	说明
  boolean	equals(array1,array2)	比较两个数组是否相等
  void	sort(array)	对数组元素升序排序
  String	toString(array)	将数组转化为一个字符串
  void	fill(array,val)	将数组元素都赋值为val
  与array数据类型一致	copyOf(array,length)	将数组复制成一个长度为length的新数组
  int	binarySearch(array,val)	查询元素值val在数组中的下标

• 使用Arrays类操作数组

  • equals():当两个数组长度相等，对应位置的元素也一一相等时，返回true，否则返回false。

    import java.util.Arrays;
    //使用Arrays中的方法时要导入java.util中的Arrays类
    public class demo{
        public static void main(String[] args) {
            int[] arr1 = {10,20,30};
            int[] arr2 = {10,20,30};
            int[] arr3 = {10,20};
            System.out.println(Arrays.equals(arr1,arr2));//true
            System.out.println(Arrays.equals(arr1,arr3));//false
    
        }
    }
    

  • sort():对数组元素升序排序，即从小到大。

    import java.util.Arrays;
    public class demo{
        public static void main(String[] args) {
            int[] arr = {15,20,4,9,3};
            Arrays.sort(arr);
            for (int i:arr) {
                System.out.println(i);//3 4 9 15 20
            }
        }
    }
    

  • toString():按顺序把多个数组连在一起，多个数组元素之间用英文逗号和空格隔开

    import java.util.Arrays;
    public class demo{
        public static void main(String[] args) {
            int[] arr = {15,20,4,9,3};
            String s = Arrays.toString(arr);
            System.out.println(s);//[15, 20, 4, 9, 3]
        }
    }
    

  • fill()

    import java.util.Arrays;
    public class demo{
        public static void main(String[] args) {
            int[] arr = {15,20,4,9,3};
            Arrays.fill(arr,1);
            String s = Arrays.toString(arr);
            System.out.println(s);//[1, 1, 1, 1, 1]
        }
    }
    

  • copyOf()

    import java.util.Arrays;
    public class demo{
        public static void main(String[] args) {
            int[] arr = {15,20,4,9,3};
            //将arr复制成长度为3的新数组arrnew1
            int[] arrnew1 = Arrays.copyOf(arr,3);
            System.out.println(Arrays.toString(arrnew1));//[15, 20, 4]
            //将arr复制成长度为3的新数组arrnew2
            int[] arrnew2 = Arrays.copyOf(arr,4);
            System.out.println(Arrays.toString(arrnew2));//[15, 20, 4, 9]
            //将arr复制成长度为3的新数组arrnew3
            int[] arrnew3 = Arrays.copyOf(arr,5);
            System.out.println(Arrays.toString(arrnew3));//[15, 20, 4, 9, 3]
    
        }
    }
    

  • binarySearch():查询元素在数组中的下标

    调用该方法时要求数组中的元素已经升序排列，这样才能得到正确的结果

  import java.util.Arrays;
  public class demo {
      public static void main(String[] args) {
          int[] arr = {15,20,4,9,3};
          Arrays.sort(arr);
          System.out.println(Arrays.toString(arr));//[3, 4, 9, 15, 20]
          int index = Arrays.binarySearch(arr,3);
          System.out.println(index);//0
      }
  }