------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

java语言基础（5）

主要内容：《方法概述和格式、形参和返回值、return语句、重载、数组的概述和定义格式、遍历、获取最值、反转、参数传递

1  方法概述和格式说明

方法(函数)的概念：

1.方法(函数)的作用：最重要的作用"代码重用"

2.定义方法的格式：

修饰符       返回值类型          方法名(形参类型 形参名,形参类型 形参名,....){

//方法体

}

1.修饰符：目前我们就先写：public static (目的是在main()方法中方便调用)

2.返回值类型：任何的Java类型(基本数据类型和引用数据类型)。它表示这个方法的工作的结果，可以返回给调用者；

一个方法可以没有返回值，那么要定义：void

3.方法名：属于自定义标识符。遵循自定义标识符的命名规则和命名规范；

方法名的命名规范，同变量名：首字母小写，多个单词，从第二个单词开始，首字母大写；

4.形参列表：不是必须的。但是一对小括号必须要写

可以包含多个形参，每个形参由"形参类型"和"形参名"组成；

"形参类型"：可以是任何的Java类型(基本类型和引用类型)

"形参名"：实际上就是变量名，它的作用域范围在方法的内部；

 1 class Demo {
 2     public static void main(String[] args) {
 3         System.out.println("Hello World!");
 4         System.out.println("需要打印九九乘法表：调用printJiuJiu方法:");
 5         printJiuJiu();//一定要带着一对小括号，代表方法调用。此时，代码的执行将转向到方法体内。
 6         System.out.println("再次需要打印九九乘法表，再调用一次printJiuJiu方法：");
 7         printJiuJiu();
 8         System.out.println("再次需要打印九九乘法表，再调用一次printJiuJiu方法：");
 9         printJiuJiu();
10         System.out.println("再次需要打印九九乘法表，再调用一次printJiuJiu方法：");
11         printJiuJiu();
12         System.out.println("再次需要打印九九乘法表，再调用一次printJiuJiu方法：");
13         printJiuJiu();
14     }
15     //定义一个方法，打印九九乘法表：
16     public static void printJiuJiu(){
17         //打印九九乘法表的代码
18         for(int i = 1 ;i <= 9 ;i++){
19             for(int j = 1 ; j <= i ;j++){
20                 System.out.print(j + "*" + i + "=" + (j * i) + "\t");
21             }
22             System.out.println();//打印换行
23         }
24     }
25 }

2 方法之形参和返回值

方法的形参和返回值：

1.形参：可以接收外部的数据。然后，方法内部可以根据这个外部数据，去做具体事项；

//定义一个方法：求三个数的最大值。

//确定三件事情：

//1.方法名：getMax

//2.形参：因为要求三个数的最大值，这个值需要从外部传入，所以定义三个int类型的形参：int a,int b,int c

//3.返回值：因为要求三个数的最大值，所以计算结果应该是a,b,c中的最大值，这个值要返回给调用者；返回值为int

2.返回值：将方法内部的一些操作的结果返回给调用者

 1   public static int getMax(int a, int b , int c){
 2                     //a = 43243,b = 432, c = 432154
 3
 4                             int max = a > b ? ( a > c ? a : c) : (b > c ? b : c);
 5
 6                             return max;
 7
 8               }
 9
10 }            

需求：求三个数的最大值；

 1 class Demo {
 2
 3               public static void main(String[] args){
 4
 5                             //调用方法，求三个数的最大值；
 6
 7                             int x = 10;
 8
 9                             int y = 20;
10
11                             int z = 30;
12
13                             int m = getMax(x,y,z);//getMax(10,20,30);//int m = 30;
14
15                             System.out.println("最大值为:" + m);
16
17                             int v1 = 43243;
18
19                             int v2 = 4322343;
20
21                             int v3 = 432154;
22
23                             int m2 = getMax(v1,v2,v3);
24
25                             System.out.println("m2中的值为：" + m2);
26
27               }
28
29              

 1 //定义一个方法：求三个数的最大值。
 2     //确定三件事情：
 3     //1.方法名：getMax
 4     //2.形参：因为要求三个数的最大值，这个值需要从外部传入，所以定义三个int类型的形参：int a,int b,int c
 5     //3.返回值：因为要求三个数的最大值，所以计算结果应该是a,b,c中的最大值，这个值要返回给调用者；返回值为int
 6     public static int getMax(int a, int b , int c){//a = 43243,b = 432, c = 432154
 7         int max = a > b ? ( a > c ? a : c) : (b > c ? b : c);
 8         return max;
 9     }
10 }

