java中的方法和数组---＞常见的一维数组和二维数组的应用

文章目录

java中的方法方法的概念方法的定义方法重载 java中的数组数组的概念一维数组的定义和初始化一维数组的应用1.按照固定的格式[元素1, 元素2, 元素3, 元素4]数组的遍历2.数组中的最值问题3.键盘录入5个数据,组成一个数组(不重复),查询指定元素在数组中第一次出现的索引值!4.数组的逆序5.冒泡排序6.选择排序 数组中常见的异常二维数组的定义和初始化二维数组的应用1.二维数组的遍历2.杨辉三角形 参数传递中的一些注意事项

java中的方法

方法的概念

使用{}将代码包裹起来,并给这个代码起一个名字:方法名 ---->以后直接用这个方法名调用 {}代码块

方法的定义

如何定义方法? 1)有返回值类型的方法的定义 2)没有返回值类型的方法的定义 a.有返回值类型的方法的定义 固定格式: public static 返回值类型 方法名(形参列表){ 业务需求... return 结果; } 有返回值类型的方法调用: a)单独调用 b)输出调用 c)赋值调用 b.没有具体返回值类型的方法定义 public static void 方法名(形参列表){ 直接输出或者其他的业务操作 } 没有返回值类型的方法调用: 一般为直接输出调用 定义有具体返回值类型的方法的定义的注意事项----- 1) 方法和方法是平级,不能进行嵌套 2) 定义方法的两个明确 明确返回值类型 明确参数类型和参数个数 3)定义方法的时候 必须携带参数类型public static int add(int a,int b) 需求: 求两个数据的和,使用方法完成这个需求 class FunDemo{ public static void main(String[] args){ int a = 10; int b = 20; int add = sum(a,b); System.out.println(add); } //明确返回值类型: //明确参数类型以及参数个数 public static int sum(int a, int b){ int x = a + b; return x; } }

方法重载

方法重载: overload 方法名相同,参数列表不同,与返回值无关 参数列表不同: 1)参数类型不同,参数个数相同 2)参数类型相同,参数个数不同 3)参数类型不同,参数个数不同

java中的数组

数组的概念

数组: 引用数据类型 数组: 是可以存储元素的一种容器! 前提: 元素的数据类型必须一致的!

一维数组的定义和初始化

格式: 数据类型[] 数组名称 ; 数据类型 数组名称[] ; 举例: int[] arr; (习惯于第一种) 定义了一个int类型数组arr变量 int arr[] ;定义了一个int类型的arr数组 数组的初始化: 1)动态初始化:指定了数组长度,系统默认给定数组的元素值! 2)静态初始化:指定了具体的元素的内容,系统默认指定数组的长度! 数组的静态初始化 :指定数组的元素内容,系统给它默认长度 格式: 标准格式: 数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ; 数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ; 举例: int[] arr = new int[]{11,22,33} ; 简化格式: 数据类型[] 数组名称 ={元素1,元素2,元素3....} ; 数据类型 数组名称[] ={元素1,元素2,元素3....} ; 举例: int[] arr = {1,2,3} ; 动态初始化: 格式: 数据类型[] 数组名称 = new 数据类型[数组长度] ; 数据类型 数组名称[] = new 数据类型[数组长度] ; 举例: int[] arr = new int[3] ; //创建了一个数组对象,分配3个长度 int arr[] = new int[2] ;//.创建了一个数组对象,分配2个长度 数组中元素的的访问方式: 数组名称[角标]来访问 角标(下标/索引):都是从0开始记录元素的!

一维数组的应用

1.按照固定的格式[元素1, 元素2, 元素3, 元素4]数组的遍历

public static void print(int arr[]){ System.out.print("["); for(int i = 0;i < arr.length;i++){ if(i == arr.length-1){ System.out.print(arr[i]+"]"); }else{ System.out.print(arr[i]+", "); } } }

2.数组中的最值问题

