数组:存储同一种数据类型的多个元素的容器。
定义格式：
A:数据类型[] 数组名;
B:数据类型 数组名[];
举例：
A:int[] a; 定义一个int类型的数组a变量
B:int a[]; 定义一个int类型的a数组变量
注意：效果可以认为是一样的，都是定义一个int数组，但是念法上有些小区别。
推荐使用第一种。
如何对数组进行初始化呢?
A:何谓初始化呢? 就是为数组开辟内存空间，并为每个数组元素赋予值
B:有几种方式呢?
a:动态初始化 只指定长度，由系统给出初始化值
b:静态初始化 给出初始化值，由系统决定长度
动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];
举例：
int[] arr = new int[3];
如何获取数组中的元素呢?
通过:
数组名[索引]
索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。
class ArrayDemo1 { public static void main(String[] args) { //定义一个数组 //int[] a; //可能尚未初始化变量a //System.out.println(a); int[] arr = new int[3]; /* 左边： int:说明数组中的元素的数据类型是int类型 []:说明这是一个数组 arr:是数组的名称 右边： new:为数组分配内存空间。 int:说明数组中的元素的数据类型是int类型 []:说明这是一个数组 3:数组长度，其实也就是数组中元素的个数 */ System.out.println(arr); //[I@1db9742 地址值。 //我要地址值没有意义啊，我就要数据值，怎么办呢? //其实数组中的每个元素都是有编号的，并且是从0开始。最大编号是数组的长度-1。 //用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法：索引 //通过数组名访问数据的格式是：数组名[索引]; System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); } }
数组的静态初始化：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
简化后：
int[] arr = {1,2,3};
注意事项：
不要同时动态和静态进行。
如下格式：
int[] arr = new int[3]{1,2,3}; //错误
class ArrayDemo2 { public static void main(String[] args) { //定义数组 int[] arr = {1,2,3}; System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); } }
数组操作的两个常见小问题：
ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。
NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
class ArrayDemo3 { public static void main(String[] args) { //定义数组 int[] arr = {1,2,3}; //System.out.println(arr[3]); //引用类型的常量：空常量 null arr = null; System.out.println(arr[0]); } }
数组遍历：就是依次输出数组中的每一个元素。
注意：数组提供了一个属性length，用于获取数组的长度。
格式：数组名.length
class ArrayDemo4 { public static void main(String[] args) { //定义数组 int[] arr = {1,2,3,4,5}; for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); } System.out.println("--------------------"); //调用遍历方法 printArray(arr);
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]+", "); } } } }
数组获取最值方法(获取数组中的最大值最小值)
分析：
A:定义一个数组，并对数组的元素进行静态初始化。
B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。
C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
D:最后参照物里面保存的就是最大值。
class ArrayDemo5 { public static void main(String[] args) { //定义一个数组 int[] arr = {10,50,80,123,115,198}; //请获取数组中的最大值 /* //从数组中任意的找一个元素作为参照物 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; } }
数组元素逆序方法 (把元素对调)
分析：
A:定义一个数组，并进行静态初始化。
B:思路
把0索引和arr.length-1的数据交换
把1索引和arr.length-2的数据交换
…
只要做到arr.length/2的时候即可。
class ArrayDemo6 { public static void main(String[] args) { //定义一个数组，并进行静态初始化。 int[] arr = {89,10,32,56,45}; //逆序前 System.out.println("逆序前："); printArray(arr); //逆序后 System.out.println("逆序后："); //reverse(arr);//方法1 reverse2(arr);//方法2 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]+", "); } } } }
数组查表法(根据键盘录入索引,查找对应日期)
举例：String[] strArray = {“星期一”,”星期二”,…};
import java.util.Scanner; class ArrayDemo7 { 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]); } }
数组元素查找(查找指定元素第一次在数组中出现的索引)
分析：
A:定义一个数组，并静态初始化。
B:写一个功能实现
遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较
如果相等，就返回当前的索引值。
class ArrayDemo8 { 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; } }
数组加密应用
运用知识点：
变量
数据类型
运算符
键盘录入
语句
方法
数组
需求：
某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，
在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
然后，把加密后的结果在控制台打印出来。
需求解析：
A:数据是小于8位的整数
定义一个int类型的数据
int number = 123456;
B:加密规则
a:首先将数据倒序
结果 654321
b:然后将每位数字都加上5，再用和除以10的余数代替该数字
结果 109876
c:最后将第一位和最后一位数字交换
结果 609871
C:把加密后的结果输出在控制台
D:把以上步骤做成通用的模型
通过简单的分析，我们知道如果我们有办法把这个数据变成数组就好了。
但不是直接写成这个样子的：
int[] arr = {1,2,3,4,5,6};
如何把数据转成数组呢?
A:定义一个数据
int number = 123456;
B:定义一个数组,这个时候问题就来了，数组的长度是多少呢?
int[] arr = new int[8]; //不可能超过8
在赋值的时候，我用一个变量记录索引的变化。
定义一个索引值是0
int index = 0;
C:获取每一个数据
int ge = number%10
int shi = number/10%10
int bai = number/10/10%10
arr[index] = ge;
index++;
arr[index] = shi;
index++;
arr[index] = bai;
…
//以下是思路解析 class JiaMiDemo1 { public static void main(String[] args) { //定义一个数据 int number = 123456; //定义一个数组 int[] arr = new int[8]; //把数据中每一位上的数据获取到后存储到数组中 /* int index = 0; arr[index] = number%10; //arr[0]=6; index++; arr[index] = number/10%10; //arr[1]=5; index++; arr[index] = mumber/10/10%10; //arr[2]=4; */ //通过观察这个代码，我们发现应该是可以通过循环改进的 int index = 0; //循环过程 while(number > 0) { //(1start)number=123456,(5)number=12345,(9)number=1234,(13)number=123,(17)number=12,(21)number=1,(25end)number=0 arr[index] = number%10; //(2)arr[0]=6,(6)arr[1]=5,(10)arr[2]=4,(14)arr[3]=3,(18)arr[4]=2,(22)arr[5]=1 index++;//(3)index=1,(7)index=2,(11)index=3,(15)index=4,(19)index=5,(23)index=6 number/=10;//(4)number=12345,(8)number=1234,(12)number=123,(16)number=12,(20)number=1,(24)number=0 } //然后将每位数字都加上5，再用和除以10的余数代替该数字 for(int x=0; x<index; x++) { arr[x] += 5; arr[x] %= 10; } //最后将第一位和最后一位数字交换 int temp = arr[0]; arr[0] = arr[index-1]; arr[index-1] = temp; //输出数据 for(int x=0; x<index; x++) { System.out.print(arr[x]); } System.out.println(); } }
把以上代码改成方法：
A:把数据改进为键盘录入
B:把代码改进为方法实现
import java.util.Scanner; class JiaMiDemo2 { public static void main(String[] args) { //创建键盘录入对象 Scanner sc = new Scanner(System.in); //请输入一个数据 System.out.println("请输入一个数据(小于8位)："); int number = sc.nextInt(); //写功能实现把number进行加密 //调用 String result = jiaMi(number); System.out.println("加密后的结果是："+result); } /* 需求：写一个功能，把数据number实现加密。 两个明确： 返回值类型：String 做一个字符串的拼接。 参数列表：int number */ public static String jiaMi(int number) { //定义数组 int[] arr = new int[8]; //定义索引 int index = 0; //把number中的数据想办法放到数组中 while(number > 0) { arr[index] = number%10; index++; number /= 10; } //把每个数据加5，然后对10取得余数 for(int x=0; x<index; x++) { arr[x] += 5; arr[x] %= 10; } //把第一位和最后一位交换 int temp = arr[0]; arr[0] = arr[index-1]; arr[index-1] = temp; //把数组的元素拼接成一个字符串返回 //定义一个空内容字符串 String s = ""; for(int x=0; x<index; x++) { s += arr[x]; } return s; } }