3 方法之求和案例及其调用

定义一个方法，求两个整数的和；

1.方法名：sum;

2.形参：需要从外部接收两个数，方法内求这两个数的和；int a,int b

3.返回值：将两个数的和返回。int

 1 class Demo {
 2
 3               public static void main(String[] args) {
 4
 5                             int a = 10;
 6
 7                             int b = 20;
 8
 9                             int sum = sum(a,b);//sum(10,20);//int sum = 30;
10
11                             System.out.println(sum);
12
13               }
14
15               public static int sum(int a,int b){
16
17                             int sum = a + b;
18
19                             return sum;//return 30;
20
21               }
22
23 }

4 方法的形参和返回值的问题

1.调用方法时，形参：方法声明需要什么类型的形参，就要传递什么类型的形参。而且数量要匹配；

2.调用方法时，返回值：如果方法声明了有返回值，那么调用方，可以接收，可以不接收；

如果方法没有声明返回值，那么就不能接收。

5 方法内部的return语句以及方法的练习

方法内部的return语句：

return语句的含义：

1.在方法内返回一个值；

2.结束方法的执行；

1.如果一个方法，声明了某个返回值类型。那么此方法内部必须return一个此类型的值；否则编译错误；

2.如果一个方法，没有声明返回某类型的值，声明了void的，那么方法内部就不能return一个某类型的值；但，可以写"return;"语句，表示"结束方法的执行

 1 class Demo {
 2     public static void main(String[] args) {
 3         System.out.println("Hello World!");
 4     }
 5     public static int sum(int a ,int b){
 6 if(a > 10){
 7             return 10;
 8         }else if(b > 10){
 9             return 20;
10 }else{
11 return 30;
12             }
13         }
14 public static int max(int a ,int b ,int c){
15         if(a > b && a > c){
16             return a;
17         }else if(a > b && a < c){
18             return c;
19         }else if(b > a && b < c){
20             return c;
21         }else if(b > a && b > c){
22             return b;
23         }
24         return 0;
25     }
26     public static void print(){
27     //    return 10;
28     //    return "a";
29         return;//表示结束方法的执行；
30     }
31 }

 1 键盘录入行数和列数，输出对应的星形
 2 import java.util.Scanner;
 3 class Demo {
 4     public static void main(String[] args) {
 5         Scanner sc = new Scanner(System.in);
 6         System.out.println("请输入行数：" );
 7         int x = sc.nextInt();
 8         System.out.println("请输入列数：");
 9         int y = sc.nextInt();
10         printXing(x,y);
11     }
12     //打印星形的方法。
13     public static void printXing(int row,int col){
14         for(int i = 1 ; i <= row ; i++){
15             for(int j = 1; j <= col ; j++){
16                 System.out.print("*");
17             }
18             System.out.println();
19         }
20     }
21 }

 1 练习：键盘接收三个数，计算三个数中的最大值；
 2     1.定义一个方法，可以计算三个数的最大值；
 3     2.接收控制台数据；
 4 import java.util.Scanner;
 5 class Demo {
 6     public static void main(String[] args) {
 7         Scanner sc = new Scanner(System.in);
 8         System.out.println("请输入第一个数：");
 9         int num1 = sc.nextInt();
10         System.out.println("请输入第二个数：");
11         int num2 = sc.nextInt();
12         System.out.println("请输入第三个数：");
13         int num3 = sc.nextInt();
14
15         System.out.println("三个数的最大值是：" + getMax(num1,num2,num3));
16     }
17     //定义一个方法计算三个数的最大值
18     public static int getMax(int a,int b,int c){
19         return a > b ? ( a > c ? a : c ) : (b > c ? b : c);
20     }
21 }