/*分析:假设思想 1)将数组中第一个元素arr[0]看为最大值 2)从角标1开始遍历其他元素 2.1)分别将当前遍历的元素依次和最大值进行比较 如果当前元素大于最大值 将当前元素内容赋值max变量 */ class Test2{ public static void main(String[] args){ //创建一个数组:静态初始化 int[] arr = {13,87,65,24,57} ; //赋值调用 int max = getMax(arr) ; System.out.println("数组中的最大值是:"+max) ; System.out.println("--------------------------------") ; //获取最小值 int min = getMin(arr) ; System.out.println("数组中的最小值是:"+min) ; } public static int getMin(int[] arr){ //参照物 int min = arr[0] ;//假设第一个元素是最小值 //从角标1开始遍历其他元素 for(int x =1 ; x < arr.length ; x ++){ //比较 if(arr[x] < min){ min = arr[x] ; } } return min ; } public static int getMax(int[] arr){ //定义一个参照物 int max = arr[0] ; //从角标1开始遍历其他元素 for(int x = 1 ; x < arr.length ; x ++){ //获取出来了 //分别将当前遍历的元素依次和最大值进行比较 if(arr[x] > max){ max = arr[x] ; } } return max ; } }

3.键盘录入5个数据,组成一个数组(不重复),查询指定元素在数组中第一次出现的索引值!

import java.util.Scanner; class Test2{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); int[] arr = new int[5]; init(arr); System.out.println("当前数组为:"); print(arr); System.out.println("\n"+"需要查询该数组的元素:"); int key = sc.nextInt(); int index = query(arr,key); System.out.println(index); } //对元素的查询,并返回结果index, -1为查询失败. public static int query(int arr[],int key){ int index = -1; for(int i = 0;i < arr.length;i++){ if(arr[i] == key){ index = i; System.out.println("当前查询的值在数组中的位置为:arr["+i+"]"); break; } } return index; } //使用键盘输入的方式给数组赋值 public static void init(int arr[]){ Scanner sc = new Scanner(System.in); System.out.println("请输入数组:"); for(int i = 0;i<arr.length;i++){ arr[i] = sc.nextInt(); } System.out.println("赋值结束-------"); } //按照固定格式遍历数组 public static void print(int arr[]){ System.out.print("["); for(int i = 0;i < arr.length;i++){ if(i == arr.length-1){ System.out.print(arr[i]+"]"); }else{ System.out.print(arr[i]+", "); } } } }

4.数组的逆序

/*数组的应用: 数组的元素逆序 int[] arr = {13,87,65,24,57} ; 中心思想: 将13 arr[0]--57 arr[arr.length-1]互换 将87 arr[1]---24 arr[arr.length-1-1]互换.... 互换次数 == 数组的长度/2 */ class ArrayTest3{ public static void main(String[] args){ //创建一个数组,静态初始化! int[] arr = {13,87,65,24,57} ; System.out.println("数组逆序前: ") ; printArray(arr) ; System.out.println("----------------") ; System.out.println("数组逆序后: ") ; //reverse(arr) ;//逆序方法 reverse2(arr) ; printArray(arr) ;//遍历(输出结果) } //方法2 public static void reverse2(int[] arr){ //start:表示开启索引值 //end:表示最大索引值 for(int start = 0 ,end = arr.length-1 ; start<end ; start ++,end --){ int temp = arr[start] ; arr[start] = arr[end] ; arr[end] = temp ; } } //方法1 public static void reverse(int[] arr){ //遍历数组:保证角标值小于数组长度/2 for(int x = 0 ; x < arr.length/2 ; x ++){ //中间变量方式互换 int temp = arr[x] ; arr[x] = arr[arr.length-1-x] ; //后面的元素和前面的互换 arr[arr.length-1-x] = temp ; } } //数组的遍历功能: public static void printArray(int[] arr){ System.out.print("[") ; for(int x = 0 ; x < arr.length ; x ++){ if(x == arr.length-1){ System.out.println(arr[x]+"]") ; }else{ System.out.print(arr[x] +", ") ; } } } }

5.冒泡排序

/*冒泡排序思想 两两比较,将较大的值往后放;第一次比较完毕,最大值就出现在最大索引处! 依次这样比较: 规律: 第一次:有0个不比 第二次:有1个不比 ... ... 比较的次数:数组长度-1次 */ //键盘录入5个数据组成数组,然后使用冒泡排序将数组排序并进行遍历, //输出格式{元素1, 元素2, 元素3, 元素4 ...} import java.util.Scanner; class Test4{ public static void main(String[] args){ int arr[] = new int[5]; init(arr); print(arr); System.out.println("\n\n"); maoPao(arr); System.out.println("进行冒泡排序--------"); print(arr); } //使用for循环对数组元素进行初始化 public static void init(int arr[]){ Scanner sc = new Scanner(System.in); System.out.println("请输入数组:"); for(int i = 0;i<arr.length;i++){ arr[i] = sc.nextInt(); } System.out.println("赋值结束-------"); } //按照固定格式对数组进行遍历 public static void print(int arr[]){ System.out.print("["); for(int i = 0;i < arr.length;i++){ if(i == arr.length-1){ System.out.print(arr[i]+"]"); }else{ System.out.print(arr[i]+", "); } } } //进行冒泡排序 public static void maoPao(int arr[]){ for(int i = 0; i < arr.length;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; } } } } }

6.选择排序

//自己自定义一个数组,选择排序对数组排序并遍历 class Test5{ public static void main(String[] args){ int[] arr = {5,4,2,6,3,7,8,9,5}; System.out.println("当前数组为:"); print(arr); select(arr); System.out.println("使用选择排序算法进行排序:------"); print(arr); } public static void select(int arr[]){ for(int i = 0; i < arr.length-1;i++){ //假设arr[0]为最小 int min = i; //从arr[0]的下一个开始,分别和arr[0]两两比较 for(int j = i+1;j<arr.length;j++){ //如果arr[0]不是最小,则将最小元素的角标赋值给min; if(arr[j]<arr[min]){ min = j; } } //完成元素之间的交换 if(min != i){ int temp = arr[i]; arr[i] = arr[min]; arr[min] = temp; } } } public static void print(int arr[]){ System.out.print("["); for(int i = 0;i < arr.length;i++){ if(i == arr.length-1){ System.out.print(arr[i]+"]\n"); }else{ System.out.print(arr[i]+", "); } } } }

数组中常见的异常

异常: 后期Throwable:异常的总称 程序出问题了! 严重问题: error : 内存异常了 (通过一些第三方工具避免了!) 举例: 一些软件通过一些特殊的操作:造成软件崩溃了! 异常: Exception: 能够通过本身代码来解决问题 编译时期异常:只要不是运行时期的异常都属于编译时期(不解决,编译通过不了) RuntimeExcetion:运行时期异常 在执行过程中,由于代码结构不严谨,导致的问题! 第一个异常:数组角标越界! java.lang.ArrayIndexOutOfBoundsException: 出现的原因:访问不存在的角标!就出异常了 解决方案:改动角标值即可! 第二个异常:空指针异常: java.lang.NullPointerException: 出现的原因:某个对象都为null,还需要使用对象访问内容或者调用其他功能! 解决方案:只需要对某个对象做一个非空判断!(逻辑判断)

二维数组的定义和初始化

二维数组: 它就是一个包含多个一维数组的数组! 定义格式: 数据类型[] 数组名称[] ; 数据类型[][] 数组名称 ; (推荐) 二维数组的初始化: a.静态初始化: 标准格式: 数据类型[][] 数组名称 = new 数据类型[][]{{元素1,元素2,...},{元素1,元素2...},{元素1,元素2...}}; 简化格式: 数据类型[][] 数组名称 = {{元素1,元素2,...},{元素1,元素2...},{元素1,元素2...}} b.动态初始化: 指定数组长度,系统给数组中元素分配默认值 动态初始化格式1 数据类型[][] 数组名称 = new 数据类型[m][n] ; m:表示当前二维数组中的一维数组的个数 n:表示每一个一维数组的长度 int[][] arr = new int[3][2] ; int[] arr[] = new int[3][2] ; 动态初始化格式2: 数据类型[][] 数组名称 = new 数据类型[m][] ; 数据类型[] 数组名称[] = new 数据类型[m][] ; 举例 int[] arr[] = new int[2][] ; //上面:当前二维arr中有2个一维数组,但是不知道2个一维数组的长度 //所以,需要动态给定一维数组的长度

二维数组的应用

1.二维数组的遍历

//将数组int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}; //这个二维数组遍历，使用功能改进，按照[元素1, 元素2, 元素3， ...]格式输出 class Demo6{ public static void main(String[] args){ int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}; System.out.println("\n"); System.out.print("{"); for(int i = 0;i < arr.length;i++){ System.out.print("{"); for(int j = 0;j< arr[i].length;j++){ //使用逻辑单与,在i,j都取最后一个值即(最后一次循环所取到的最后一个j的值)的时候只输出一个 " } " if(j == arr[i].length-1 & i == j){ System.out.print(arr[i][j]+"},"); // 使用if条件语句,判断在每一次循环中j取到最后一个值的时候输出 " }, " }else if(j == arr[i].length-1){ System.out.print(arr[i][j]+"}"); }else{ System.out.print(arr[i][j]+", "); } } if(i == arr.length-1 ){ System.out.print("}"); } } System.out.println("\n"); } }

2.杨辉三角形

//通过键盘录入n, 产生n*n的杨辉三角形 import java.util.Scanner; class Demo{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("type in :"); int n = sc.nextInt(); int[][] arr = new int[n][n]; for(int i = 0;i<n;i++){ arr[i][0]=1; arr[i][i]=1; } //赋值循环语句 从第三行开始,中间的数值等于上一个数据加上一个数据的前一个数据; for(int i = 2;i<arr.length;i++){ // j < i ; j <= i-1 ; 这两个表达式,都是因为每一行最后一个数据(即i== j 的值)已经赋值了 for(int j = 1;j < i;j++){ arr[i][j] = arr[i-1][j-1]+arr[i-1][j]; } } //类似99乘法表的遍历方式 for(int i = 0; i<arr.length;i++){ for(int j = 0; j <= i;j++){ System.out.print(arr[i][j]+" "); } System.out.println(); } } }

参数传递中的一些注意事项

/* 引用类型作为参数传递 --- > 传递的是一个值(空间地址值) 基本类型作为参数传递 --- > 传递的是一个值(具体的数据值) String类型是一种特殊的引用类型 -----> 字符串是一个常量,一旦被赋值,就不能更改 (属于常量,它们的值创建之后不能更改) 形参的改变对实际参数没有影响 */ class Demo{ public static void main(String[] args){ int a = 10; int b = 20; System.out.println("a:"+a+",b:"+b); // 10 20 //如果形式参数是一个基本类型,形式参数的改变不会影响实际参数 change(a,b); System.out.println("a:"+a+",b:"+b); // 10 20 int[] arr = {1,2,3,4,5}; //如果形式参数是一个引用类型,形式参数的改变会直接影响实际参数!!! System.out.println(arr[1]); // 2 change(arr); System.out.println(arr[1]); // 4 //如果形式参数是String类型的引用类型,形式参数的改变不会影响实际参数 String s = "hello"; System.out.println(s); //hello change(s); System.out.println(s); //hello } public static void change(int a,int b){ System.out.println("a:"+a+",b:"+b); //10 20 a = b; b = a + b; System.out.println("a:"+a+",b:"+b); // 20 40 } public static void change(int[] arr){ for(int x=0; x<arr.length; x++) { if(arr[x]%2==0) { arr[x] *= 2; } } } public static void change(String s){ s += "world"; } }