Java基础---方法2&Arrays类_java temp=arr-优快云博客

本文链接：https://blog.youkuaiyun.com/qq1476027184/article/details/108107475

方法重载

方法的重载是在同一个类中，方法名相同，参数列表不同的形式叫方法重载
参数列表包括参数的类型、参数的数量和参数的位置

public class OverLoadDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
	//计算两个数的和
	static int getSum(int a,int b) {
		return a+b;
	}
	//计算三个数的和
	static int getSum(int a,int b,int c) {
		return a+b+c;
	}
	//计算四个数的和
	static int getSum(int a, int b, int c, int d) {
		return a+b+c+d;
	}
}

方法的值传递

Java中的参数传递都是值传递
基本数据类型传递是具体的值
引用数据类型传递是引用地址

#方法签名
方法名+参数列表
参数列表：参数类型，顺序，个数

import java.util.Arrays;

public class ParameterPassDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a=1;
		int b=0;
		getSum(a, b);//传递的变量为基本数据类型，传递的是具体的值
		int[] arr= {1,2,3};
		getArrSum(arr);   //引用传递
		System.out.println(Arrays.toString(arr));  //213,2,3    此处用到了Arrays工具类来打印数组
		String nameString="aaa";
		getName(nameString);   //引用传递,由于nameString是讲字符串放入常量池的，所以在方法中修改该引用变量的值时是不会改变实参的值
		System.out.println(nameString);  //aaa
	}
	private static void getName(String nameString) {
		// TODO Auto-generated method stub
		nameString="123456";
		System.out.println(nameString);
	}
	private static void getArrSum(int[] arr) {
		// TODO Auto-generated method stub
		int sum=0;
		for (int i = 0; i < arr.length; i++) {
			sum+=arr[i];
		}
		arr[0]=213;
		System.out.println(sum);
	}
	static void getSum(int a,int b) {
		System.out.println(a);
		System.out.println(b);
		return a+b;
	}
}

可变参数

可以就用来表示0个或者多个同种类型的数据
语法：
	数据类型...变量名（只能用来作为形式参数）
可变参数只能放在参数列表的末尾
它的本质是一个数组
可变参数的遍历可以使用和数组遍历的方式一样

/**
 * @author Administrator
 *	可变参数：指的是0个或者多个同种数据类型
 *		数据类型...变量名   （只能用来作为形式参数）
 *		参数传递：多个同类型的参数用逗号隔开传递
 *		可变参数从本质上来说是一个数组
 *	注意事项：可变参数只能放在参数列表的末尾
 *			一个参数列表不可能有多个可变参数
 */
public class ChangeParameterDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int mySum = getMySum(1,23,34,2);
		System.out.println(mySum);
		int product = getProduct(2,32,4,5);
		System.out.println(product);
	}
	//使用可变参数，设计一个方法，求多个数的和
	static int getMySum(int...param) {
		int sum=0;
		System.out.println(param.length);
		for (int i : param) {
			sum+=i;
		}
		return sum;
	}
	//使用可变参数计算多个数的乘积
	static int getProduct(int...param) {
		int p=1;
		for (int i : param) {
			p*=i;
		}
		return p;
	}
	//设计一个方法，求多个数字的和
	static int getSum(int[] arr) {
		int sum=0;
		for (int i : arr) {
			sum+=i;
		}
		return sum;
	}
}

Arrays工具类:

它里面的方法都是静态方法调用方式:类名.方法名(有参传参)
在使用的时候记得导包: ctrl+shift+o
常用得方法:
	sort：升序排序
	toString：转成String类型
	copyOfRanage：按范围复制
	equals：比较数组中得元素

import java.util.Arrays;

/**
 * @author Administrator
 *	使用工具类导包
 *	1.java.util.Arrays
 *	2.在报错的地方点import导包
 *	3.eclipse快捷键 ctrl+shift+o
 */
