1:方法(掌握)
(1)方法：就是完成特定功能的代码块。
注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。
(2)格式：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
}
修饰符：目前就用 public static。后面再详细讲解其他修饰符
返回值类型：就是功能结果的数据类型
方法名：就是起了一个名字，方便我们调用该方法。
参数类型：就是参数的数据类型
参数名：就是变量
参数分类：
实参：实际参与运算的数据
形参：方法上定义的，用于接收实际参数的变量
方法体语句：就是完成功能的代码块
return：结束方法
返回值：就是功能的结果，由return带给调用者。
(3)两个明确：
返回值类型：结果的数据类型
参数列表：参数的个数及对应的数据类型
(4)方法调用
A:有明确返回值的方法
a:单独调用，没有意义
b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。
c:赋值调用，推荐方案
B:void类型修饰的方法
a:单独调用
(5)案例：
A:求和方案
B:获取两个数中的较大值
C:比较两个数据是否相同
D:获取三个数中的最大值
E:输出m行n列的星形
F:输出nn乘法表
(6)方法的注意事项
A:方法不调用不执行
B:方法之间是平级关系，不能嵌套定义
C:方法定义的时候，参数是用，隔开的
D:方法在调用的时候，不用在传递数据类型
E:如果方法有明确的返回值类型，就必须有return语句返回。
(7)方法重载
在同一个类中，方法名相同，参数列表不同。与返回值无关。
参数列表不同：
参数的个数不同。
参数的对应的数据类型不同。
(8)方法重载案例
不同的类型的多个同名方法的比较。
FunctionDemo.java
1 /* 2 方法：完成特定功能的代码块。 3 4 注意：在很多语言里面有函数的定义，而在Java中函数被称为方法。 5 6 方法格式： 7 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) { 8 方法体语句; 9 return 返回值; 10 } 11 详细解释： 12 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。 13 返回值类型：就是功能结果的数据类型。 14 方法名：符合命名规则即可。方便我们的调用。 15 参数： 16 实际参数：就是实际参与运算的。 17 形式参数；就是方法定义上的，用于接收实际参数的。 18 参数类型：就是参数的数据类型 19 参数名：就是变量名 20 方法体语句：就是完成功能的代码。 21 return：结束方法的。 22 返回值：就是功能的结果，由return带给调用者。 23 24 要想写好一个方法，就必须明确两个东西： 25 A:返回值类型 26 结果的数据类型 27 B:参数列表 28 你要传递几个参数，以及每个参数的数据类型 29 30 需求：求两个数据之和的案例 31 32 方法的执行特点： 33 不调用，不执行。 34 35 如何调用呢?(有明确返回值的调用) 36 A:单独调用,一般来说没有意义，所以不推荐。 37 B:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。 38 C:赋值调用,推荐方案。 39 40 */ 41 class FunctionDemo { 42 public static void main(String[] args) { 43 int x = 10; 44 int y = 20; 45 46 //方式1：单独调用 47 //sum(x,y); 48 49 //方式2：输出调用 50 //System.out.println(sum(x,y)); 51 //System.out.println(30); 52 53 //方式3：赋值调用 54 int result = sum(x,y); 55 //result在这里可以进行操作 56 System.out.println(result); 57 } 58 59 /* 60 需求：求两个数据之和的案例 61 62 两个明确： 63 返回值类型：int 64 参数列表：2个，都是int类型。 65 */ 66 public static int sum(int a,int b) { 67 //如何实现呢? 68 //int c = a + b; 69 //return c; 70 71 //c就是a+b,所以，我可以直接返回a+b 72 return a + b; 73 } 74 75 }
FunctionDemo2.java
1 /* 2 方法的注意事项： 3 A:方法不调用不执行 4 B:方法与方法是平级关系，不能嵌套定义 5 C:方法定义的时候参数之间用逗号隔开 6 D:方法调用的时候不用在传递数据类型 7 E:如果方法有明确的返回值，一定要有return带回一个值 8 */ 9 class FunctionDemo2 { 10 public static void main(String[] args) { 11 /* 12 错误的 13 public static int sum(int a,int b){ 14 return a + b; 15 } 16 */ 17 18 //sum(10,20); 19 20 //int x = 10; 21 //int y = 20; 22 //错误 23 //sum(int x,int y); 24 } 25 26 public static int sum(int a,int b){ 27 return a + b; 28 } 29 }
FunctionDemo3.java
1 /* 2 需求：在控制台输出如下的形状 3 ***** 4 ***** 5 ***** 6 ***** 7 8 void类型返回值的方法调用： 9 单独调用 10 输出调用(错误) 11 赋值调用(错误) 12 */ 13 class FunctionDemo3 { 14 public static void main(String[] args) { 15 //for循环嵌套输出图形 16 for(int x=0; x<4; x++) { 17 for(int y=0; y<5; y++) { 18 System.out.print("*"); 19 } 20 System.out.println(); 21 } 22 System.out.println("--------------"); 23 24 //需求：我要在控制台输出一个6行7列的星形图形 25 for(int x=0; x<6; x++) { 26 for(int y=0; y<7; y++) { 27 System.out.print("*"); 28 } 29 System.out.println(); 30 } 31 System.out.println("--------------"); 32 33 //如果需要继续改变，我们就应该考虑使用方法改进。 34 //单独调用 35 pringXing(3,4); 36 System.out.println("--------------"); 37 pringXing(6,7); 38 System.out.println("--------------"); 39 pringXing(8,9); 40 41 //输出调用 42 //此处不允许使用 '空' 类型 43 //System.out.println(pringXing(3,4)); 44 45 //赋值调用 46 //非法的表达式开始 47 //void v = pringXing(3,4); 48 } 49 50 /* 51 写一个什么样子的方法呢?写一个m行n列的代码 52 53 两个明确： 54 返回值类型：这个时候没有明确的返回值，不写东西还不行，所以，这里记住是void 55 参数列表：int m,int n 56 */ 57 public static void pringXing(int m,int n) { 58 for(int x=0; x<m; x++) { 59 for(int y=0; y<n; y++) { 60 System.out.print("*"); 61 } 62 System.out.println(); 63 } 64 } 65 }
FunctionDemo4.java
1 /* 2 需求：我要求数的和 3 4 我们的需求不断的发生改变，我们就对应的提供了多个求和的方法。 5 但是呢，他们的名字是不一样的。 6 而我们又要求方法命名做到：见名知意。 7 但是，很明显，现在没有做到。 8 那么，肿么办呢? 9 针对这种情况：方法的功能相同，参数列表不同的情况，为了见名知意，Java允许它们起一样的名字。 10 11 其实，这种情况有一个专业名词：方法重载。 12 13 方法重载： 14 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。 15 16 参数列表不同： 17 A:参数个数不同 18 B:参数类型不同 19 */ 20 class FunctionDemo4 { 21 public static void main(String[] args) { 22 //jvm会根据不同的参数去调用不同的功能 23 System.out.println(sum(10,20)); 24 System.out.println(sum(10,20,30)); 25 System.out.println(sum(10,20,30,40)); 26 27 System.out.println(sum(10.5f,20f)); 28 } 29 30 //需求1:求两个数的和 31 public static int sum(int a,int b) { 32 System.out.println("int"); 33 return a + b; 34 } 35 36 //需求2:求三数的和 37 /* 38 public static int sum1(int a,int b,int c) { 39 return a + b + c; 40 } 41 */ 42 43 public static int sum(int a,int b,int c) { 44 return a + b + c; 45 } 46 47 //需求3:求四个数的和 48 /* 49 public static int sum2(int a,int b,int c,int d) { 50 return a + b + c + d; 51 } 52 */ 53 public static int sum(int a,int b,int c,int d) { 54 return a + b + c + d; 55 } 56 57 public static float sum(float a,float b) { 58 System.out.println("float"); 59 return a + b; 60 } 61 }
FunctionTest.java
1 /* 2 键盘录入两个数据，返回两个数中的较大值 3 */ 4 import java.util.Scanner; 5 6 class FunctionTest { 7 public static void main(String[] args) { 8 //创建键盘录入对象 9 Scanner sc = new Scanner(System.in); 10 11 System.out.println("请输入第一个数据:"); 12 int a = sc.nextInt(); 13 14 System.out.println("请输入第二个数据:"); 15 int b = sc.nextInt(); 16 17 int result = getMax(a,b); 18 System.out.println("较大值是："+result); 19 } 20 21 /* 22 需求：两个数中的较大值 23 两个明确： 24 返回值类型：int 25 参数列表：int a,int b 26 */ 27 public static int getMax(int a,int b) { 28 //if语句 29 /* 30 if(a > b) { 31 //System.out.println(a); 32 return a; 33 }else { 34 //System.out.println(b); 35 return b; 36 } 37 */ 38 39 //用三元改进 40 //int c = ((a > b)? a: b); 41 //return c; 42 43 //由于c就是后面的式子 44 return ((a>b)? a : b); 45 } 46 }
FunctionTest2.java
1 /* 2 键盘录入两个数据，比较两个数是否相等 3 4 分析： 5 比较两个数是否相等结果是一个boolean类型。 6 */ 7 import java.util.Scanner; 8 9 class FunctionTest2 { 10 public static void main(String[] args) { 11 //创建键盘录入对象 12 Scanner sc = new Scanner(System.in); 13 14 System.out.println("请输入第一个数据:"); 15 int a = sc.nextInt(); 16 17 System.out.println("请输入第二个数据:"); 18 int b = sc.nextInt(); 19 20 boolean flag = compare(a,b); 21 System.out.println(flag); 22 } 23 24 /* 25 需求：比较两个数是否相等 26 两个明确： 27 返回值类型：boolean 28 参数列表：int a,int b 29 */ 30 public static boolean compare(int a,int b) { 31 //if语句的格式2实现 32 /* 33 if(a == b) { 34 return true; 35 }else { 36 return false; 37 } 38 */ 39 40 //三元改进 41 //boolean flag = ((a==b)? true: false); 42 //return flag; 43 44 //继续改进 45 //return ((a==b)? true: false); 46 47 //最终版 48 return a == b; 49 } 50 }
FunctionTest3.java
/* 键盘录入三个数据，返回三个数中的最大值 */ import java.util.Scanner; class FunctionTest3 { public static void main(String[] args) { //创建键盘录入对象 Scanner sc = new Scanner(System.in); System.out.println("请输入第一个数据:"); int a = sc.nextInt(); System.out.println("请输入第二个数据:"); int b = sc.nextInt(); System.out.println("请输入第三个数据:"); int c = sc.nextInt(); int max = getMax(a,b,c); System.out.println("三个数据中的最大值是："+max); } /* 需求；返回三个数中的最大值 两个明确： 返回值类型：int 参数列表：int a,int b,int c */ public static int getMax(int a,int b,int c) { //if嵌套 /* if(a > b) { if(a > c) { return a; }else { return c; } }else { if(b > c) { return b; }else { return c; } } */ //用三元改 /* if(a > b) { return (a>c? a: c); }else { return (b>c? b: c); } */ //继续改进 //return (a>b)? (a>c? a: c): (b>c? b: c); //不建议，写代码一定要注意阅读性强 int temp = ((a>b)? a: b); int max = ((temp>c)? temp: c); return max; } }
FunctionTest4.java
1 /* 2 键盘录入行数和列数，输出对应的星形 3 */ 4 import java.util.Scanner; 5 6 class FunctionTest4 { 7 public static void main(String[] args) { 8 //创建键盘录入对象 9 Scanner sc = new Scanner(System.in); 10 11 System.out.println("请输入行数："); 12 int m = sc.nextInt(); 13 14 System.out.println("请输入列数："); 15 int n = sc.nextInt(); 16 17 //void类型的方法调用 18 pringXing(m,n); 19 } 20 21 /* 22 输出星形 23 24 两个明确： 25 返回值类型：void 26 参数列表：int m,int n 27 */ 28 public static void pringXing(int m,int n) { 29 for(int x=0; x<m; x++) { 30 for(int y=0; y<n; y++) { 31 System.out.print("*"); 32 } 33 System.out.println(); 34 } 35 } 36 }
FunctionTest5.java
1 /* 2 键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表 3 */ 4 import java.util.Scanner; 5 6 class FunctionTest5 { 7 public static void main(String[] args) { 8 //创建对象 9 Scanner sc = new Scanner(System.in); 10 11 System.out.println("请输入n的值：(1~9)"); 12 int n = sc.nextInt(); 13 14 //调用 15 printNN(n); 16 } 17 18 /* 19 需求：输出对应的nn乘法表 20 两个明确： 21 返回值类型：void 22 参数列表：int n 23 */ 24 public static void printNN(int n) { 25 for(int x=1; x<=n; x++) { 26 for(int y=1; y<=x; y++) { 27 System.out.print(y+"*"+x+"="+y*x+" "); 28 } 29 System.out.println(); 30 } 31 } 32 }
FunctionTest6.java
1 /* 2 比较两个数据是否相等。参数类型分别为 3 两个byte类型，两个short类型，两个int类型，两个long类型， 4 并在main方法中进行测试 5 */ 6 class FunctionTest6 { 7 public static void main(String[] args) { 8 //测试 9 byte b1 = 3; 10 byte b2 = 4; 11 System.out.println("byte:"+compare(b1,b2)); 12 13 //测试 14 short s1 = 5; 15 short s2 = 5; 16 System.out.println("short:"+compare(s1,s2)); 17 18 //后面的两个自己测试 19 } 20 21 //byte类型 22 public static boolean compare(byte a,byte b) { 23 System.out.println("byte"); 24 return a == b; 25 } 26 27 //short类型 28 public static boolean compare(short a,short b) { 29 System.out.println("short"); 30 return a == b; 31 } 32 33 //int类型 34 public static boolean compare(int a,int b) { 35 System.out.println("int"); 36 return a == b; 37 } 38 39 //long类型 40 public static boolean compare(long a,long b) { 41 System.out.println("long"); 42 return a == b; 43 } 44 }
2:数组(掌握)
(1)数组：存储同一种数据类型的多个元素的容器。
(2)特点：每一个元素都有编号，从0开始，最大编号是: 长度-1。
编号的专业叫法：索引
(3)定义格式
A:数据类型[] 数组名;
B:数据类型 数组名[];
推荐是用A方式，B方法就忘了吧。
但是要能看懂
(4)数组的初始化
A:动态初始化
只给长度，系统给出默认值
举例：int[] arr = new int[3];
B:静态初始化
给出值，系统决定长度
举例：int[] arr = new int[]{1,2,3};
简化版：int[] arr = {1,2,3};
(5)Java的内存分配
A:栈 存储局部变量
B:堆 存储所有new出来的
C:方法区(面向对象部分详细讲解)
D:本地方法区(系统相关)
E:寄存器(CPU使用)
注意：
a:局部变量 在方法定义中或者方法声明上定义的变量。
b:栈内存和堆内存的区别
栈：数据使用完毕，就消失。
堆：每一个new出来的东西都有地址
每一个变量都有默认值
byte,short,int,long 0
float,double 0.0
char 'u0000'
boolean false
引用类型 null
数据使用完毕后，在垃圾回收器空闲的时候回收。
(6)数组内存图
A:一个数组
B:二个数组
C:三个数组(两个栈变量指向同一个堆内存)
(7)数组的常见操作
A:遍历
方式1：
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
}
方式2：
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.println(arr[x]+", ");
}
}
}
B:最值
最大值：
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;
}
最小值：
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;
}
C:逆序
方式1：
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;
}
}
方式2：
public static void reverse(int[] arr) {
for(int start=0,end=arr.length-1; start<=end; start++,end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
D:查表
public static String getString(String[] strArray,int index) {
return strArray[index];
}
E:基本查找
方式1：
public static int getIndex(int[] arr,int value) {
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
return x;
}
}
return -1;
}
方式2：
public static int getIndex(int[] arr,int value) {
int index = -1;
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
index = x;
break;
}
}
return index;
}
ArrayDemo.java
1 /* 2 数组:存储同一种数据类型的多个元素的容器。 3 4 定义格式： 5 A:数据类型[] 数组名; 6 B:数据类型 数组名[]; 7 8 举例： 9 A:int[] a; 定义一个int类型的数组a变量 10 B:int a[]; 定义一个int类型的a数组变量 11 12 注意：效果可以认为是一样的，都是定义一个int数组，但是念法上有些小区别。推荐使用第一种。 13 14 如何对数组进行初始化呢? 15 A:何谓初始化呢? 就是为数组开辟内存空间，并为每个数组元素赋予值 16 B:有几种方式呢? 17 a:动态初始化 只指定长度，由系统给出初始化值 18 b:静态初始化 给出初始化值，由系统决定长度 19 20 动态初始化的格式： 21 数据类型[] 数组名 = new 数据类型[数组长度]; 22 23 举例： 24 int[] arr = new int[3]; 25 26 如何获取数组中的元素呢? 27 通过: 28 数组名[索引] 29 索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。 30 */ 31 class ArrayDemo { 32 public static void main(String[] args) { 33 //定义一个数组 34 //int[] a; 35 //可能尚未初始化变量a 36 //System.out.println(a); 37 38 int[] arr = new int[3]; 39 /* 40 左边： 41 int:说明数组中的元素的数据类型是int类型 42 []:说明这是一个数组 43 arr:是数组的名称 44 45 右边： 46 new:为数组分配内存空间。 47 int:说明数组中的元素的数据类型是int类型 48 []:说明这是一个数组 49 3:数组长度，其实也就是数组中元素的个数 50 */ 51 52 System.out.println(arr); //[I@175078b 地址值。 53 //我要地址值没有意义啊，我就要数据值，怎么办呢? 54 //不用担心，java为你考虑到了。 55 //其实数组中的每个元素都是有编号的，并且是从0开始。最大编号是数组的长度-1。 56 //用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法：索引 57 //通过数组名访问数据的格式是：数组名[索引]; 58 System.out.println(arr[0]); 59 System.out.println(arr[1]); 60 System.out.println(arr[2]); 61 } 62 }
Java中的内存分配图解
ArrayDemo2.java
1 /* 2 定义一个数组，输出该数组的名称和数组元素值。 3 给数组元素赋值，再次输出该数组的名称和数组元素值。 4 */ 5 class ArrayDemo2 { 6 public static void main(String[] args) { 7 //定义一个数组 8 int[] arr = new int[3]; 9 10 //输出数组名称 11 System.out.println(arr); 12 //输出数组元素值 13 System.out.println(arr[0]); 14 System.out.println(arr[1]); 15 System.out.println(arr[2]); 16 System.out.println("----"); 17 18 //给数组元素赋值 19 arr[0] = 100; 20 arr[2] = 200; 21 22 //输出数组名称 23 System.out.println(arr); 24 //输出数组元素值 25 System.out.println(arr[0]); 26 System.out.println(arr[1]); 27 System.out.println(arr[2]); 28 } 29 }
ArrayDemo3.java
1 /* 2 定义两个数组，分别输出两个数组各自的数组名及元素值。 3 然后给每个数组的元素重新赋值，再次分别输出两个数组各自的数组名及元素值。 4 */ 5 class ArrayDemo3 { 6 public static void main(String[] args) { 7 //定义第一个数组 8 int[] arr = new int[2]; 9 //定义第二个数组 10 int[] arr2 = new int[3]; 11 12 //输出数组名和元素值 13 System.out.println(arr); 14 System.out.println(arr[0]); 15 System.out.println(arr[1]); 16 System.out.println("----"); 17 18 System.out.println(arr2); 19 System.out.println(arr2[0]); 20 System.out.println(arr2[1]); 21 System.out.println(arr2[2]); 22 System.out.println("----"); 23 24 //给元素重新赋值 25 arr[1] = 20; 26 27 arr2[1] = 30; 28 arr2[0] = 40; 29 30 //输出数组名和元素值 31 System.out.println(arr); 32 System.out.println(arr[0]); 33 System.out.println(arr[1]); 34 System.out.println("----"); 35 36 System.out.println(arr2); 37 System.out.println(arr2[0]); 38 System.out.println(arr2[1]); 39 System.out.println(arr2[2]); 40 } 41 }
ArrayDemo4.java
1 /* 2 定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。 3 定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。 4 定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重复赋值。 5 最后，再次输出第一个数组数组名称和元素。 6 */ 7 class ArrayDemo4 { 8 public static void main(String[] args) { 9 //定义第一个数组 10 int[] arr = new int[3]; 11 arr[0] = 88; 12 arr[1] = 33; 13 arr[2] = 66; 14 System.out.println(arr); 15 System.out.println(arr[0]); 16 System.out.println(arr[1]); 17 System.out.println(arr[2]); 18 System.out.println("----"); 19 20 //定义第二个数组 21 int[] arr2 = new int[3]; 22 arr2[0] = 22; 23 arr2[1] = 44; 24 arr2[2] = 55; 25 System.out.println(arr2); 26 System.out.println(arr2[0]); 27 System.out.println(arr2[1]); 28 System.out.println(arr2[2]); 29 System.out.println("----"); 30 31 //定义第三个数组 32 int[] arr3 = arr; 33 arr3[0] = 100; 34 arr3[1] = 200; 35 System.out.println(arr); 36 System.out.println(arr[0]); 37 System.out.println(arr[1]); 38 System.out.println(arr[2]); 39 } 40 }
ArrayDemo5.java
/* 数组操作的两个常见小问题： ArrayIndexOutOfBoundsException:数组索引越界异常 原因：你访问了不存在的索引。 NullPointerException:空指针异常 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。 作用：请自己把所有的场景Exception结尾的问题总结一下。以后遇到就记录下来。 现象，原因，解决方案。 */ class ArrayDemo6 { public static void main(String[] args) { //定义数组 int[] arr = {1,2,3}; //System.out.println(arr[3]); //引用类型的常量：空常量 null arr = null; System.out.println(arr[0]); } }
ArrayTest.java【遍历数组元素】
/* 数组遍历：就是依次输出数组中的每一个元素。 注意：数组提供了一个属性length，用于获取数组的长度。 格式：数组名.length */ class ArrayTest { public static void main(String[] args) { //定义数组 int[] arr = {11,22,33,44,55}; //获取每一个元素 //如何获取呢?我们知道数组名结合编号(索引)就可以找到数据 System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); System.out.println(arr[3]); System.out.println(arr[4]); System.out.println("--------------------"); //虽然这种做法可以，但是不是我想要的 //我们发现，代码的重复度很高 //输出语句，数组名都是相同的，仅仅是索引是变化的 //我们就可以使用循环搞定索引值 for(int x=0; x<5; x++) { //x=0,1,2,3,4 System.out.println(arr[x]); } System.out.println("--------------------"); //从0开始我们是明确的，但是为什么到5呢，我们是数了一下数组的个数 //继续看下个数组如何遍历 int[] arr2 = {1,2,3,4,5,6,7,8,9,10,11,2,2,3,4,5,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8}; //而我们在很多时候，数组的元素不能靠数 //这个时候，数组就给我们提供了一个属性：length专门用于获取数组的长度 //格式：数组名.length 返回数组的长度 System.out.println(arr.length); System.out.println(arr2.length); System.out.println("--------------------"); //改进第一个程序 for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); } System.out.println("--------------------"); //我们如果想要对多个数组进行遍历，每个数组的遍历我们都把代码写一遍，麻烦不 //麻烦，所以，我们准备用方法改进。 //用方法改进后，请调用 printArray(arr); System.out.println("--------------------"); printArray(arr2); System.out.println("--------------------"); printArray2(arr); } /* 遍历数组的方法 两个明确： 返回值类型：void 参数列表：int[] arr */ public static void printArray(int[] arr) { for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); } } //请看改进版本 public static void printArray2(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]+", "); } } } }
ArrayTest2.java【求数组最值】
/* 数组获取最值(获取数组中的最大值最小值) 分析： A:定义一个数组，并对数组的元素进行静态初始化。 B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。 C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。 D:最后参照物里面保存的就是最大值。 */ class ArrayTest2 { public static void main(String[] args) { //定义一个数组 int[] arr = {34,98,10,25,67}; //请获取数组中的最大值 /* //从数组中任意的找一个元素作为参照物 int max = arr[0]; //然后遍历其他的元素 for(int x=1; x<arr.length; x++) { //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。 if(arr[x] > max) { max = arr[x]; } } //最后参照物里面保存的就是最大值。 System.out.println("max:"+max); */ //把这个代码用方法改进 //调用方法 int max = getMax(arr); System.out.println("max:"+max); //请获取数组中的最小值 int min = getMin(arr); System.out.println("min:"+min); } /* 需求：获取数组中的最大值 两个明确： 返回值类型：int 参数列表：int[] arr */ 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; } 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; } }
ArrayTest3.java【将数组元素逆序】
/* 数组元素逆序 (就是把元素对调) 分析： A:定义一个数组，并进行静态初始化。 B:思路 把0索引和arr.length-1的数据交换 把1索引和arr.length-2的数据交换 ... 只要做到arr.length/2的时候即可。 */ class ArrayTest3 { public static void main(String[] args) { //定义一个数组，并进行静态初始化。 int[] arr = {12,98,50,34,76}; //逆序前 System.out.println("逆序前："); printArray(arr); //逆序后 System.out.println("逆序后："); //reverse(arr); reverse2(arr); printArray(arr); } /* 需求：数组逆序 两个明确： 返回值类型：void (有人会想到应该返回的是逆序后的数组，但是没必要，因为这两个数组其实是同一个数组) 参数列表：int[] arr */ public static void reverse(int[] arr) { /* //第一次交换 int temp = arr[0]; arr[0] = arr[arr.length-1-0]; arr[arr.length-1-0] = temp; //第二次交换 int temp = arr[1]; arr[1] = arr[arr.length-1-1]; arr[arr.length-1-1] = temp; //第三次交换 int temp = arr[2]; arr[2] = arr[arr.length-1-2]; arr[arr.length-1-2] = temp; */ //用循环改进 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 reverse2(int[] arr) { for(int start=0,end=arr.length-1; start<=end; start++,end--) { int temp = arr[start]; arr[start] = arr[end]; arr[end] = 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]+", "); } } } }
ArrayTest4.java【数组查表法】
/* 数组查表法(根据键盘录入索引,查找对应星期) 意思是：String[] strArray = {"星期一","星期二",...}; */ import java.util.Scanner; class ArrayTest4 { public static void main(String[] args) { //定义一个字符串数组 String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"}; //创建键盘录入对象 Scanner sc = new Scanner(System.in); System.out.println("请输入一个数据(0-6)："); int index = sc.nextInt(); System.out.println("你要查找的日期是："+strArray[index]); } }
ArrayTest5.java
/* 需求：数组元素查找(查找指定元素第一次在数组中出现的索引) 分析： A:定义一个数组，并静态初始化。 B:写一个功能实现 遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较 如果相等，就返回当前的索引值。 */ class ArrayTest5 { public static void main(String[] args) { //定义一个数组，并静态初始化 int[] arr = {200,250,38,888,444}; //需求：我要查找250在这个数组中第一次出现的索引 int index = getIndex(arr,250); System.out.println("250在数组中第一次出现的索引是："+index); int index2 = getIndex2(arr,250); System.out.println("250在数组中第一次出现的索引是："+index2); int index3 = getIndex2(arr,2500); System.out.println("2500在数组中第一次出现的索引是："+index3); } /* 需求：查找指定数据在数组中第一次出现的索引 两个明确： 返回值类型：int 参数列表：int[] arr,int value */ public static int getIndex(int[] arr,int value) { //遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较 for(int x=0; x<arr.length; x++) { if(arr[x] == value) { //如果相等，就返回当前的索引值。 return x; } } //目前的代码有一个小问题 //就是假如我要查找的数据在数组中不存在，那就找不到，找不到，你就对应的返回吗? //所以报错。 //只要是判断，就可能是false，所以大家要细心。 //如果找不到数据，我们一般返回一个负数即可，而且是返回-1 return -1; } public static int getIndex2(int[] arr,int value) { //定义一个索引 int index = -1; //有就修改索引值 for(int x=0; x<arr.length; x++) { if(arr[x] == value) { index = x; break; } } //返回index return index; } }