键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表
import java.util.Scanner;
class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        do{
            System.out.println("请输入1-9的值：");
            int n = sc.nextInt();
            if(n >= 1 && n <= 9){
                print(n);
                break;
            }else{
                System.out.println("非法的值！");
            }
        }while(true);
    }

    public static void print(int n){
        for(int i = 1 ; i<= n ; i++){
            for(int j = 1 ;j <= i ; j++){
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
            System.out.println();
        }
    }
}

 1  键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表
 2
 3 import java.util.Scanner;
 4
 5 class Demo {
 6
 7          public static void main(String[] args) {
 8
 9                    Scanner sc = new Scanner(System.in);
10
11                    do{
12
13                             System.out.println("请输入1-9的值：");
14
15                             int n = sc.nextInt();
16
17                             if(n >= 1 && n <= 9){
18
19                                      print(n);
20
21                                      break;
22
23                             }else{
24
25                                      System.out.println("非法的值！");
26
27                             }
28
29                    }while(true);
30
31          }
32
33
34
35          public static void print(int n){
36
37                    for(int i = 1 ; i<= n ; i++){
38
39                             for(int j = 1 ;j <= i ; j++){
40
41                                      System.out.print(j + "*" + i + "=" + (j * i) + "\t");
42
43                             }
44
45                             System.out.println();
46
47                    }
48
49          }
50
51 }

6 方法重载概述和练习

方法的重载：

1.可以定义方法：求两个整数的和；

2.如果再需要其它类似的方法：例如：求三个整数的和，或求五个double值的和，我们都要

相应的定义方法，每个方法都要起一个名字。这样，对于使用者来说，十分不方便。

3.这时，Java提供了一种机制，允许我们将一些"功能相同或相似"但"形参不完全相同"的方法

定义成相同的名字。调用时，根据调用方法传递参数的数量和类型来判断具体是哪个方法。

这种机制：方法的重载；

4."方法的重载"：可以定义多个同名的方法，但形参列表不能完全相同。

1.形参列表的顺序可以不同；

public static int sum(int a ,double d){

}

public static int sum(double d,int a){//OK的，重载成功

}

2.跟形参名无关；

sum(int a ,int b)

和

sum(int b, int a)//错误，重载失败；

3.跟返回值类型无关；

int sum(int a ,int b):

