Day02
定义方法:
两个明确
1)明确返回值类型: mei有返回值用void 代替.
2)明确参数类型以及参数个数:int 1个参数.
格式在同一个类下:public static void 方法名(形式参数列表){
...
}
import java.util.Scanner ;
class FunctionDemo{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请输入一个数据N(1-9):") ;
int n = sc.nextInt() ;
//调用方法:打印nn乘法表
printNN(n) ;
System.out.println("--------------------------------") ;
//打印z行m列的*形
System.out.println("请输入行数z:") ;
int z = sc.nextInt() ;
System.out.println("请输入列数m:") ;
int m = sc.nextInt() ;
//调用方法
printStar(z,m) ;
}
/*
定义方法:
两个明确
1)明确返回值类型:void代替
2)明确参数类型以及参数个数: int 两个参数
*/
public static void printStar(int z,int m){
for(int x = 0 ; x <= z ; x ++){
for(int y = 0 ; y <= m ; y ++){
System.out.print("*");
}
System.out.println();
}
}
/*
定义方法:
两个明确
1)明确返回值类型: 用void 代替
2)明确参数类型以及参数个数:int 1个参数
*/
public static void printNN(int n){
//外层循环控制行数
for(int x = 1 ; x <= n ; x ++){
//内层循环列数在变化: <=x
for(int y =1 ; y <=x ; y ++){
System.out.print(x+"*"+y+"="+(y*x)+"\t") ;
}
System.out.println() ;
}
}
}方法重载(OverLoad):方法名相同,参数列表不同,与返回值无关!(多个功能都是一样的,又做到方法名要见名知意)
参数列表不同:
1)参数个数不一样
2)参数类型不一样
数组中的基本元素查找法:
基本查询
在数组中从头查找到末尾
高级查询: 二分搜索法(数组 折半查找)
已知一个数组,静态初始化
int[] arr = {69,78,34,200,120} ;
需求:查询34这个元素在数组的角标值(默认int)
分析:
1)创建一个数组,静态初始化
2)定义一个功能:查询元素在数组的角标值的功能
两个明确
1)明确返回值类型: int
2)明确参数类型以及参数格式
两个参数:
int[] arr
int target/key
方式1:
以后在判断:无非两种情况:要么成立,要么不成立!
先去遍历数组中的所有元素,一一获取每一个元素
判断:如果当前要查询的target元素和arr[x]元素一致
找打了,直接x返回;
如果找不到呢?
在Java中:如果元素在数组中没有找到,返回负数:-1
class ArratTest6{
public static void main(String[] args){
//已知一个数组,静态初始化
int[] arr = {69,78,34,200,120} ;
//查询34这个元素第一次在数组中出现索引值
//int index = getIndex(arr,34) ;
int index = getIndex2(arr,120) ;
System.out.println("index:"+index) ;
//int index2 = getIndex(arr,250) ;
int index2 = getIndex2(arr,300) ;
System.out.println("index2:"+index2) ;
}
//方式2:
//使用一种假设思想
public static int getIndex2(int[] arr,int key){
//定义一个变量index
int index = -1 ; //假设找不到
//遍历arr数组
for(int x = 0 ; x < arr.length ; x ++){
//判断
if(arr[x] == key){
index = x ;
break ;
}
}
return index ;
}
//方式1:
//定义一个功能
//参数1:在指定的数组中查询
//参数2:要查找的元素
public static int getIndex(int[] arr,int target){
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
//获取到元素
//判断:如果当前要查询的target元素和arr[x]元素一致
if(target == arr[x]){
return x ; //找到了
}
}
//找不到
return -1 ;
}
}数组的静态初始化:给定了数组的元素的内容,由系统指定数组的长度
格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3...} ;(推荐)
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3...} ;
简写方式:
数据类型[] 数组名称 = {元素1,元素2,元素3...} ;
int[] arr = {1,2,3,4,5,6} ;
注意:
不能动静初始化(要么动态初始化,要么静态初始化!)
int[] arr = new int[3]{1,2,3} ; 错误的
在数组注意问题:
1)数组角标越界异常:ArrayIndexOutOfBoundsException
出现的原因:访问了数组中不存在的索引值,索引值是非法!(大于或者等于数组长度,索引值为负)
解决方案:及时检查错误,然后更新代码!
数组是引用类型,引用类型的默认值是null(空对象),
空指针异常:NullPointerException
出现的原因:
1)在数组中的,数组对象已经为null,还要访问里面的元素
2)在后期可能会使用某些类的功能的时候,但是这个类的对象已经为null了
解决方案:(在idea中,使用断点来调试程序!debug)
在某段代码中,如果出现空指针,在使用该对象的时候,进行非空判断!
数组的最值
需求:给定一个数组,静态初始化,获取数组中的最大值
class ArrayTest3{
public static void main(String[] args){
//指定一个数组,静态初始化
int[] arr = {69,45,87,13,24} ;
//定义一个参照物:
int max = arr[0] ; //arr[0]它是最大值
//遍历数组中的后面元素,1开始
for(int x = 1 ; x < arr.length ; x ++){
//判断:使用后面的元素依次和这个max进行比较
//如果后面的元素都大于max
if(arr[x]> max){
//改变max的值
max = arr[x] ;
}
}
System.out.println("数组中的最大值是:"+max) ;
System.out.println("----------------------") ;
int max2 = 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] ;
for(int x = 1; x < arr.length ; x ++){
if(arr[x] < min){
min = arr[x] ;
}
}
return min ;
}
/*
定义一个求最大值的方法
两个明确
1)明确返回值类型:int
2)明确参数类型以及参数个数
int[] 1个参数
*/
public static int getMax(int[] arr){
//定义有一个参照物
int max = arr[0] ;
//遍历其他元素
for(int x = 1 ; x < arr.length ; x ++){
if(arr[x] > max){
max = arr[x] ;
}
}
return max ;
}
}元素逆序
需求:
已知数组,静态初始化,将元素逆序!
举例:
int[] arr = {14,69,24,78,52} ;
分析:
1)已知数组,静态初始化
2)
需要将arr[0]和arr[arr.length-1] 对应的元素进行互换
arr[1]和arr[arr.length-1-1] 对应的元素进行互换...
...
...
保证数的长度arr.length/2class ArrayTest4{ public static void main(String[] args){ //创建数组,并静态初始化 int[] arr = {14,69,24,78,52} ; 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: 定义方法:逆序的方法 两个明确 1)明确返回值类型:void 2)明确参数类型以及参数格式:int[] 数组 1个参数 需要将arr[0]和arr[arr.length-1] 对应的元素进行互换 arr[1]和arr[arr.length-1-1] 对应的元素进行互换... ... ... 保证数的长度arr.length/2 */ public static void reverse(int[] arr){ 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]+", ") ; } } } }
冒泡排序:
两两比较,将较大的值往后方法,第一次比较完毕,最大值出现在最大索引处!
依次这样比较...
最终比较次数:数组长度-1次
class ArrayTest{
public static void main(String[] args){
//创建一个数组,静态初始化
int[] arr = {24,69,87,56,13} ;
System.out.println("排序前:") ;
printArray(arr) ;
System.out.println("-------------------") ;
bubbleSort(arr) ;
printArray(arr) ;
}
//定义一个冒泡排序的功能
//两个明确:明确返回值类型: void
//明确参数类型以及参数个数:int[] 一个参数
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length-1 ; x ++){ //比较4次
for(int y = 0 ; y < arr.length-1-x ; y++){
//判断
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = 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]+", ") ;
}
}
}
}
扫一扫
171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
