方法设计（参数及返回值）练习题

0.设计一个方法，用来画星星 倒三角 行数不确定 方向也不确定

//设计一个方法  用来画星星  4*4
//f-->表示方向的意思  f==true  偏左  没有空格  f==false  偏右  带空格
public void drawStar(int line,boolean f){
	for(int i=1;i<=line;i++){
		if(!f){//f==false  偏右  带空格
			for(int j=1;j<=line-i;j++){
				System.out.print(	"  ");
			}
		}
		for(int j=1;j<=i;j++){
			System.out.print("*");
		}
		System.out.println();
	}
}

1.设计一个方法，用来交换两个数组元素a{1,2,3,4} b{5,6,7,8}

public void changeTwoArray(int[] a,int[] b){//f返回值类型为二维数组：int[][]  里面可以装多个数组
	//2.交换数组中的元素
	//方式一  将两个数组内的元素对应位置互换  方式二的设计问题在于
	//用循环的方式挨个交换素组内的元素，性能比较慢
	//交换的时候需要保证两个数组的长度是一致的
	for(int i=0;i<a.length;i++){//每一次找到一个数组中的元素  跟另一个数组对应位置
		int x=a[i];
		a[i]=b[i];
		b[i]=x;
	}
	//方式二  将两个数组的地址引用直接互换
	int[] temp =a;
	a=b;
	b=temp;
}
//如果需要将两个数组返回出去
//int[][] rusult={a,b};
//return result;
//拆开时的代码是
//int[][] value=类对象.changeTwoArray(x,y);
//x=value[0];
//y=value[1];
//返回值类型为：int[][]

//原始的交换
public static void main(String[] args){
	//用来交换两个数组元素
	//1.先有两个数组
	int[] a={1,2,3,4};
	int[] b={5,6,7,8};
	//2.交换数组中的元素
	//方式一  将两个数组内的元素对应位置互换
	for(int i=0;i<a.length;i++){//每一次找到一个数组中的元素  跟另一个数组对应位置
		int x=a[i];
		a[i]=b[i];
		b[i]=x;
	}
	//3.验证一下  看一看
	for(int v:a){
		System.out.println(v);
	}
	System.out.println("------------");
	for(int v:b){
		System.out.println(v);
	}
}

2.设计一个方法，用来交换一个数组（头尾交换）

//是否需要参数及返回值  需要提供一个数组  需要数组返回值
public int[] changggeArrayElements(int[] array){
	//2.数组内部的元素头尾对应互换
	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;
	}
	return array;
}

3.设计一个方法，用来寻找数组中的极值（最大值或最小值）

//需要提供一个数组  需要提供一个值（最大、最小）  返回值肯定需要一个值
public int findMaxOrMinNum(int[] array,boolean flag){//flag==true最大值  flag==false最小值
	//2.找一个变量
	int temp=array[0];
	//2.利用遍历数组的方式挨个与max比较
	for(int i=1;i<array.length;i++){
		if(flag && array[i]>temp){//找寻最大值
			temp=array[i];
		}else if(!flag && array[i]<temp){//找寻最小值
			temp=array[i];
		}
	}
	//3.将找到的值返回
	return temp;
}

4.设计一个方法，用来找寻给定的元素是否在数组内存在（scanner输入一个）

//方法设计了返回值类型  就必须给返回值  编译检测的悲观性原则
public String isExist(int[] array,int element){
	//循环方式找寻是否存在
	String result="对不起  你要的值在数组中没有";
	for(int i=0;i<array.length;i++){
		if(array[i]==element){	
			result="恭喜你  你要的值在数组中存在";
			break;
		}
	}
	return result;
}

5.设计一个方法，用来合并两个数组

//  是否需要参数  需要提供两个数组  需要返回一个大的数组
public int[] mergeArray(int[] a,int[] b){
	//创建一个新的数组
	int[] newArray=new int[a.length+b.length];
	//分别将a和b数组的元素存入新数组内
	for(int i=o;i<a.length;i++){
		newArray[i]=a[i];
	}
	for(int i=0;i<b.length;i++){
		newArray[a.length+i]=b[i];
	}
	//将新数组返回
	return newArray;
}

6.设计一个方法，用来将一个数组按照最大值位置拆分

//需要提供一个大的数组  需要返回值二维数组
public int[][] splitArray(int[] array){
	//找寻最大值索引位置
	int max=array[0];//记录最大值
	int index=0;//记录最大值的索引位置
	for(int i=1;i<array.length;i++){
		if(array[i]>max){
			max=array[i];
			index=i;
		}
	}
	//通过找寻到的index判定数组拆分后的前后长度
	int[] newa=new int[index];
	int[] newb=new int[array.length-index-1];
	//分别将两个小数组填满
	for(int i=0;i,newa.length;i++){
		newa[i]=array[i];
	}
	for(int i=0;i<newb,length;i++){
		newb[i]=array[(index+1)+i];
	}
	//将两个新的小数组一起返回
	//int[][] result={newa,newb};
	return new int[][]{newa,newb};
}

