[Java] 方法和数组
目录
1. 方法
1.2 什么是方法
Java中的方法就类似于C语言当中的函数，是实现一种特定的，使用频率高的功能，专门解决一种问题的办法。例如：求一个数的开平方，判断一个数是不是素数。
方法也分为两种，一种是Java语言规定的方法，还有一种是程序员根据自己的需要自定义的一些方法。
当在解决重复问题时，设置一个方法解决重复问题，可以多次调用方法去解决重复问题，不用每次使用就需要写代码，减少代码冗余度。
1.2 方法的定义
修饰符 返回值类型 方法名(参数类型）{
方法体代码；
（return 返回值;)
}
上面是方法的基本形式，举个例子，写一个判断一个数是不是素数的方法：
public static boolean isPrimeNumber(int n){
for (int i = 2; i < Math.sqrt(n); i++) {
if(n % i == 0){
return false;
}
}
return true;
}
}public static 是修饰符，boolean 是返回值类型，返回值类型必须与return返回的类型一致，isPrimeNumber是方法名，int n是参数，下面便是方法体，如果没有返回值，则返回值类型写void，不用写return。
方法不能嵌套定义，方法的命名一般是小驼峰，方法必须在类里面。
1.3 方法的调用
定义好一个方法后，需要在main函数里面进行调用，否则不会调用。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
boolean b = isPrimeNumber(a);
if (b == true) {
System.out.println(a + "是素数");
}
}在调用方法时候如果方法需要传参，便需要在调用的时候传入对应类型的参数，然后调用方法。 形参是实参的一份临时拷贝，改变形参的值不会改变实参的值，因为形参和实参不是同一块地址，每次调用方法都需要在栈中调用一块空间，方法调用完销毁。
1.4 方法的重载
方法在调用时候可能需要传的参数的类型，顺序，数量不同，但都是同一种功能的方法，这时候就可以把两种方法用相同的名字命名，例如:
public static int add(int a,int b){
return a + b;
}
public static double add(double a,double b){
return a + b;
}上面代码是计算两个数的和的方法，但是传的参数不一样，可以用相同的名字来命名方法，这样调用这个方法时候既可以计算两个整型的和，也能计算两个双精度浮点数的和。
注意：
方法名必须相同
方法参数的类型，顺序，数量其中至少有一种不同
与方法的返回值类型无关。
按理来说同一块作用域不能有两个相同的标识符，但是为什么类里面可以有相同名字的两种方法呢？
其实不然，我们编写的方法名并不是真正存储在内存中的方法名，而编译器会将方法+后面的参数编译成一种方法签名供机器识别。
我们可以通过JDK自带的反汇编工具查看方法在机器中存储的真正名字。
1.先将.java文件编译成.class文件
2. 找到.class文件所在的目录，用控制台打开
3. 输入javap -v 字节码文件名就可以显示反汇编码了。
上面第一个方法名是add;(II)I，括号里面表示方法的参数是两个整型，后面表示返回值是整型，第二个方法名add(DD)D,括号里面表示方法的参数是两个double类型的，后面表示返回值是double类型。机器识别的是这种方法签名，区分方法的重载。
下面方法签名的一些符号：
1.5 递归
递归就是递推和回归的意思，在解决一些问题时，使用递归将复杂的问题简单化，就可以轻松求解。递归也就是方法重复调用自己，知道遇到停止条件，才停止调用，返回调用的值。
因此递归有两个重要的部分：
1. 递推公式
2. 终止条件
例如求n!；
public static void main(String[] args) {
//求n的阶乘
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println(fib(n));
}
public static int fib(int a){
if(a == 1){
return 1;
}
return a * fib(a-1);
}上面代码中 a == 1是终止条件，a * fib(a-1)是递推公式。
但是递归也有它的坏处，那就是容易导致栈溢出，因为每次调用方法都需要在栈里面申请空间，如果问题过于复杂，申请的空间过多，就会导致栈溢出，例如用递归解决斐波那契数列问题，给的数太大，就会导致栈溢出。
2. 一维数组
2.1 什么是数组
数组可以理解为相同元素的集合，数组里面可以存储许多相同类型的数据，数组在内存中是连续存储的。
2.2 数组的创建
数组创建的基本形式，下面我以创建整型数组为例：
int[] a = new int[10];int[]是数据类型，代表引用类型，a是变量名，称为引用变量也被称为引用，new是创建一个新的对象，后面中括号里是数组的大小。
2.3 数组的初始化
数组的初始化分为两种动态初始化和静态初始化：
动态初始化：
在创建数组的时候直接指定数组的大小，不指定数组内容，系统默认赋值为0：
int[] a = new int[10];静态初始化：
在创建数组的时候不指定数组元素的个数，而是指定数组里面的值：
int[] a = new int[]{1,2,3,4,5};静态变量虽然没有指定数组的大小，但是编译器会根据后面数据的内容来判断数组的大小。
静态变量初始化时候可以简写成：
int[] a = {1,2,3,4,5};在Java中也支持C语言的定义数组的方法：
int a[] = {1,2,3,4,5};当然不建议平时这样定义数组和初始化。
在静态初始化和动态初始化时也可以分开来写：
//静态初始化
int[] a;
a = new int[]{1,2,3,4,5};
//动态初始化
int[] b;
b = new int[10];当然不能写成如下格式：
//错误
int[] a;
a = {1,2,3,4,5};数组没有初始化的话，系统默认的值是：
数组中存储的是引用类型时的默认值是：null。
2.4 遍历数组
遍历数组有三种方法：
方法一：
下面方法中使用循环的方法来遍历数组并打印，里面用到.length的属性，.length是求数组长度的属性。
int[] a = new int[]{1,2,3,4,5};
for(int i = 0;i < a.length;i++) {
System.out.print(a[i] + " ");
}方法二：
下面是for循环的的另一种版本，能够更简便的遍历数组，把数组里的每个值传给定义的 x变量，并打印。
int[] a = new int[]{1,2,3,4,5};
for (int x,a) {
System.out.print(x + " ");
}方法二的优点是遍历数组简单，缺点是获取不了数组元素的下标，不能改变数组里面的值。
方法三：
这里用到了Arrays里面的toString方法，将数组传进去返回数字里面的值的字符串形式：
import java.util.Arrays
int[] a = new int[]{1,2,3,4,5};
String b = Arrays.toString(a);
System.out.println(b);输出结果是：[1,2,3,4,5]
2.5 引用数据类型
数组属于引用数据类型，引用数据类型就是存储到是数据在堆区创建的地址，存储都引用变量里面。下面先介绍一下JVM(java虚拟机)：
程序都要在JVM中运行，在JVM中的栈区申请一块栈帧，存放方法的局部变量等，在堆区创建对象，用引用变量存放对象的地址，来使用对象。
下面是JVM里面的代码运行时的数据区：
为什么会有两个栈区？
本地方法栈执行的是由C/C++编写的方法。
虚拟机栈是执行的Java的方法的。
我们今天只用到堆区和虚拟机栈。
这里定义一个整型数组：
int[] a = new int[]{1,2,3,4,5}; int[] 是引用类型，a是引用变量，又称引用，new是创建新对象，后面是创建的新对象，它们在内存中存储如下：
引用变量a先在栈区申请一块空间，a是引用变量存放的是对象的地址，new创建的对象存放在堆区，a存放的地址，指向堆区里面创建的数组对象。
1. 一个引用变量只能指向一个对象。
2. 引用变量初始化赋值为null时，引用变量不指向任何对象。
3. 假设两个引用变量a 和 b，a=b的含义是：a指向的对象变成b指向的对象
4. 引用类型的引用变量存放的是对象的地址。
在Java中数组可以作为返回值，也可以作为方法的参数：
例如：
public static int[] arr(int[] a) {
int[] b = new int[a.length];
for(int i = 0;i < a.length;i++) {
b[i] = a[i];
return b;
}2.6 关于null
null 在Java中被称为空引用，也就是不指向任何一个对象：
int[] a = null;该引用不能进行读写操作，或者.length操作等，如果使用就会报错：
null相当于C语言中的NULL指针，表示的是一个无效的内存。
2.7 数组转字符串
在Java中有一个名为Arrays的类，里面有很多对数组处理的方法，Arrsys类里面的toString（数组名）的方法，能帮助我们快速的将数组转换成字符串：
public static void main(String[] args) {
//数组转字符串
int[] a = new int[]{1, 2, 3, 4, 5};
String b = Arrays.toString(a);
System.out.println(b);
}当然我们也可以自己书写一个将数组转换为字符串的方法：
public static void main(String[] args) {
int[] a = new int[]{1,3,5,7,9};
String b = myToString(a);
System.out.println(b);
}
public static String myToString(int[] a) {
String arr = "[";
for (int i = 0; i < a.length; i++) {
arr += a[i];
if(i != a.length-1) {
arr += ", ";
}
}
arr += "]";
return arr;
}
2.8 数组元素的查找
方法一：顺序查找
一次遍历数组中的每个元素，知道遇到要查找的元素，返回元素下标。
public static void main(String[] args) {
//查找数组中的元素，返回下标
int[] a = new int[]{1,2,3,4,5};
int b = 3;
System.out.println(find(a,b));
}
public static int find(int[] a,int b) {
for (int i = 0; i < a.length; i++) {
if(b == a[i]) {
return i;
}
}
return -1;
}方法二：二分查找
二分查找的前提是数组元素是有序的，一次检查一半的元素，直到查找到元素，返回下标。
public static int fingOne(int[] a,int b) {
int left = 0;
int right = a.length - 1;
while(left <= right) {
int mid = (left + right) / 2;
if(b > a[mid]) {
left = mid + 1;
}else if(b < a[mid]) {
right = mid - 1;
}else {
return mid;
}
}
return -1;
}方法三：系统自带的二分查找方法
int[] a = new int[]{1,2,3,4,5};
int c = Arrays.binarySearch(a,3);
System.out.println(c);用到Arrays类里面的binarySearch（数组名，查找元素）方法 ,返回查找的数组下标，如果数组中没有查找元素，则返回 -（最后一次二分查找左下标 + 1）。
该方法的重载还可以实现指定数组返回进行二分查找元素：
int[] a = new int[]{1,2,3,4,5};
int d = Arrays.binarySearch(a,1,3,3);
System.out.println(d);Arrays.binarySearch(数组名，范围开始下标，范围结束下标，查找元素）；
从数组下标范围 [1,3)里面查找3元素，返回下标。
2.9 数组的排序
方法一：冒泡排序
升序：对数组中的元素从开始依次相邻两个进行比较；大的数后移，直到比较到最后两个数结束，数组中最大的数就在最后一个位置。循环往复，最后完成数组的升序排列：
public static void main(String[] args) {
//冒泡排序（升序）
int[] a = new int[]{1,22,5,33,66,55,9};
mysort(a);
System.out.println(Arrays.toString(a));
}
public static void mysort(int[] a) {
boolean b = true;
//轮数
for (int i = 0; i < a.length-1; i++) {
for (int j = 0; j < a.length-1-i; j++) {
if(a[j] > a[j+1]) {
int tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
b = false;
}
}
if(b == true) {
return;
}
}
return;
}方法二：Java自带的方法
Arrays类里面的.sort（数组名）方法，默认将数组内容升序排列：
int[] a = new int[]{1,22,5,33,66,55,9};
Arrays.sort(a);
System.out.println(Arrays.toString(a));2.10 数组的拷贝
方法一：
自己创建方法实现
public static void main(String[] args) {
//数组的拷贝
int[] a = new int[]{1,2,3,4,5};
int[] b = myCopyArray(a);
System.out.println(Arrays.toString(b));
}
public static int[] myCopyArray(int[] a) {
int[] b = new int[a.length];
for (int i = 0; i < a.length; i++) {
b[i] = a[i];
}
return b;
}方法二：
Java中自带的方法
Arrays类中的copyOf(拷贝的数组名，新数组的长度）；
int[] a = new int[]{1,2,3,4,5};
int[] c = Arrays.copyOf(a,a.length);
System.out.println(Arrays.toString(c));Arrays类里面还有一种方法可以指定数组范围拷贝：copyOfRange(拷贝的数组名，拷贝开始的下标，拷贝结束的下标）；
int[] a = new int[]{1,2,3,4,5};
int[] d = Arrays.copyOfRange(a,2,4);
System.out.println(Arrays.toString(d));注意：拷贝方法的底层方法代码由C/C++代码书写，被关键字native修饰的方法是由C/C++代码书写的，运行效率高，查看不了源代码。
2.11 数组逆序
将数组中的元素逆序输出：
public static void main(String[] args) {
//数组逆序
int[] a = new int[]{1,2,3,4,5};
move(a);
System.out.println(Arrays.toString(a));
}
public static void move(int[] a) {
int left = 0;
int right = a.length - 1;
while(left < right) {
int tmp = a[left];
a[left] = a[right];
a[right] = tmp;
left++;
right--;
}
}2.12 Arrays类部分方法
查找数组指定元素（二分查找）
Arrays.binarySearch(数组名，查找元素）；返回查找元素下标，若不存在查找元素，返回最后一次二分查找的左下标 + 1 取负数。
//查找数组指定元素
int[] a = new int[]{1,2,3,4,5};
int b = Arrays.binarySearch(a,4);
int c = Arrays.binarySearch(a,2,4,3);
System.out.println(b);
System.out.println(c);数组的拷贝
Arrays.copyOf(拷贝的数组名，新数组的大小）；返回拷贝的新数组。
int[] a = new int[]{1,2,3,4,5};
int[] c = Arrays.copyOf(a,a.length);
System.out.println(Arrays.toString(c));Arrays.copyOfRange(拷贝的数组名，拷贝开始下标，拷贝结束下标）；拷贝数组指定范围的数据到新数组。
int[] a = new int[]{1,2,3,4,5};
int[] d = Arrays.copyOfRange(a,2,4);
System.out.println(Arrays.toString(d));判断两个数组是否相等
Arrays.equals(数组1，数组2）；比较数组1和数组2里面的内容是否相等。相等返回true,不相等返回false。
//比较两个数组是否相等
int[] arr1 = new int[]{1,2,3,4,5};
int[] arr2 = new int[]{1,2,3,4,5};
boolean d = Arrays.equals(arr1,arr2);
System.out.println(d);数组的赋值
Arrays.fill(数组名，值）；将值赋值给数组的所有元素。
//数组赋值
int[] arr3 = new int[]{1,2,3,4,5};
Arrays.fill(arr3,6);
System.out.println(Arrays.toString(arr3));fill方法的重载：Arrays.fill(数组名，赋值开始坐标，赋值结束坐标，值);指定数组范围赋值。
//数组赋值
int[] arr3 = new int[]{1,2,3,4,5};
Arrays.fill(arr3,2,4,6);
System.out.println(Arrays.toString(arr3));数组的排序（升序）
Arrays.sort(数组名)；对数组内的元素进行升序排列。
int[] a = new int[]{1,22,5,33,66,55,9};
Arrays.sort(a);
System.out.println(Arrays.toString(a));数组转换成字符串
Arrays.toString(数组名）；将数组转换成字符串[1，2，3，4，5]。
//数组转换成字符串
int[] arr4 = new int[]{1,2,3,4,5};
System.out.println(Arrays.toString(arr4));二维数组转换成字符串
Arrays.deepToString(数组名) ；将二维数组转换成[ [1,2,3],[4,5,6] ]。
//二维数组转换成字符串
int[][] a = new int[][]{{1,2,3},{4,5,6}};
System.out.println(Arrays.deepToString(a));3. 二维数组
3.1 二维数组的定义和初始化
下面是定义并初始化数组的写法：
int[][] a = new int[2][3];
int[][] b = new int[][]{{1,2,3},{4,5,6}};
int[][] c = {{1,2,3},{4,5,6}};
int[][] d;
d = new int[2][3];
int[][] f;
f = new int[][]{{1,2,3},{4,5,6}};3.2 数组的遍历
二维数组是特殊的一维数组，假设二维数组int[][] arr = new int[][]{{1,2,3},{4,5,6,}}，arr指向的对象是一维数组，里面存放两个一维数组对象的地址，而两个地址位置分别是两个一维数组。
关系如下图：
方法一：循环遍历
public static void main(String[] args) {
int[][] a = new int[][]{{1,2,3},{4,5,6}};
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println();
}
}方法二：for-each遍历
public static void main(String[] args) {
int[][] a = new int[][]{{1,2,3},{4,5,6}};
for(int[] b : a) {
for(int c : b) {
System.out.print(c + " ");
}
System.out.println();
}
}方法三：Java自带的方法
Arrays.deepToString(数组名）；作用是将二维数组转换成字符串
System.out.println(Arrays.deepToString(a));打印结果：
3.3 不规则二维数组
Java中定义数组时不可以省略行的值，可以省略列的值：
public static void main(String[] args) {
int[][] a = new int[2][];
a[0] = new int[3];
a[1] = new int[4];
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println();
}
}上面数组a就是不规则数组，第一行有三列，第二行有四列。
打印出来是：
在堆中存储如下：
开源鸿蒙跨平台开发社区汇聚开发者与厂商，共建“一次开发，多端部署”的开源生态，致力于降低跨端开发门槛，推动万物智联创新。
更多推荐
42
0- 0
已为社区贡献2条内容
所有评论(0)