数组
我们可以使用数组来保存同一个数据类型的多个数据
数组的特点
1. 数组的长度一旦确定就不能改变
1. 一个数组中元素的数据类型都是一样的数组的初始化
动态初始化
格式
数据类型[] 数组名 = new 数据类型[长度];
例如：
int[] array = new int[10];//动态初始化一个长度为10的数组，数组元素为int类型静态初始化
格式
数据类型[] 数组名 = new 数据类型[]{元素值1,元素值2,元素值3,...};
数据类型[] 数组名 = {元素值1,元素值2,元素值3,...};//省略格式
例如：
int[] array = new int[]{1,2,3,4};
int[] arr = {1,3,4,6};总结
静态初始化和动态初始化都可以实现对数组的初始化，那么我们在需要创建数组的时候应该如何选择呢？
如果数组元素都确定好了，并且个数有限的情况下我们可以使用静态初始化，因为更方便。如果只能确定数组的长度，数组的元素值需要后面再赋值的话可以使用动态初始化。
数组元素的表示
格式
数组名[索引值]
例如：
int[] arr = {1,2,3,4};
System.out.println(arr[0]);//输出数组arr的第一个元素
arr[2] = 5;//把数组arr的第3个元素值修改为5注意
- 索引值就是一个
int数字，代表数组当中元素的编号。 - 索引值从0开始，一直到“数组的长度-1”为止。例如长度为5的数组他的索引范围为0到4。
数组的内存数据结构
int[] arr1 = new int[4];
arr1[0] = 1;
arr1[1] = 2;
int[] arr2 = arr1;
arr2[2] = 3;
arr2[3] = 4;
System.out.println(arr1);//[I@7c30a502
System.out.println(arr2);//[I@7c30a502
System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]
System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4]如果想要弄明白上面代码的输出结果就需要知道一个数组在内存中是如何存储的。
实际上，数组的实体保存在堆中，数组名实际保存的是数组实体的地址值。
数组
长度
在java中我们可以非常方便的获取到数组的长度，格式如下：
数组名.length
例如：
int[] arr = {1,2,3,4};
//输出数组长度
System.out.println(arr.length);数组遍历
我们在操作数组的时候很多时候需要对数组的每个元素挨个操作一遍，这种情况下我们就可以对数组进行遍历操作。
int[] arr={1,2,3,4,5,7};
//遍历输出数组元素
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}常见问题
- 数组越界：数组定义的长度n，索引可使用的最大值为n-1。
索引值从0开始。
二维数组
二维数组是一维数组的扩展（一维数组嵌套），实质是一维数组中存放其他一维数组的地址，然后根据地址进行访问。
在找到内层的一维数组的地址后，其内部数据的操作和正常的一维数组相同。
初始化
格式示例：
public static void main(String[] args) {
int[][] arr1 = new int[3][2];//正常定义二维数组
int[][] arr2 = new int[4][];// 由于二维数组本质是一维数组嵌套的性质，在初始化的时候必须指定外层数组的个数
//int[][] arr2 = new int[][x];// 编译不通过
int[][] arr3 = new int[][]{{1,3},{2},{5,6,7}};// 相当于 int[][] arr1 = new int[3][3]; 并赋值
}二维数组的内存结构
二维数组的长度
由于是嵌套一维数组，外层长度指的是外层一维数组的长度，可以通过二维数组变量名称.length 得到。内存数组类似。
int[][] arr1 = new int[][]{{1,3},{2},{5,6,7}};
System.out.println(arr1.length);// 3 二维数组外层长度
System.out.println(arr1[0].length);// 2 二维数组内层第一个数组的长度
System.out.println(arr1[1].length);// 1 二维数组内层第二个数组的长度
System.out.println(arr1[2].length);// 3 二维数组内层第三个数组的长度二维数组遍历
int[][] arr = new int[3][2];
//循环赋值
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length ; j++) {
arr[i][j] = 2 * (j+1) - 1;
}
}
//打印二维数组
for (int i = 0; i < arr.length; i++) {
System.out.println(Arrays.toString(arr[i]));
}相关算法
- 二分查找(Binary Search)
- 冒泡排序
Arrays工具类
int[] arr = {21, 513, 34, 6, 32, 632, 44, 66, 13};
int[] arr1 = {21,42,354,345,12,2345,56};
//sortOne(arr);
Arrays.sort(arr);//从小到到排序
boolean equals = Arrays.equals(arr, arr1);//判断数组内容是否相等
int binarySearch = Arrays.binarySearch(arr, 32);//对有序数组进行二分查找，并返回数组下标，-1表示未找到。
System.err.println(binarySearch);
System.err.println(equals);//false
System.out.println(Arrays.toString(arr));//[6, 13, 21, 32, 34, 44, 66, 513, 632]面向过程实现
水仙花数
所谓的水仙花数是指：一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等于它本身。例如153，370，371，407等都是水仙花数，就拿153来说，153 = 111 + 555 + 333.
代码实现：
//面向过程实战：寻找水仙花数
public static void main(String[] args) {
seekNum();
}
private static void seekNum() {
int j = 0;
int k = 0;
int l = 0;
int[] nums;
int sum = 0;
for (int i = 100; i < 1000; i++) {
j = i / 100;
k = i / 10 % 10;
l = i % 10;
if (i == (j * j * j + k * k * k + l * l * l)) {
System.out.println(i + " 是一个水仙花数");
}
}
}九九乘法表
代码实现：
public static void main(String[] args) {
for (int i = 1; i <= 9 ; i++) {
for (int j = 1; j <= i; j++) {
System.out.printf(" %d x %d = %2d ",i,j,i*j);
}
System.out.println();
}
}斐波那契数列
斐波那契数列（Fibonacci sequence），又称黄金分割数列，因意大利数学家莱昂纳多·斐波那契（Leonardo Fibonacci）1202年以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：
1、1、2、3、5、8、13、21、34、55、89……
这个数列从第 3 项开始，每一项都等于前两项之和。
在数学上，斐波那契数列以如下被以递推的方法定义：
F(0) = 0,F(1) = 1,F(n) = F(n-1) + F(n-2) n属于自然数
代码实现：
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//int num = seekNum01(sc.nextInt());//递归函数
int num2 = seekNum02(sc.nextInt());//for循环
System.out.println(num2);
}
private static int seekNum02(int i) {
int tmp = 0;
int a = 1;
int b = 1;
for (int j = 1; j <= i-2; j++) {
tmp = a + b;
a = b;
b = tmp;
}
return tmp;
}
private static int seekNum01(int i) {
if(i == 1 || i ==2){
return 1;
}else {
return seekNum01(i -1) +seekNum01(i - 2);
}
}