这篇博客主要介绍了数组的遍历、求和、最值、逆序以及基本元素查询等操作。通过示例代码展示了如何使用循环和方法优化数组处理，包括遍历输出数组、求数组元素之和、找到数组中的最大值以及实现数组的逆序。此外，还讨论了数组查表法和二分查找法在数组查询中的应用。
/*
数组的应用
1)遍历数组
遍历数组:就是将数组中的元素一一输出
输出
[11, 22, 33, 44, 55]
*/
class ArrayTest{ public static void main(String[] args){ //创建一个数组,静态初始化 int[] arr = {11,22,33,44,55} ; //遍历arr数组 //原始的做法: //通过数组名称来访问 //arr[角标] System.out.println(arr[0]) ; System.out.println(arr[1]) ; System.out.println(arr[2]) ; System.out.println(arr[3]) ; System.out.println(arr[4]) ; System.out.println("-------------------------------") ; //很麻烦:冗余度很大---循环思想改进 for(int x = 0 ; x < 5 ; x ++){//x就是角标:0,1,2,3,4 System.out.println(arr[x]) ; } System.out.println("-------------------------------") ; //创建一个新的数组,静态初始化 int[] arr2 = {11,1,2,3,4,5,6,7,8,100,45,23,13,46,78,69} ; //如果数组中的元素很多,数它多少个,很麻烦,,, ,, //在数组中有一个属性length:可以很快获取数组长度 数组名称.length System.out.println(arr2.length) ; System.out.println("-------------------------------") ; //我们将上面的arr数组---继续优化改进 for(int x = 0 ; x < arr.length ; x ++){//最大的角标值= 数组的长度-1 ; System.out.println(arr[x]) ; } System.out.println("======================方法调用==========================") ; //我们现在学习了方法,将遍历数组使用方法改进! //没有具体返回值类型的方法---调用 单独调用 printArray(arr) ; } /* 定义方法两个明确 1)明确返回值类型 void代替 2)明确参数类型以及参数个数 参数类型:int[] 1个参数 */ public static void printArray(int[] array){ //形式参数数一个数组 for(int x = 0 ; x < array.length ; x ++){//最大的角标值= 数组的长度-1 ; System.out.println(array[x]) ; } } }
空指针异常
//导包 import java.util.Scanner ; class Demo{ public static void main(String[] args){ //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //很明显--赋值为null sc = null ; //提示并录入数据 System.out.println("请您输入一个数据int类型: ") ; if(sc!=null){ int a = sc.nextInt() ; System.out.println("您录入的数据是:"+a) ; }else{ System.out.println("键盘录入对象为空,无法录入数据!") ; } } }
/*
需求:
求数据之和---使用方法调用完成
分析:
没有说几个数据之和?
我可以定义一个方法,求两个数据之和
定义一个方法,求三个数据之和
定义一个方法,求四个数据之和
....
定义完成,分别输出调用了,没有任何问题!
但是,很早讲"标识符"---定义方法,见名知意!
这些方法不都是求和吗?,只是参数个数不同,这个时候,提供了技术---
方法重载(OverLoad)
当方法的功能都是相同的,
我们可以定义同名的方法,参数列表不同,跟返回值无关,可以提高这个功能的扩展性!
方法重载:---为了提供某个功能的扩展性
方法名相同,参数列表不同,与返回值无关!
参数列表不同:
1)参数个数不同
2)参数类型不同
3)考虑参数类型的顺序
*/class FunctionDemo{ public static void main(String[] args){ //调用方法---为了简单一些,直接输出调用了 System.out.println(sum(10,20)) ; //System.out.println(sum2(10,20,30)) ; //System.out.println(sum3(10,20,30,40)) ; System.out.println(sum(10,20,30)) ; System.out.println(sum(10,20,30,40)) ; } //定义求两个数据之和的方法 /* 两个明确: 1)明确返回值类型 int 2)明确参数类型以及参数个数 int ,2个 */ public static int sum(int a,int b){ return a + b ; } //定义求三个数据之和的方法 //public static int sum2(int a,int b,int c){ //优化 public static int sum(int a,int b,int c){ return a + b +c ; } //定义求四个数据之和的方法 //public static int sum3(int a,int b,int c,int d){ public static int sum(int a,int b,int c,int d){ return a+b+c+d ; } //两个double类型求和 public static double sum(double a,double b){ return a+b ; } /* public static double sum(int a,double b){ return a+b ; } public static double sum(double a,int b){ return a+b ; } */ }
/*
数组的遍历 :
定义一个数组,静态初始化,将数组中的元素按照下面格式输出
[元素1, 元素2, 元素3, 元素4 ....元素n] ,使用方法调用完成
*/class ArrayTest{ public static void main(String[] args){ //定义一个数组,静态初始化 int[] arr = {11,22,33,44,55} ; //按照指定的格式遍历数组 //[元素1, 元素2, 元素3, 元素4 ....] printArray(arr) ;//实际参数传递的就是数组对象! } /* 定义方法:两个明确 1)明确返回值类型,没有具体返回值类型 void 2)明确参数类型以及参数个数 数组类型,1个 */ public static void printArray(int[] array){//形式参数 //[元素1, 元素2, 元素3, 元素4 ....元素n] //打印一个左中括号"[",不换行 System.out.print("[") ; //遍历数组---格式 for(int x = 0 ; x <array.length ; x ++){ //array[x]---可以获取到每一个元素了 //判断当前x--索引值---是否取到了最大索引值 if(x == array.length-1){//数组的最大索引值=数组长度-1 //获取到了最后的元素---以及右中括号 "]",换行不换行都可以! System.out.println(array[x]+"]") ; }else{ //就是中间元素,拼接", ",在同一行上 System.out.print(array[x]+", ") ; } } } }
/*
数组的最值问题:
已知一个数组,静态初始化了
int[] arr = {69,87,52,13,24} ;
求arr数组中的最大值,使用方法完成!
最值问题:
最大值/最小值
可以参照物方式---假设思想
*/class ArrayTest2{ public static void main(String[] args){ //已知一个数组,静态初始化了 int[] arr = {69,87,52,13,24} ; //不使用方法调用 //先完成 //定义一个参照物,arr[0] 就是最大值 int max = arr[0] ; //从角标1遍历其他元素 for(int x = 1 ; x < arr.length ; x++){ //获取到了每一个元素 //判断:使用后面的元素依次和参照物max进行对比 if(arr[x] > max){ //后面的元素大 //重新赋值新的元素给max变量 max = arr[x] ; } } //输出即可 System.out.println("当前数组中的最大值是:"+max) ; System.out.println("------------------------------------") ; //继续优化:使用方法改进 int max2 = getArrayMax(arr) ; System.out.println("当前数组中的最大值是:"+max2) ; } //定义一个求数组最大值的方法 /* 两个明确 1)明确返回值类型 int 2)明确参数类型以及参数个数 int[] 数组,1个参数 */ public static int getArrayMax(int[] array){ //定义参照物 int max = array[0] ; //遍历其他元素 for(int x =1 ; x < array.length ; x ++){ //使用后面的元素依次和参照物max进行对比 if(array[x] > max){ max = array[x] ; } } return max ;//返回 } }
/*
数组逆序
逆序:就是将数组中的一个元素和最后一个元素互换
将数组中的第二个元素和倒数第二个元素进行互换
...
int[] arr = {69,87,52,13,24,....} ;
69 -- 24 互换
87 -- 13 互换
....
分析:
arr[0]和arr.length-1互换
arr[1]和arr.length-1-1 换行
...
...
保证数组的长度 arr.length/2
先将原始数组---进行遍历---
逆序之前:
输出([元素1, 元素2, 元素3, 元素4...元素n])
调用逆序的方法(完成逆序)
逆序之后:
输出([元素1, 元素2, 元素3, 元素4...元素n])
*/
class ArrayTest3{ public static void main(String[] args){ //定义数组,静态初始化 int[] arr = {69,87,52,13,24} ; //System.out.println("逆序前: ") ; //先遍历---输出结果 //printArray(arr) ; //System.out.println("-----------------------------") ; //调用逆序的方法 //System.out.println("逆序后: ") ; //reverse(arr) ; //遍历输出结果: printArray(arr) ; System.out.println("-------------方式2----------------"); System.out.println("逆序前:") ; printArray(arr) ; //方式2: System.out.println("逆序后: ") ; reverse2(arr) ; //遍历输出结果: printArray(arr) ; } //方式2: 遍历数组,定义两个变量,起始索引,最终索引 //起始索引从0开始,最终索引:arr.length-1开始,起始索引不断++,最终索引不断-- //起始索引< 最终索引 public static void reverse2(int[] arr){ for(int start = 0 ,end = arr.length-1 ; start<end ; start++,end --){ //互换 //中间变量 int temp = arr[start] ; arr[start] = arr[end] ; arr[end] = temp ; } } /* 定义一个数组逆序的方法 两个明确 1)明确返回值类型 void 2)明确参数类型以及参数个数 int[] 数组 ,1个参数 */ public static void reverse(int[] array){ /* //第一次互换 //就使用中间变量的方式互换 int temp = array[0] ; //将array[array.lenght-1] 赋值给array[0] array[0] = array[array.length-1] ; array[array.length-1] = temp ; //第二次互换 temp = array[1] ; //将第二个元素和倒数第二个元素互换arr.length-1-1 array[1] = array[array.length-1-1] ; array[array.length-1-1] = temp ; ...第三次互换 ...第四次互换 */ //上面太麻烦了.... 循环改进,遍历数组,保证数组的长度 arr.length/2,进行互换即可 for(int x = 0 ; x < array.length/2 ; x ++){//x=0,1,2,...arr.length-1 //互换 int temp = array[x] ; array[x] =array[array.length-1-x] ; array[array.length-1-x] = temp ; } } //遍历数组的方法 public static void printArray(int[] array){ System.out.print("[") ; //遍历数组array for(int x = 0 ;x < array.length ; x ++){ //判断x是否取到最大索引值,取到了最大索引值, //获取最后一个元素以及输出"]" if(x == array.length-1){ System.out.println(array[x] +"]") ; }else{ //中间的元素输出,同时不换行的输出", " System.out.print(array[x] +", ") ; } } } }
/*
数组的基本查表法
就是通过数组的对象名称[索引值]----获取元素内容
需求:
有个字符串数组?String----特殊的引用类型
创建数组:
静态初始化
数据类型[] 数组名称= new 数据类型[]{元素1, 元素2...} ;
数据类型[] 数组名称 = {元素1, 元素2...} ; //简写格式
int[] arr = {.....} ;
字符串数组
String[] weeks =
{"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
键盘录入指定的数据, (0-6的范围),通过数组查表法:通过角标查询元素!
数据结构:
底层数据结构:(先去了解)
数组: 查询快(角标就直接访问),增删慢
链表:由数据域和指针域组成:
查询慢(从链表开头查),
增删快
*///导包 import java.util.Scanner ; class ArrayTest4{ public static void main(String[] args){ //字符串数组,静态初始化 String[] weeks = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ; //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //提示并录入数据 System.out.println("请您输入一个数据: ") ; int n = sc.nextInt() ; if(n>=0 && n<=6){ System.out.println("您要查找的是:"+weeks[n]) ; }else{ System.out.println("录入的数据,不再数据表的范围内...") ; } } }
/*
数组的基本元素查询:
这种情况,查元素第一次出现的索引值,每次从头查询到尾
这个数组:
皆可以无序,也可以有序!
高级查询---二分搜索法 ----"折半思想查找" (后面讲)
前提条件: 只能针对数组有序的情况下
*/class ArrayTest5{ public static void main(String[] args){ //创建一个数组,静态初始化 int[] arr = {11,45,5,78,96,13} ; //无序的数组 //调用一个方法,查询 45这个元素的索引值 int index = getIndex(arr,45) ; System.out.println("当前该元素的索引值是:"+index) ; //调用一个方法,查询 450这个元素的索引值 int index2 = getIndex(arr,450) ; System.out.println("当前该元素的索引值是:"+index2) ; System.out.println("------------------------------------------") ; int index3 = getIndex2(arr,250) ; System.out.println("index3:"+index3) ; int index4 = getIndex2(arr,78) ; System.out.println("index4:"+index4) ; } //方式2: public static int getIndex2(int[] array,int target){ //使用假设思想: //先定义变量index:就是我们的索引值 int index = -1 ; //找不到 //遍历指定的array数组 for(int x = 0 ; x < array.length; x ++){ //获取到了所有元素, //判断:如果当前array[x]== target 一致,找到了 if(array[x] == target){ //重新改变index 的值 index = x ; break ; } } return index ; } /* 定义一个方法,查询在指定数组中的指定元素出现的索引值 两个明确 1)明确返回值类型 int 2)明确参数类型以及参数个数 2个参数 int[] array 数组 int target 目标元素 */ public static int getIndex(int[] array,int target){ //遍历数组 for(int x = 0 ; x < array.length ; x ++){ //获取到每个数组中的元素 //判断 //如果当前array[x] == target ----找到了元素了 if(array[x] == target){ //返回x--索引值 return x ; } } //如果上面循环中找不到这个元素,就说明没有这个元素,方法调用完毕,必须结果值 return -1 ;//找不到 } }
扫一扫
1086
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