double sum(int a ,int b)://错误。重载失败

 1 class Demo {
 2     public static void main(String[] args) {
 3     //调用求两个数的
 4     //    System.out.println(sum(10,30));
 5     //需要求三个数的和
 6     //    System.out.println(sum3(10,30,50));
 7     //需要求三个double值的和
 8     //    System.out.println(sumDouble(1.0,2.0,3.0));
 9         System.out.println(sum(10,20));//调用的第一个方法
10         System.out.println(sum(10,20,30));//调用的第二个方法
11         System.out.println(sum(1.0,2.0,3.0));//调用的第三个方法；
12     }
13     //求两个整数的和
14     public static int sum(int a ,int b){
15     return a + b;
16     }
17     public static int sum3(int a ,int b,int c){
18         return a + b + c;
19     }
20     public static double sumDouble(double d1 ,double d2,double d3){
21         return d1 + d2 + d3;
22     }
23     //求两个整数的和
24     public static int sum(int a ,int b){//sum(int,int)
25         return a + b;
26     }
27 //    public static int sum(int b, int a){//sum(int,int)//重载失败
28 //    }
29 //public static double sum(int a ,int b){//sum(int,int);//重载失败，跟返回值无关
30 //    }
31     //求三个整数的和
32     public static int sum(int a,int b,int c){//sum(int,int,int)
33         return a + b + c;
34     }
35     //求三个double的和
36     public static double sum(double d1 ,double d2,double d3){//sum(double,double,double)
37         return d1 + d2 + d3;
38     }
39     //例子：
40     public static int sum(int a ,double d){
41         return 0;
42     }
43     public static int sum(double d,int a){//OK的，重载成功
44         return 0;

7 数组的概述和定义格式说明

1.为什么要数组：

之前我们可以遍历1--100的数，并计算累加和，但这些数是"有序的"，

我们可以使用循环，就可以得到每个数；

2.假如有一组无序的数，例如：我们班每个学员的考试分数

想计算：

1.平均分：

2.最高分：

3.最低分：

这样的分数的特点：虽然只有80个，但它们是"无序的"，用循环直接得到数字

似乎是不可能了。

3.这个时候，编程语言就为我们提供了一种机制，可以将一组"无序的"数字，进行

分组排列，并为每个数字分配一个唯一的编号，使用循环，遍历这个编号就可以了。

　　　　这种机制就叫做：数组

 1 class Demo
 2
 3 {
 4
 5               public static void main(String[] args)
 6
 7               {
 8
 9                             //计算1--100的累加和：
10
11                             //计算的数字：1,2,3,4,5,.....,99,100(有序)
12
13                             int sum = 0;
14
15                             for(int num = 1 ; num<=1000;num++){
16
17                                           sum+=num;
18
19                             }
20
21                             System.out.println("sum = " + sum);
22
23
24
25                             //需求：
26
27                             //有80个同学的分数：                   90,95,88,89,97,.......,89,77(80个)(无序)
28
29                             //为数字分组，并分配编号：      1, 2, 3 ,4, 5 ,.......,79,80(有序的编号)
30
31
32
33                             int sum = 90 + 95 + 88 + 89 + 97 + ...+ 89 + 77;
34
35                             for(int num = 1 ; num <= 80 ; num++){
36
37
38
39                             }
40
41               }
42
43 }

数组的定义格式：

数据类型[]   数组名  = new 数据类型[数组的长度];

或：

数据类型 数组名[] = new 数据类型[数组长度];

说明：

1.数据类型：可以是任何的Java类型(基本数据类型、引用数据类型)

2.数组名：属于自定义标识符，要遵循命名规则和命名规范；

3.new:是Java的关键字。由于"数组"是Java的"引用数据类型"，这里使用new关键字对

数组分配空间。

4.数据类型：要和前面的数据类型一致；

5.[数组长度]：指定数组的长度。一个整型值，可以是字面常量，可以是变量或表达式；

8 动态初始化

数据类型[] 数组名 = new 数据类型[数组长度];                   1.先指定数组的长度，由系统为数组分配初始值：

或：

数据类型 数组名[] = new 数据类型[数组长度];

初始值：

1.整数：0

2.浮点：0.0

3.字符：‘\u0000‘(空字符)

4.布尔：false

5.String类型：String是引用类型：null

 1 class Demo {
 2
 3          public static void main(String[] args) {
 4
 5                    //1.定义一个数组
 6
 7                    int[] array = new int[3];
 8
 9                    //2.上边的语句之后，数组的内容就被自动初始化了
10
11                    //直接获取元素的值：
12
13                    System.out.println("第一个元素的初始值：" + array[0]);//0
14
15                    System.out.println("第二个元素的初始值：" + array[1]);
16
17                    System.out.println("第三个元素的初始值：" + array[2]);
18
19                    //定义一个double的数组
20
21                    double[] doubleArray = new double[3];
22
23                    System.out.println("double数组的初始值：" + doubleArray[0]);//0.0
24
25                    //字符
26
27                    char[] charArray = new char[3];
28
29                    System.out.println("char数组的初始值：" + charArray[0]);//空字符‘\u0000‘
30
31                    //布尔
32
33                    boolean[] booleanArray = new boolean[3];
34
35                    System.out.println("boolean数组的初始值：" + booleanArray[0]);//false
36
37                    //字符串String,同其它的"引用数据类型"，初始化为：null(空地址)
38
39                    String[] stringArray = new String[3];
40
41                    System.out.println("String数组的初始值：" + stringArray[0]);//null
42
43                    //定义一个数组
44
45                    int[] intArray = new int[3];
46
47                    System.out.println(intArray[0]);//0
48
49                    System.out.println(intArray[1]);//0
50
51                    System.out.println(intArray[2]);//0
52
53                    //填充数组
54
55                    intArray[0] = 80;
56
57                    intArray[1] = 90;
58
59                    System.out.println("填充数组后，遍历数组：");
60
61                    //遍历打印
62
63                    for(int i = 0 ; i < 3 ; i++){
64
65                             System.out.println(intArray[i]);
66
67                    }
68
69                   }
70
71 }

9 一个数组

一个数组：一个数组的内存图：

int[] array = new int[3];

1.在"堆"中，开辟一个三个连续的空间

2.而且每个空间都自动初始化为0；

3.array变量是存在"栈"中，它存储的是"堆空间的地址"

二个数组

定义两个数组，分别输出数组名及元素。   然后分别给数组中的元素赋值，分别再次输出数组名及元素。

三个数组

定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。

然后给第二个数组赋值，再次输出两个数组的名及元素.

 1 二个数组
 2
 3 class Demo {
 4
 5          public static void main(String[] args) {
 6
 7                    int[] array1 = new int[3];
 8
 9                    int[] array2 = new int[5];
10
11                    //分别打印两个数组名：
12
13                    System.out.println(array1);//[[email protected]
14
15                    System.out.println(array2);//[[email protected]
16
17                    //分别遍历两个数组，打印数组元素
18
19                    System.out.println("**********第一个数组************");
20
21                    for(int i = 0;i < 3 ; i++){
22
23                             System.out.println(array1[i]);
24
25                    }
26
27                    System.out.println("**********第二个数组************");
28
29                    for(int i = 0;i < 5 ; i++){
30
31                             System.out.println(array2[i]);
32
33                    }
34
35                    System.out.println("*******为数组赋值**********");
36
37                    //第一个数组的第一个元素赋值为：10
38
39                    array1[0] = 10;
40
41                    //第二个数组的第三个元素复制为：30
42
43                    array2[2] = 30;
44
45                    //再次打印地址
46
47                    System.out.println(array1);
48
49                    System.out.println(array2);
50
51                    //再次遍历元素：
52
53                    System.out.println("**********第一个数组************");
54
55                    for(int i = 0;i < 3 ; i++){
56
57                             System.out.println(array1[i]);
58
59                    }
60
61                    System.out.println("**********第二个数组************");
62
63                    for(int i = 0;i < 5 ; i++){
64
65                             System.out.println(array2[i]);
66
67                    }
68
69          }
70
71 }

 1 三个数组
 2 class Demo {
 3     public static void main(String[] args) {
 4         int[] array1 = new int[3];
 5         System.out.println(array1);//地址
 6         array1[0] = 10;
 7         array1[1] = 20;
 8         array1[2] = 30;
 9         System.out.println("array1[0] : " + array1[0]);
10         int[] array2 = array1;//重点理解这句话。必须要理解。将array1的地址赋给了array2
11 //导致两个引用指向了同一个堆空间。通过哪个引用都可以访问这个堆空间
12         array2[0] = 100;
13         System.out.println("array1[0] : " + array1[0]);
14         System.out.println("array2[0] : " + array2[0]);
15         //打印一下两个元素的地址
16         System.out.println("array1的地址：" + array1);
17         System.out.println("array2的地址：" + array2);
18     }
19 }

10  初始化静态初始化

2.格式：         1.在定义数组时，我们直接指定"数组元素"，由系统为我们指定"数组长度"；

数据类型[] 数组名 = new 数据类型[]{值1,值2,值3,....,值n};

注意：后面的：new 数据类型[]方括号中，不能加"数组长度"，否则编译错误；

或：

数据类型[] 数组名 = {值1,值2,值3,....,值n};

 1 class Demo {
 2     public static void main(String[] args) {
 3         //定义一个数组，静态初始化
 4         int[] array = new int[]{1,2,3,4,5,6,3,43245,314,897,64,24,215,43,6,4345,32,42,43,25,43,
 5 432,432,45,35,21,4332,54,365,43,432,5,436,2,41,4,325,43,532,14,14,3,24,325,32,532,53,62,431,5,3,65,35,32,431,5,436,53,54};
 6         System.out.println(array[0]);//1
 7         System.out.println(array[5]);//6
 8         //遍历数组
 9         System.out.println("******循环遍历*********");
10         for(int i = 0 ;i < 6; i++){
11             System.out.println(array[i]);
12         }
13         //"数组"有个属性：length，它可以返回数组的长度；
14         int[] array1 = new int[6];
15         System.out.println("array1数组长度：" + array1.length);//6
16         System.out.println("array数组的长度：" + array.length);
17         //遍历array数组
18         System.out.println("使用length属性遍历数组：");
19         for(int i = 0;i < array.length ; i++){
20             System.out.println(array[i]);
21         }
22         //使用衍生的格式
23         int[] intArray = {1,3,24,32,54,324,32,4};
24         System.out.println("使用第二种静态初始化：");
25         for(int i = 0;i < intArray.length ; i++){
26             System.out.println(intArray[i]);
27         }
28     }
29 }

11 数组操作的两个常见小问题越界和空指针

1.数组索引越界异常：

1).当我们试图访问一个不存在索引(超出范围)的索引时，会引发此异常；

 1 class Demo {
 2     public static void main(String[] args) {
 3         int[] array = new int[3];
 4         System.out.println(array[0]);//0
 5         System.out.println(array[1]);//0
 6         System.out.println(array[2]);//0
 7     //    System.out.println(array[3]);//编译通过。运行时异常：ArrayIndexOutOfBoundsException(数组索引越界异常)
 8         array = null;
 9     //    System.out.println(array[0]);//编译通过，运行时异常：NullPointerException(空指针异常)
10         /*
11         String s = null;
12         System.out.println(s);
13         int a = 0;
14         System.out.println(a);
15         //    int[] array2 = null;
16     System.out.println(array2.length);//java.lang.NullPointerException
17     }
18 }

12 数组的遍历、获取最值、和反转

 1 遍历class Demo
 2 {
 3     public static void main(String[] args)
 4     {
 5         //定义和填充数组
 6         int[] array = {13,2,432,4,35,2,432,5,432,4};
 7         //遍历数组
 8         for(int i = 0 ; i < array.length ; i++){
 9             System.out.println(array[i]);
10         }
11     }
12 }

 1 获取最值class Demo {
 2     public static void main(String[] args) {
 3         int[] array = {143,43,245,35,4,321,48888,8743,645,76,53,8743,3};
 4         int max = array[0];
 5         int min = array[0];
 6         for(int i = 0 ; i < array.length ; i++){
 7                 if(array[i] > max){
 8                 max = array[i];
 9             }
10             if(array[i] < min){
11                 min = array[i];
12             }
13             */
14             max = array[i] > max ? array[i] : max;
15             min = array[i] < min ? array[i] : min;
16         }
17         System.out.println("max = " + max);
18         System.out.println("min = " + min);
19     }
20 }

 1 逆序    class Demo {
 2     public static void main(String[] args) {
 3         int[] array = {1,2,3,4,5,6,7,8,9,10};
 4         int[] array2 = new int[array.length];
 5         //倒序遍历array
 6         int index = 0;//做新数组的索引，从0开始
 7         for(int i = array.length - 1 ; i >= 0 ; i--){
 8             array2[index] = array[i];
 9             index++;
10         }
11         //打印新数组
12         for(int i = 0;i < array2.length ; i++){
13             System.out.println(array2[i]);
14         }
15
16         //*****使用方式二**********//
17         int[] array3 = {1,2,3,4,5,6,7,8,9,10};
18         for(int i = 0 ;i < array3.length / 2 ; i++){
19             int temp = array3[i];
20             array3[i] = array3[array3.length - 1 - i];
21             array3[array3.length - 1 - i] = temp;
22         }
23         System.out.println("使用方式二倒序输出:");
24         for(int i = 0;i < array3.length ; i++){
25             System.out.println(array3[i]);
26         }
27     }
28 }

 1 数组元素逆序 (就是把元素对调)
 2 方式一1.定义一个原数组，并填充数据；
 3      2.定义一个新数组，跟原数组长度相同；
 4 3.倒序遍历原数组，取出每个数，正序填充到新数组中；
 5         int[] array = {1,2,3,4,5,6,7,8,9,10};
 6         int[] array2 = new int[array.length];
 7         //倒序遍历array
 8     int index = 0;//做新数组的索引，从0开始
 9         for(int i = array.length - 1 ; i >= 0 ; i--){
10             array2[index] = array[i];
11             index++;
12         }
13 4.结束后，新数组中的内容就是原数组内容的倒序；
14 方式二：1.定义一个原数组，并填充数据；
15        2.遍历原数组，只需要遍历到：(数组.length - 1) / 2 的位置；进行首位交换：
16         将第一个元素和最后一个元素互换；
17          将第二个元素和倒数第二个元素互换；
18            ....
19     3.遍历之后，已将原数组的顺序颠倒；