public class ArraysDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr= {2,1,4,6,3,7,5,3,8};
		//使用Arrays工具类排序
		Arrays.sort(arr);
		//使用Arrays.toString
		String string = Arrays.toString(arr);
		System.out.println(string);
		int[] arr1 = Arrays.copyOf(arr,arr.length); //复制一个从0开始的指定长度的数组，
		System.out.println(Arrays.toString(arr1));
		int[] arr2 = Arrays.copyOfRange(arr, 2, 6);//复制一个从from开始到to之间的数组，
		System.out.println(Arrays.toString(arr2));
		int index = Arrays.binarySearch(arr, 5);  //二分查找数组中的指定值，返回找到值的索引
		System.out.println(index);
		int hashCode = Arrays.hashCode(arr);   //返回指定数组的哈希码
		System.out.println(hashCode);
		boolean b = Arrays.equals(arr, arr1);  //判断两个数组中元素的值是否全等
		System.out.println(b);
	}
}

自定义工具类和排序算法


import java.util.Arrays;
import java.util.Random;

public class ArrayUtil {
	/**
	 * 	随机生成一个长度为len，范围为from到to的数组
	 * @param len
	 * @param from
	 * @param to
	 * @return int[]
	 */
	public static int[] randomArray(int len,int from,int to) {
		Random rd=new Random();
		int[] arr=new int[len];
		for (int i = 0; i < arr.length; i++) {
			arr[i]=rd.nextInt(to-from)+from;
		}
		return arr;
	}
	//插入排序
	public static void insertSort(int[] arr) {
		//假定前面的数是已排序数，将后面的数插入到已排序的数中
		for (int i = 1; i < arr.length; i++) {
			int temp=arr[i];
			int j;
			for(j=i-1;j>=0&&arr[j]>temp;j--) {
				arr[j+1]=arr[j];
			}
			arr[j+1]=temp;
		}
	}
	//希尔排序
	public static void shellSort(int[] arr) {
		int temp;
		int len=arr.length;
		for (int i = len/2; i > 0; i/=2) {
			//不需要先对一个组排序完再对另一个组进行排序，而是轮流对每个组进行插入排序（减少一层for循环）
			for (int j = i; j < len; j++) {
				temp=arr[j];    //记录第j个数的值
				int k;
				for (k = j-i; k >= 0&&arr[k]>temp; k-=i) { 
					
					arr[k+i]=arr[k];  //根据步数进行往后移动
				}
				arr[k+i]=temp;   //插入第j个数的值
			}
		}
		System.out.println(Arrays.toString(arr));
	}
	
	//快速排序
	public static void quickSort(int[] arr) {
		int l=0;
		int r=arr.length-1;
		quickSort(arr,l,r);
	}
	//递归
	public static void quickSort(int[] arr,int l,int r) {
		if(r>l) {
			int t=partition(arr, l, r);  //基准数排序，最后返回基准数的最后位置  以这个基准数为变准划分新的左右把数组分成两段
			//前一段的右边距为返回的基准数的前一个数，t-1
			//后一段的左边距为返回的基准数的后一个数，t+1
			quickSort(arr,t+1,r);   //分治思想    递归    
			quickSort(arr,l,t-1);
		}
	}
	//以左边第一个数为基准数，把大于基准数的放在右边，小于基准数的放在基准数的左边
	//返回最后基准数放的位置
	public static int partition(int arr[],int l,int r) {
		// 定义基准数
		int t=arr[l];
		while(r>l) {
			while(r>l&&arr[r]>t)
				r--;
			if(r>l)
				arr[l++]=arr[r];
			while(r>l&&arr[l]<t)
				l++;
			if(r>l)
				arr[r]=arr[l];
		}
		arr[l]=t;
		return l;

	}
	//冒泡排序
	public static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = 0; j < arr.length-i-1; j++) {
				if(arr[j]>arr[j+1]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}
	//选择排序
	public static void selectSort(int[] arr) {
		int temp;
		for (int i = 0; i < arr.length-1; i++) {
			temp=i;
			for (int j = i+1; j < arr.length; j++) {
				if(arr[j]<arr[temp]) {
					temp=j;
				}
			}
			int t=arr[temp];
			arr[temp]=arr[i];
			arr[i]=t;
		}
	}
	
	public static void printArray(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length-1; i++) {
			System.out.print(arr[i]+",");
		}
		System.out.println(arr[arr.length-1]+"]");
	}
}