7.设计一个方法，用来去掉数组中的0元素

//需要提供一个数组  还需要提供删除的元素是什么  返回值  一个新的数组
public  int[]  removeElementFromArray(int[] array,int element){
	//找寻原数组中去掉被删除元素后的长度
	int count=0;//记录非删除元素的个数
	for(int i=0;i<array.length;i++){
		if(array[i]!=element){
			count++;
		}
	}
	//通过找到的count创建一个新的数组
	int[] newArray=new int[count];
	int index=0;//控制新数组的索引变化
	//将原来数组中非删除的元素存入新数组中
	for(int i=0;i<array.length;i++){
		if(array[i]!=0){
			newArray[index++]=array[i];
		}
	}
	//将新数组返回
	reture newArray;
}

8.设计一个方法，用来存储给定范围内的素数（2-100）

//是否需要提供条件  begin end  返回值一个装满了素数的数组
public int[]  findPrimeNum(int begin,int end){
	if(begin<0 || end<0){
		System.out.println("素数没有负数  不给你找啦");
		return null;//自定义一个异常  认为规定的一种不正常的现象
	}
	if(begin>end){
		System.out.println("你提供的范围有误  begin应该比end要小");
		return null;//自定义一个异常  认为规定的一种不正常的现象
	}
	//创建一个足够长的数组
	int[] array =new int[(end-begin)/2];
	int index=0;//记录新数组的索引变化  同时记录个数
	for(int num=begin;num<=end;num++){
		boolean b=false;//标记
		for(int i=2;i<num/2;i++){
			if(num%i==0){
				b=true;
				break;
			}
		}
		if(!b){
			array[index++]=num;
		}
	}
	//将数组后面的多余的0去掉
	int[] primeArray=new int[index];
	for(int i=0;i<primeArray.length;i++){
		primeArray[i]=arry[i];
	}
	array=null;
	return primeArray;
}

9.设计一个方法，用来给数组元素排序（冒泡排序算法）既能升序又能降序

//是否需要提供条件--数组  提供一个排序的规则boolean  返回值--不用
//flag==true升序排序    flag==false降序排序
public void orderArray(int[] array,boolean flag){
	for(int i=1;j<array.length;i++){//控制执行的轮次--数组的长度
		//什么情况下可以进行元素的互换
		if((flag==true&& array[j<array[j-1])||(flag==false  && array[j]>array[j-1])){
			int temp=array[j];
			array[j]=array[j-1];
			array[j-1]=temp;
		}
	}
}

//原来的初始冒泡代码
int[] array=new int[]{5,3,4,2,1};
for(int i=1;i<array.length;i++){//控制执行的轮次---数组的长度
	for(int j=array.length-1;j>=1;j--){//控制比较4次
		if(array[j]<array[j-1]){//降序用时改为大于号
			it temp=array[j];
			array[j]=array[j-1];
			array[j-1]=temp;
		}
	}
}
for(int v:array){
	System.out.println(v);
}

10.设计一个方法，用来实现用户登录认证（二维数组当做小数据库）

//方法
public String login(String user,String password){
	//1.需要有一个小数据库---存储用户真实的账号和密码
	String[][]  userBox={{"某某1",“123456”},{“某某2”,“666666”},{"某某3","888"}};//用private修饰
	//4.进行校验
	String result="用户名或密码错误";
	for(int i=0;i<userBox.length;i++){
		if(userBox[i][0].equals(user)){
			if(userBox[i][0].equals(password)){
				System.out.println("登录成功");
			}
			break;
		}
	}
	return result;
}

//原始的代码
//实现一个用户的登录认证
//1.需要有一个小数据库---存储用户真实的账号和密码
String[][]  userBox={{"某某1",“123456”},{“某某2”,“666666”},{"某某3","888"}};
//2.用户输入自己登录的账号和密码
Scanner input=new Scanner(System.in);
//3.提示用户输入账号和密码
System.out.println("请输入账号");
String user=input.nextLine();
System.out.println("请输入密码");
String password=input.nextLine();
//4.进行校验
boolean b=false;//标记
for(int i=0;i<userBox.length;i++){
	if(userBox[i][0].equals(user)){
		if(userBox[i][0].equals(password)){
			System.out.println("登录成功");
			b=true;//如果找到人名  修改标记
		}
		break;
	}
}
if(!b){
	//用户名或密码  有一个不正确就需要输出
	//代码的输出取决于b标记的值  如果与最初的一致没有改过，就可以输出
	System.out.println("用户名或密码错误");//用户名或密码错误
}