数组
概念
数组是存储多个变量（元素）的东西（容器），这多个变量的数据类型要一致。
在实际的开发过程中，我们经常会面对同时处理大量的数据，如果同时声明这么多的变量显然不现实，Java给我们提供了数组来解决这个问题。
数组是存储同一种数据类型多个元素的集合。
数组既可以存储基本数据类型，也可以存储引用数据类型。
数组的定义语法
语法一： 数据类型 [ ] 数组名；
语法二： 数据类型 数组名 [ ]
数组的初始化
Java中的数组必须先开始初始化，然后才能使用。
所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
初始化的分类
动态初始化：只指定长度，由系统给出初始化值
静态初始化：给出初始化值，由系统决定长度
两种方式只能二选一，不能动静结合。
初始化的语法
动态初始化： 数据类型 [ ] 数组名 = new 数据类型 [ 数组长度 ] ;
静态初始化： 数据类型 [ ] 数组名 = { 元素1,元素2,元素3…… } ;
数组长度就是数组中元素的个数。
举例：
int [] arr1 = new int [3] ;
即定义了一个名叫arr1的int类型的新数组，这个数组中有3个元素。
int [] arr2 = {1,2,3} ;
即定义了一个名叫arr2的int类型的新数组，这个数组中的元素是：1,2,3
Java中的内存分配以及栈和堆的区别
栈：存放的是局部变量(在方法定义中或者方法声明中的变量)
堆：存放的是所有new出来的东西
堆的特点：
1、每一个new出来的东西都会为其分配一个地址值
2、每一个变量都有一个默认的值
byte，short，int，long – 0
float，double – 0.0
char – ‘\u0000’
boolean – false
引用数据类型 – null
3、使用完后就变成了垃圾，等待垃圾回收器对其回收
数组部分常见的小问题
1、ArrayIndexOutOfBoundsException——数组索引越界异常
原因：访问了不存在的索引
2、NullPointerException——空指针异常
原因：数组已经不再指向堆内存了，还用数组名去访问元素。
数组的基本操作——遍历
public class MyArray{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//arr.length就是数组中的元素个数
for(int i = 0 ; i < arr.length ; i++){
System.out.println(arr[i]);
}
}
}
数组的基本操作——获取最值
public class MyArray2{
public static void main(String[] args){
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//假设第一个数最大,注意数组中的第一个数的地址是0而不是1
int max = arr[0];
//记录最大值的地址
int maxIndex = 0;
//arr.length就是数组中的元素个数,从第二个数开始找
for(int i = 1 ; i < arr.length ; i++){
//如果第一个数后面的数比它大，就把这个数的值赋给max
if(arr[i] > max){
max = arr[i];
maxIndex = i;
}
System.out.println("最大值是："+"max");
System.out.println("它是数组中第"+(maxIndex+1)+"个数");
}
}
数组的基本操作——反转（元素对调）
public class MyArray3{
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//输出变化前的数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//把整个数组分为前后两部分，一一对调。
for (int i = 0; i < arr.length / 2; i++) {
//定义temp变量来记录值
int temp = arr[i];
//arr.length - i - 1 是对调目标的地址，如果我们i值从1开始，就不必再减1
arr[i] = arr[arr.length - i - 1];
//完成对调
arr[arr.length - i - 1] = temp;
}
//输出变化后的数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
关键部分的另外一种写法：
//首尾元素交换
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
数组的基本操作——查表法
import java.util.*;
public class MyArray4 {
public static void main(String[] args) {
String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
System.out.println("请输入一个整数0-6");
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
String b = getIndex(week, a);
System.out.println("你要查找的是：" + b);
}
//创建一个私有的方法来查找
private static String getIndex(String[] arr, int index) {
if (index >= 0 && index <= 6) {
String s = arr[index];
return s;
} else {
return ("指令错误");
}
}
}
二维数组
语法
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组；
n表示每一个一维数组的元素个数。
举例：
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素
以下格式也可以表示二维数组
a:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
这两种格式不推荐使用
注意下面定义的区别
int x,y;
int[] x,y[];
区别是:
int[] x,y[]; //定义了两个数组 一个是一维数组x 一个是二维数组y
public class MyArray5 {
public static void main(String[] args) {
//一位数组表示班级，二维数组表示学生，三个班，每个班两个人
String[][] school = new String[3][2];
school[0] = new String[]{"张小凡","陆雪琪"};
school[1] = new String[]{"哈利波特","伏地魔"};
school[2] = new String[]{"马云","马化腾"};
System.out.println(school[0][0]);
System.out.println(school[0][1]);
System.out.println(school[1][0]);
System.out.println(school[1][1]);
System.out.println(school[2][0]);
System.out.println(school[2][1]);
}
}
另外一种格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
String[][] school = {{"张小凡","陆雪琪"},{"哈利波特","伏地魔"},{"马云","马化腾"},};
二维数组的遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。
public class MyArray6 {
public static void main(String[] args) {
String[][] school = new String[3][2];
school[0] = new String[]{"张小凡", "陆雪琪"};
school[1] = new String[]{"哈利波特", "伏地魔"};
school[2] = new String[]{"马云", "马化腾"};
//遍历,school.length是一维数组的个数，school[i].length是每层一维数组中的元素个数
for (int i = 0; i < school.length; i++) {
for (int j = 0; j < school[i].length; j++) {
System.out.println(school[i][j]);
}
}
}
}
二维数组练习——求和
案例演示
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
public class MyArray5 {
public static void main(String[] args) {
int[][] turnover = {{22, 66, 44},{77, 33, 88},{25, 45, 65},{11, 66, 99}};
int totalMoney = 0;
for (int i = 0; i < turnover.length; i++) {
for (int j = 0; j < turnover[i].length; j++) {
totalMoney = totalMoney + turnover[i][j];
}
}
System.out.println("年销售总额为"+totalMoney);
}
}
需求：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
分析：看这种图像的规律
A:任何一行的第一列和最后一列都是1
B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
步骤：
A:首先定义一个二维数组。行数n由键盘录入，列数待定。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值：从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
D:输出
public class YangHuiTriangle {
public static void main(String[] args) {
//键盘录入行数
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个正整数代表你想要打印多少行的杨辉三角：");
int n = scanner.nextInt();
//创建一个二维数组，行数由控制台输入给定，列数待定
int[][] arr = new int[n][];
//开始赋值，外层循环表示行数
for (int i = 0; i < n; i++) {
//arr[i]表示二维数组arr中的第i+1层一维数组，即杨辉三角的行数；
//例：arr[0]就是第1层一维数组……；
//new int [i+1] 表示第i+1层一维数组有i+1元素，即杨辉三角每行的列数；
//例：arr[0] = new int [0+1]，表示第1层一维数组中有1个元素；
//我们观察图形发现第一行有一个元素，第二行有两个元素……故用这种方法完成二维数组的定义。
arr[i] = new int[i + 1];
//每行的第一个元素和最后一个元素为1
arr[i][0] = arr[i][i] = 1;
//内层循环表示列数
for (int j = 0; j < i + 1; j++) {
//从第三行开始，即i>1,每一个数据是它上一行的前一列和它上一行的本列之和。
if (i > 1 && (j > 0 && j < i)) {
arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
}
//输出这一行的元素
System.out.print(arr[i][j]);
}
//换行
System.out.println();
}
}
}
递归
方法定义中调用方法本身的现象
递归的注意事项：要有出口，否则变成死龟 (0_0)’ ……
次数不能太多，否则就内存溢出。
案例：求5的阶乘
public class Factorial {
public static void main(String[] args) {
MyFactorial myFactorial = new MyFactorial();
int goCal = myFactorial.GoCal(5);
System.out.println(goCal);
}
}
class MyFactorial {
public int GoCal(int i) {
if (i == 1) {
return 1;
} else {
return i * GoCal(--i);
}
}
}
案例：不死神兔问题（斐波那契数列）
A:案例演示: 需求：兔子问题(斐波那契数列)
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 …
使用递归一层一层的调，再一层一层的返回
public class MyFibonacciList {
public static void main(String[] args) {
int rabbit = Rabbit(20);
System.out.println(rabbit);
}
// 1 1 2 3 5 8 13 21 斐波那契数列 从第三个数开始，每个数等于他前两个数之和
//这个递归的出口在月数等于1或者月数等于2，我们不断地调法方法，方法不断的返回前两个数的和
private static int Rabbit(int months){
if( months==1 || months==2 ){
return 1;
}else{
return Rabbit(months-1)+Rabbit(months-2);
}
}
}
这个问题其实使用数组也能做：
public class Rabbit{
public static void main(String[] args){
int[] arr = new int[20];
arr[0] = 1;
arr[1] = 2;
for(int i = 2; i < arr.length; i++){
arr[i] = arr[i-1] + arr[i-2];
}
system.out.println(arr[20]);
}
}