鲁达 提纲：
1、方法的概念 2、方法语法 3、方法使用 4、参数 5、返回值 6、方法的分类 7、作业一、数组的概念
1.1、为什么使用数组
如果说程序中，需要存储大量的相同类型的一组数据，如果直接使用变量来进行存储，每个变量只能存储一个值，就需要大量的变量。 1、代码过于臃肿 2、程序的可读性差 3、数据维护较差1.2、数组的概念
数组的概念： 就是一组相同数据类型的数据。内存上是开辟的连续的内存空间。1.3、数组的特点？
1、定长。容量固定。数组一旦创建后，那么长度不能更改。(容量，长度，都是指存储的数量) 2、存储的数据类型必须都一致。 3、在内存中空间连续挨个。 4、数组是引用类型的数据，存在栈和堆的地址引用关系。 Java中：两大数据类型 基本：4类8种 引用：数组，对象，集合。。。。二、数组的使用
2.1、数组的使用
step1：先创建数组 step2：使用数组：存储数据，访问数据。2.2、数组的语法
创建数组的语法： 数据类型[] 数组名 = new 数据类型[长度、容量、个数]; 数据类型 数组名[] = new 数据类型[长度];//也可以 使用的语法： 数组名[index]，操作数组 index：因为一个数组存储了多个数据(也叫元素)，每个元素都有一个下标，也叫索引，index。理解起来就是给每个数据排个编号，固定从0开始，0,1,2,3,4.。。。到长度减1。 数组的下标不能超出这个范围。否则就会下标越界：java.lang.ArrayIndexOutOfBoundsException示例代码：
public class Test1Array { public static void main(String[] args){ //1.变量的定义 int num = 10; Sy(num); //2.数组 /* 创建数组：语法格式 数据类型[] 数组名 = new 数据类型[容量/长度/个数]; 数组是引用类型的数据： a中存储的是数组的实际的地址。 */ int[] a = new int[5];//声明一个数组，并创建出来，然后就可以使用这个数组了。 Sy(a); //3.使用数组：存储数据 a[0] = 10; a[1] = 20; a[2] = 30; a[3] = 40; a[4] = 50; //a[5] = 100; //获取数据 Sy(a[0]);//打印数组的第一个元素 Sy(a[1]);//打印数组的第二个元素 Sy(a[2]);//打印数组的第三个元素 Sy(a[3]);//打印数组的第四个元素 Sy(a[4]);//打印数组的第五个元素 //课堂练习：创建一个数组， 存储班级5位同学的性别。 char[] arr2 = new char[5]; arr2[0] = '男'; arr2[1] = '男'; arr2[2] = '男'; arr2[3] = '女'; arr2[4] = '女'; //打印悄悄 Sy(arr2[0]); Sy(arr2[1]); Sy(arr2[2]); Sy(arr2[3]); Sy(arr2[4]); } }2.3、内存分析(扩展)
内存：存储数据 A：栈，存放的是基本数据类型的变量，以及引用类型变量的引用。 特点：函数中的变量所占用的空间，执行之后就会销毁。 B：堆，存放的是new出来的东西。 特点：执行之后，堆里存储的内容(对象等)，会被标记为垃圾，但是不会立即被销毁，而是等待系统的垃圾回收机制来回收(GC)。 JVM,GC(Grabage Collection)
2.4、数组的长度
获取数组的长度：length，数组的一个属性。 数组名.length--->获取这个数组的长度。
2.5、使用循环遍历数组
2.5.1、普通的循环
1、遍历：依次访问数组中每个元素。可以赋值，可以取值。 2、因为操作数组，就是数组名字配合下标，而下标固定都是从0开始，到长度减1。 for(int i = 0;i < arr2.length;i++){ Sy(arr2[i]); }示例代码：
class Test2ArrayFor { public static void main(String[] args) { //定义了一个数组，存储了5个学生的性别。 char[] arr2 = new char[5]; arr2[0] = '男'; arr2[1] = '男'; arr2[2] = '男'; arr2[3] = '女'; arr2[4] = '女'; /* Sy(arr2[0]); Sy(arr2[1]); Sy(arr2[2]); Sy(arr2[3]); Sy(arr2[4]); */ //借助循环来打印数组：for，while，do-while循环 for(int i = 0;i < arr2.length;i++){ //i:0,1,2,3,,5 Sy(arr2[i]); //arr2[0],arr2[1],arr2[2],arr2[3],arr2[4] } Sy);//专门用于获取一个数组的长度,5 //课堂练习1：定义一个int类型的数组，求该数组中所有元素的总和。 //课堂练习2：统计这个数组中元素的平均值。 } }
2.5.2、for-each循环
for-each循环：【扩展】 增强for循环：JDK1.5的版本出现的。 特定的用法：专门用于获取数组中的每一个元素的值。 语法结构： for(数据类型 变量名 : 数组名){ Sy(变量名); } 工作原理： for(int e :arr){ Sy(e); } int e，定义变量e， 依次获取数组的元素，赋值给e 注意点： A：for-each只能获取数组的数据，但是不能给数组进行赋值 B：for-each，在代码这个层面，不能操作下标。示例代码：
public class Test1ForEach { public static void main(String[] args){ /* 循环的遍历：依次获取里面的每一个元素 方法一：一个一个的获取 方法二：普通的循环：for循环 方法三：for-each循环： for(数据类型 变量名 : 数组名){ Sy(变量名); } element，元素。数组中存储的数据-->数组的元素。 */ int[] arr = new int[4]; arr[0] = 1; arr[1] = 4; arr[2] = 3; arr[3] = 5; //方法一： Sy(arr[0]); Sy(arr[1]); Sy(arr[2]); Sy(arr[3]); //方法二： for(int i=0;i < arr.length;i++){ Sy("--->" + arr[i]); } //方法三： /* index-->0,1,2,3 arr--->[1,4,3,5] 工作原理： int e，定义变量e， 依次获取数组的元素，赋值给e */ for(int e : arr){ //int e = 1; //e = 4; //e = 3; //e = 5; Sy(e); } Sy("------------------"); //普通的for循环赋值 int[] arr2 = new int[5];//1,3,5,7,9 for(int i = 0;i<arr2.length;i++){ //i:0,0 1 //i:1,2 3 //i:2,4 5 //i:3,6 7 //i:4,8 9 arr2[i] = i * 2 + 1; } for(int i=0;i<arr2.length;i++){ Sy(arr2[i]); } //通过for-each给数组进行赋值？不能给数组赋值。 for(int e : arr2){ // int e :1 e = 10;//仅仅是给变量e进行赋值，和arr2数组无关。 } for(int e : arr2){ Sy(e); } } }2.6、数组中的默认值
数组的默认值，就是数组创建后，里面存储的默认的数据。 数组的引用存在栈内存中，数组本身存在堆内存中。 数组创建完，就有默认的数据了。 数组中存储的默认值： 数组中是有默认值的 整数：0 小数：0.0 字符：\u0000 布尔：false 其他：null 示例代码：
class Test2DefaultValue { public static void main(String[] args) { /* 数组中存储的默认值： 数组中是有默认值的 整数：0 小数：0.0 字符：\u0000 布尔：false 其他：null arr[i]? 1.先根据arr中存储的地址，找到这块堆内存的数组元素。 2.找到这块数组内存后，根据i来获取对应的空间 */ int n ;//可能尚未初始化变量n Sy(n); int[] arr = new int[5]; for(int i = 0;i<arr.length;i++){ Sy(arr[i]);// } String[] arr2 = new String[3]; for(int i = 0;i < arr2.length;i++){ Sy(arr2[i]); } Sy("Hello World!"); } } 2.7、创建数组的其他语法
/* 动态创建数组：先创建数组，然后再根据下标一个一个存储数据。 A：先声明，再创建(分配内存空间) 数据类型 [] 数组名; 数组名 = new 数据类型[长度]; B：声明并创建 数据类型 [] 数组名 = new 数据类型[长度]; 数据类型 数组名[] = new 数据类型[长度]; //静态创建数组：声明，创建，赋值一起写完。 C：声明，创建，并赋值 数据类型[] 数组名 = {数值1,数值2,数值3,数值4.。。。}; //=左边声明数组，=右边，会先根据{}中数据的个数，然后再将{}中数据，按照顺序存储进去。 完成了几件事： 1.先声明：int[] c 2.根据{}中数组值的个数，开辟堆内存 3.将{}中的数组值，依次按照顺序存入数组中 D：声明，创建，并赋值 数据类型[] 数组名 = new 数据类型[]{数值1,数值2,数值3,数值4.。。。} */示例代码：
class Test3ArrayCreate { public static void main(String[] args) { //创建方式1：先声明，再创建 int[] a = null;//引用类型默认赋值null a = new int[5];//创建，有new表示开辟堆内存，创建数组了，才可以使用数组。 //创建方式2：声明和创建写一起 int[] b = new int[5]; Sy(a); //创建方式3：声明，创建，赋值，写一起 int[] c = {1,2,3,4,5}; /* 完成了几件事： 1.先声明：int[] c 2.根据{}中数组值的个数，开辟堆内存 3.将{}中的数组值，依次按照顺序存入数组中 */ Sy); for(int e :c){ Sy(e); } //创建方式4： int[] d = new int[]{1,2,3,4,5}; Sy); int[] e; e = new int[]{1,2,3,4,5}; for(int i:e){ Sy(i); } } } 2.8、数组的地址转移
Java中的数据分为两大类： 基本类型：4类8种 操作的都是数值本身 引用类型：数组 操作的是地址 基本类型进行赋值：数值 引用类型进行赋值：地址示例代码：
class Test4ArrayAddress { public static void main(String[] args) { /* 数组：引用类型的数据 数组名，存储是引用地址。 */ int[] a = new int[3]; Sy);//3 Sy(a);//a数组的地址 Sy(a[0]);//0 a[0] = 1; a[1] = 2; a[2] = 3; int[] b = {4,5,6,7}; Sy);//4 Sy(b);//b的地址 Sy(b[0]);//4 int[] c = a;//将a的值赋值给c，就是将a存储的数组的地址赋值给c //a和c存储的地址相同，那么就指向了同一个数组 Sy);//3 Sy(c);//a的地址 Sy(c[0]);//1 c[0] = 100; Sy(a[0]); Sy(b[0]); Sy(c[0]); b = c; b[1] = 200; Sy(a[1]);//200 Sy(b[1]);//200 Sy(c[1]);//200 Sy("Hello World!"); } } 内存分析：
三、数组在方法中的使用
3.1、数组作为参数
数组是引用类型：传递的是地址。就是参数也会指向这块内存。当方法结束的时候，参数就销毁了。
class Test5ArrayMethod { //设计一个方法，用于打印数组 public static void printArray(int[] arr){//int[] arr = a;a的地址给了arr，那么arr和 // a指向同一块内存的数组 for(int e : arr){ Sy(e +"\t"); } Sy(); } public static void main(String[] args) { int[] a = {1,2,3,4,5}; //设计一个方法，用于打印数组 printArray(a);//将a的地址，传递给arr Sy("Hello World!"); } }内存分析：
3.2、数组作为返回值
示例代码：
//设计一个方法，用于创建一个数组， 并赋值。数组要返回给调用处 public static int[] createArray(int len){ int[] arr = new int[len]; for(int i = 0;i <arr.length;i++){ arr[i] = i * 2; } return arr; } 3.3、可变参数【扩展】
概念：一个方法可以接收的参数的数量不定(0-多个)，但是类型固定。 语法：数据类型 ... 参数名，可变参数在方法中当数组使用。 注意事项： 1、如果参数列表中，除了可变参数还有其他的参数，可变参数要写在整个参数列表的最后。 2、一个方法最多只能有一个可变参数。 示例代码：
class Test6Array { //求一组int类型的数据的和 public static void getSum(int ... nums ){ int sum = 0; for(int i = 0;i <nums.length;i++){ sum += nums[i]; } Sy("结果：" + sum); } public static void main(String[] args) { /* 可变参数：同一种类型的参数，类型固定的，但是个数不固定。 语法的支持： 数据类型 ... 参数名 可变参数，类型固定，个数可变。0-多个 在方法中可变参数当数组使用 */ getSum(1,2,3); getSum(1,2,3,4,5,6,7,8,9,10); Sy("Hello World!"); } } 四、数组的排序
排序：数组是存储一组数据，而且这些数据是有顺序的。但是数值本身可能是无序的。通过算法来实现给数组进行排序，升序(数值从小到大)，降序(数值从大到小)。
4.1 冒泡排序
冒泡排序：思路(升序)：比较相邻的两个数，较大的数据需要向后移动。长度减1。
1、冒泡排序：Bubble Sort 原理：比较相邻的两个数，将较大的数，向后移动。 class Test7BubbleSort { public static void main(String[] args) { int[] arr = {15,23,8,10,7}; for(int i= 1; i<arr.length;i++){//控制轮数： //i=1,2,3,4 /* i=1, j<4 i=2, j<3 i=3, j<2 */ for(int j = 0;j < arr.length - i;j++){ if(arr[j] > arr[j+1]){ //交换 int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } for(int i = 0;i<arr.length;i++){ Sy(arr[i]); } } } 选择排序：思路(升序)：每次找个基准值，定一个变量k表示比较小的值的下标。每轮比较完，都在基准值上放一个比较小数。
4.2 选择排序
示例代码：
package com.qf.array; public class Test1SelectionSort { public static void main(String[] args) { /* * 选择排序： 思路： 每一轮找个基准值：在基准值上放一个比较小的数。 * * 定义一个变量k，用于标记比较小的数的下标 */ int[] arr = { 15, 23, 8, 10, 7 }; for (int i = 0; i < arr.length - 1; i++) { // i = 0,1,2,3,表示轮数 // 用于标记本轮中，要找的比较小的值。 int k = i; // 依次比较arr[k] for (int j = k + 1; j < arr.length; j++) { // 比较arr[k]和arr[j],如果arr[k]值大于arr[j]的值，将j赋值给k if (arr[k] > arr[j]) { k = j; } } // 交换arr[i]和arr[k] // i = 0, 第一轮：arr[0],arr[k] // i = 1,第二轮， arr[1],arr[k] // i =2,第三轮，arr[2],arr[k] if (k != i) { int temp = arr[i]; arr[i] = arr[k]; arr[k] = temp; } } // 排序后，打印数组 for (int e : arr) { Sy(e); } } } 五、Arrays工具类
5.1、工具类：Arrays
JDK提供好的类： A：Scanner，读取键盘 B：String，字符串 C：Math，数学的 D：Arrays，提供数组的常规操作的 E：System， 。。。在Arrays类中，提供了很多关于数组常用的操作方法。
5.2、数组的复制
就是将一个数组的数据，复制到另一个数值中。
方法一：通过循环，依次复制，将原数组的数据，一个一个，复制到目标数组中 方法二：Arrays类里方法：copyOf(原数组，新数组的长度)-->返回值是新数组 方法三：System类里的方法：arraycopy(原数组，原数组位置，新数组，新数组位置，拷贝的个数)示例代码：
package com.qf.array; import java.u; public class Test3Copy { public static void main(String[] args) { int[] a = {1,2,3}; int[] b = new int[10]; //数组的拷贝： //方法一：自己通过循环依次复制，吭哧吭哧 for(int i=0;i<a.length;i++){ b[i] =a[i]; } for(int e :b){ Sy(e); } Sy("---------"); //方法二：借助于Arrays类 /* * copyOf(int[] 原始数组，int 新数组的长度) * 返回值就是新的数组 * */ int[] c = Arrays.copyOf(a, 5);//int[] c = {1,2,3,0,0} for(int e:c){ Sy(e); } Sy("--------"); //方法三：借助于System类 /* * arraycopy(src, srcPos, dest, destPos, length) * 第一个参数：原始数组 * 第二个参数：从原始数组的哪个下标开始复制 * 第三个参数：目标数组 * 第四个参数：目标数组从哪个下标开始贴 * 第五个参数：拷贝几个数据 */ //int[] a = {1,2,3}; int [] d = new int[10]; Sy(a, 1, d, 5, 20); for(int e:d){ Sy(e+"\t"); } } } 六、二维数组
维度：dimension 数组：存储相同类型的一组数据。 一维数组：数组中存储的就是数据了。 二维数组：存储的是一维数组。本质也叫数组的数组。也被称为矩阵：行和列的。 多维数组。。。示例代码：
package com.qf.array; public class Test4TDArray { public static void main(String[] args) { //二维数组 //一维数组 int[] a = {1,2,3,4}; int[][] b = { {1,2,3}, {4,5,6}, {7,8,9,10} }; Sy(b);//打印的是b这个二维数组的地址 Sy);//3 Sy(b[0]);//第一个一维数组的地址 Sy(b[1]); Sy(b[2]); Sy(b[0][1]);//2 Sy(b[1][2]);//6 for(int i=0;i<b.length;i++){ for(int j = 0;j<b[i].length;j++){ Sy(b[i][j]+"\t"); } Sy(); } //遍历第三个一维数组 // for(int j = 0;j<b[2].length;j++){ // Sy(b[2][j]); // } Sy("------"); //for(数据类型 变量名 :数组) for(int[] arr :b){ for(int e :arr){ Sy(e+"\t"); } Sy(); } } } 示例代码：
package com.qf.array; public class Test5TDArray { public static void main(String[] args) { //二维数组的创建语法 //1.先声明，再创建 int[][] a = new int[3][4];//二维，一维一起创建 //2.先创建二维数组，后创建一维数组 int[][] b= new int[3][];//只是创建了二维数组，但是一维还没有创建 b[0] = new int[3]; b[1] = new int[4]; b[2] = new int[4]; //3.声明，创建，赋值 int[][] c = {{},{},{}}; //4. int[][] d = new int[][]{{},{},{}}; } } 七、作业
1、给定一个整数数组，例如{2，4，5，6，7，8}和一个数字，例如10，请设计一个方法，找出两个元素，并且使这两个数的和为给定数字，并打印出来。
2、某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5，然后再用加5后的数字除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。打印加密后的数字。
3、定义一个数组，存储以下数据：{1,2,3,4,5,6,7,8,9}，请查找该数组中，是否存在数字8。