13  操作查表法

数组查表法(根据键盘录入索引,查找对应星期)

1.从控制台接收一个1--7的值；

2.先在数组中定义：星期一，星期二,....,星期日

3.根据用户输入的整型值，到数组中查找对应的中文表示；

05.13 数组的操作基本查找

数组元素查找(查找指定元素第一次在数组中出现的索引)

步骤：

1.定义一个数组，并填充；

2.遍历数组，取出每个元素，跟要找的元素进行比较；

相等：此时的循环变量就是索引位置，打印一下；

　　　　　　  不等：继续下一次循环。

 1 class Demo {
 2     public static void main(String[] args) {
 3         int[] array = {1,32,432,5,243,25,43,652,443,76,54643};
 4         int num = 443;
 5         int i = 0;
 6         boolean flag = false;
 7         for(;i < array.length ; i++){
 8             if(array[i]  == num){
 9         System.out.println("数字：" + num + "  在数组中的索引为:" + i);
10                 flag = true;
11                 break;
12             }
13         }
14 //如果代码到这里，有可能循环结束，也有可能是找到break到这里
15         if(i == array.length){
16             System.out.println("数字：" + num + " 没找到！");
17         }
18         if(!flag){
19             System.out.println("数字：" + num + " 没找到！");
20         }
21     }
22 }

 1 import java.util.Scanner;
 2
 3 class Demo {
 4
 5          public static void main(String[] args) {
 6
 7          //       String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
 8
 9                    Scanner sc = new Scanner(System.in);
10
11                    System.out.println("请输入1-7的星期值：");
12
13                    int n = sc.nextInt();//n : 1--7  --> 数组的范围：0 -- 6
14
15          //       System.out.println("对应星期的中文表示：" + strArray[n - 1]);
16
17                    System.out.println("对应星期的中文表示：" + getWeek(n - 1));
18
19          }
20
21          //定义一个方法，可以根据一个1-7的星期值，返回对应中文表示；
22
23          //形参：1-7的星期值；
24
25          //返回值：String
26
27          public static String getWeek(int n){
28
29                    //这个数组就是一个"表"
30
31                    String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
32
33                    if(n >= 0 && n <= 6){
34
35                    return strArray[n];
36
37                    }
38
39                    return null;
40
41          }
42
43 }

