二：Java的方法跟数组
1-1:方法的格式
语法：
访问修饰符 其他修饰符 返回值类型 方法名(参数1、参数2){//形参列表
//方法体
return 返回值；
}
public：访问修饰符
static：静态修饰符。描述得方法可以直接调用
void：返回值（无返回值）
GetMenu:定义一个方法
public static void main (String[] args){}
GetMenu();//调用这个GetMenu方法，方法写了几次意味着调用几次
}
//定义一个方法，在调用的时候是不会运行的
public static void GetMenu(){
System.out.println("宫保鸡丁");
System.out.println("辣子鸡");
System.out.println("猪头肉");
System.out.println("红烧肉");
}
}
1-2：方法的调用：
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要打印的星星");
int line = scanner.nextInt();
Star(line);//调用Star方法
}
public static void Star(int num) {//带参数的方法
//形参：在方法定义的时候的参数成为形参
for (int i = 1; i <= num; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
1-3：方法的形参与实参：
参数：
实际参数：就是实际参与运算的；
形式参数：就是方法定义上的，用于接收实际参数的
参数类型：就是参数的数据类型
参数名：就是变量名
方法体的语句：就是完成功能的代码
注意：
1、若当前方法中不使用形参，那么形参列表中可以为空
2、实参和形参的类型相互兼容、且实参额取值范围要小于或者等于形参类型的取值范围
在调用方法中：如果我们定义的方法有参数，就必须在调用方法的同时传入这个值，即给当前方法中的参数赋值，而传入的值我们成为实际参数，也就是实参
实参：传入参数值
形参：接收实参穿过来的值
注意：实参名与形参名一致，也可以不同
小结：形参就是一个变量，实参就是一个值，传参就是一个值给一个形参赋值
1-4：方法的返回值
return：结束方法
返回值：这个就是功能的结果，有return带给调用者
注意：
1、如过当前方法没有返回值类型，机返回值是void，那么当前方法中不写return
2、return机表示结束一个方法，也可以将返回值返回给调用当前方法的调用者
3、return返回值一次只能返回一个值，不可以返回多个值
4、一个方法中可以有多个return，但是被执行的只能有一个
1-4：方法的重载：
方法名一致，参数不一致就是重载
方法名不一致，参数一致就是重写
返回值不能作为重载的条件
1-5：数组：一个能够存储相同数据类型的变量集合
1-6：数组的赋值方式：四种
1-6-1：数组元素类型【】 数组名 = new 数组元素类型【数组中的元素个数（数组的度）】；
int【】 scores = new int [3];
1-6-2：数组元素类型【】 数组名；
数组名 = New 数组元素类型【数组中元素的个数（数组的长度）】
int[] scores;
1-6-3：数组元素类型 【】 数组名 = New 数组元素类型【】{元素1，元素2.。。。。。}；
int【】 scores = New int[] {1,2,3,4,5,6}；
1-6-4：数组元素类型【】数组名 = {元素1，元素2，。。。。}
int【】 scores ={54，55，56.。。。。}；
1-6-5：数组一定要有长度、数组中的每个数据称为元素、数组元素的位置为0开始，数组的位 置称为下标
1-7：数组的遍历问题：
遍历：依次取出数组中的每一个元素
语法：普通的for循环：
public static void main(String[] args) {
int[] scores = {21, 22, 23, 24, 25};
System.out.println("请输出数组的长度:" + scores.length);
//遍历
int len = scores.length 数组的长度不变
for (int i = 0; i < len; i++) {
int score = scores[i];
System.out.println(score);
}
//System.out.println(scores);
}
1-8：foreach循环，并使用调用方法：
public static void main(String[] args) {
int[] scores = {21, 22, 23, 24, 25};
System.out.println("请输出数组的长度:" + scores.length);
//foreach 1.5之后的内容
for (int x : scores) {
System.out.print(x + "t" + "n");
}
print(scores);
}
public static void print(int[] x) {
int len = x.length;
for (int i = 0; i < len; i++) {
System.out.print(x[i]);
}
}
1-9：数组的异常：
2-0：数组的内存结构分析：数组是引用类型：存在堆内存
栈内存：用于存储局部，临时变量（基本数据类型）和引用变量；它的的大小是固定的
堆内存：大小不固定：存对象
2-1：数组排序算法：
1、原理：比较相邻的元素，如果第一个比第二个大，就做交换：
冒泡排序的算法：
public static void main (String [] args){
int [] nums = {21,19,23,26,286,54,31,94};
for(int i =0 ;i< nums.length;i++){
for (int j=0;j< nums.length-1-i;j++){
//num[j]>numd[j+1]是从小到大，泛指则是从从大到小
if (nums[j]>nums[j+1]){//控制从大到小或者从小到大的顺序
nums[j] = nums[j]+nums[j+1];
nums[j+1] = nums[j]-nums[j+1];
nums[j] = nums[j]-nums[j+1];
}
}
}
for (int n : nums){
System.out.println(n);
}
}
2-2:二分查找算法：
public static void main(String[] args) {
//必须保证正整是有序的
int[] num = {10, 20, 30, 40, 50, 60, 70};
int index = biarySeach(num, 100);
System.out.println(index);
}
//从0的下标开始照数据
//二分查找算法
public static int biarySeach(int[] num, int key) {
int start = 0;//开始下标
int end = num.length - 1;//结束下标
while (start <= end) {
int middle = (start + end) / 2;//>>1
if (num[middle] > key) {
end = middle - 1;
} else if (num[middle] < key) {
start = middle + 1;
} else {
return middle;
}
}
return -1;
}
2-3：数组的工具类：Arrays工具类：用来操作数组（比如排序跟搜索）的个中方法
2-4：二分查找1：Arrays.binarySearch：查找数值内部那个数值，从0开始数
public static void main(String [] args){
int [] num = {10,20,30,40,50,60};
int index = Arrays.binarySearch(num,60);
System.out.println(index);
}
2-5：二分查找二：Arrays.toString(num方法：
public static void main(String [] args){
int [] num = {10,20,30,40,50,60};
int index = Arrays.binarySearch(num,60);
System.out.println(index);
for (int n :num){
System.out.println(Arrays.toString(num));输出整个数组
}
}
2-6：数组排序：Arrays.sort(num)
public static void main(String [] args){
int [] num = {15,89,32,75,68,10,6,89,32};
Arrays.sort(num);
System.out.println(Arrays.toString(num));
}
2-7：数组的复制：Arrays.copyOf(X,z) z:代表着是复制某一个数组内部，具体多少个数值
public static void main(String [] args){
int [] num = {15,89,32,75,68,10,6,89,32};
Arrays.sort(num);
System.out.println(Arrays.toString(num));
//数组的复制
int [] num1 =Arrays.copyOf(num,9);//复制上面的数组内部的几个数值
System.out.println(Arrays.toString(num1));
}
效率从高到底排序是：System.arraycopy()->arrays.copyof->for
2-8：判断两个数组的值是否相等：Arrays.equals:直接对比两个数组，无取值
public static void main(String [] args){
System.out.println(Arrays.equals(num1,num2));
}
2-9：填充数组：Arrays.fill(num,0)
public static void main(String [] args) {
Arrays.fill(num,0);//val:代表填充到着个数组的数值
System.out.println(Arrays.toString(num));
}