14 数组概述和格式1的讲解

1.我们知道，可以定义任何类型的数组；         二维数组的概念：

2.我们也可以定义：存储数组的数组

3.格式：

数据类型[][] 变量名 = new 数据类型[第一维的长度][第二维的长度];

或：

数据类型 变量名[][] = new 数据类型[第一维的长度][第二维的长度];

或：

数据类型[] 变量名[] = new 数据类型[第一维的长度][第二维的长度

 1 class Demo {
 2
 3               public static void main(String[] args) {
 4
 5                             int[][] array = new int[3][2];
 6
 7                             array[1][0] = 10;
 8
 9                             array[1][1] = 20;
10
11                             array[2][1] = 40;
12
13                             System.out.println("array[0][0] : " + array[0][0]);
14
15                             System.out.println("array[0][1] : " + array[0][1]);
16
17                             System.out.println("array[1][0] : " + array[1][0]);
18
19                             System.out.println("array[1][1] : " + array[1][1]);
20
21                             System.out.println("array[2][0] : " + array[2][0]);
22
23                             System.out.println("array[2][1] : " + array[2][1]);
24
25               }
26
27 }

15 数组格式2的讲解及其内存图解

二维数组定义的格式二：

数据类型[][] 变量名 = new 数据类型[第一维长度][];

 1 class Demo {
 2     public static void main(String[] args) {
 3         int[][] array = new int[3][];
 4         System.out.println(array);//总地址
 5         System.out.println(array[0]);//null
 6         System.out.println(array[1]);//null
 7         System.out.println(array[2]);//null
 8         array[0] = new int[3];
 9         array[1] = new int[2];
10         array[2] = new int[4];
11         System.out.println(array[0]);//第一个元素存储的数组的地址
12         System.out.println(array[1]);//第二个元素存储的数组的地址
13         System.out.println(array[2]);//第三个元素存储的数组的地址
14             }

16  数组格式3

二维数组的格式三：

数据类型[][]       数组名       = new 数据类型[][]{{值1,值2,....},{值3,值4,.....},{值5,值6,....}}；

或者：

1.关于0长度数组：没有意义  数据类型[][]       数组名       = {{值1,值2,....},{值3,值4,.....},{值5,值6,....}}；

int[] array = new int[0];

System.out.println(array);//有地址，不是空指针

System.out.println(array.length);//0

System.out.println(array[0]);//ArrayIndexOutOfBoundsException

2.长度的负数值： int[] array = new int[-2];//编译通过。运行时异常：NegativeArraySizeException

3.关于二维数组的第三种格式：

int[][] array = {{1,2,3,5,6},  {1,2,3},  {6,7,9,0,17}};

 1 class Demo {
 2
 3          public static void main(String[] args) {
 4
 5                    int[][] array = new int[][]{{1,2},                      {3,4},                                                         {5,6}};
 6
 7                    //原4的位置改为40
 8
 9                    array[1][1] = 40;
10
11                    //6改为60
12
13                    array[2][1] = 60;
14
15          int[][] array2 = {{1,2},{3,4},{5,6}};
16
17                    //将2改为20
18
19                    array2[0][1] = 20;
20
21                    //3改为30
22
23                    array2[1][0] = 30;
24
25          }
26
27 }

17  数组练习遍历、求和和杨辉三角

 1 遍历二维数组：
 2 class Demo {
 3     public static void main(String[] args) {
 4         int[][] array = {{1,2,3,4,5,6},
 5                  {7,8,9,10},
 6                  {11,12,13,14,15,16,17}};
 7         System.out.println(array.length);//3
 8         System.out.println(array[0].length);//6
 9         System.out.println(array[1].length);//4
10         System.out.println(array[2].length);//7
11         System.out.println("******遍历数组*******");
12         for(int i = 0;i < array.length ; i++){
13             for(int j = 0; j < array[i].length ; j++){
14                 System.out.print(array[i][j] + "\t");
15             }
16             System.out.println();
17         }
18     }
19 }

公司年销售额求和

某公司按照季度和月份统计的数据如下：单位(万元)

第一季度：22,66,44

第二季度：77,33,88

第三季度：25,45,65

第四季度：11,66,99

求总销售额：

 1 class Demo {
 2     public static void main(String[] args) {
 3         int sum = 0;
 4         int[][] array = {{22,66,44},
 5                 {77,33,88},
 6                 {25,45,65},
 7                 {11,66,99}};
 8         for(int i = 0;i < array.length ; i++){
 9             for(int j = 0; j < array[i].length ; j++){
10                 sum += array[i][j];
11             }
12         }
13         System.out.println("总销售额：" + sum);
14     }
15 }

 1 class Demo {
 2  ublic static void main(String[] args) {
 3     int row = 8;
 4     int[][] array = new int[row][row];
 5      or(int i = 0;i < array.length ; i++){
 6         for(int j = 0;j <= i ; j++){
 7             //如果是第一行，或第二行，直接填充1
 8             if(i == 0 || i == 1){
 9             array[i][j] = 1;
10             }else{//从第三行开始
11                 //如果是第一列或最后一列，直接填充1
12                 if(j == 0 || j == i){
13                 array[i][j] = 1;
14                 }else{
15                 array[i][j] = array[i - 1][j] + array[i - 1][j - 1];
16                     }
17                 }
18             }
19         }
20 //遍历一下数组
21         for(int i = 0;i < array.length ; i++){
22             for(int j = 0;j <= i ; j++){
23                 System.out.print(array[i][j] + "\t");
24             }
25             System.out.println();
26         }
27     }
28 }

18 Java中的参数传递问题

 1 class Demo {
 2     public static void main(String[] args) {
 3         int x = 10;
 4         fun1(x);
 5         System.out.println(x);//10
 6         System.out.println("**********传递引用***********");
 7         int[] array = {1,2,3};//array = 0x2233
 8         fun2(array);//fun2(0x2233);
 9         System.out.println(array[0]);//1000
10     }
11     public static void fun1(int a){
12         a = 100;
13     }
14     //此方法接收一个数组的引用(地址)
15     public static void fun2(int[] arr){//arr = 0x2233
16         arr[0] = 1000;
17     }
18 }