Java进阶第四章——数据结构：数组
本章涉及到数组，原理可查阅：数据结构学习第二章线性表
栈，原理可查：”数据结构学习第三章栈
1.数组
-
JAVA中数组是一种引用数据类型，不属于基本数据类型。也就是数组的父类是Object。所以数组对象是堆内存当中。
-
数组可以同时容纳多个元素。可以存储基本数据类型数据，也可存储引用数据类型。
-
数组中如果存储的是“java"对象的话，实际上存储的是对象的”引用(内存地址)“，不能直接存储JAVA对象。
-
数组一旦创建，在java中长度不可变。
-
数组分类：一维数组、二维数组、多维数组……
-
所有数组对象都有length属性，用来获取数组元素的个数。
-
java中的数组要求元素类型统一。比如int类型只能存储int类型。
-
数组方便与“随机存取”，也就是根据数组下标能够直接存取。数组下标从0开始计数。
-
一维数组语法格式如下
int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;
- 初始化一个一维数组
//静态初始化语法格式
int[] array = {100,2100,300,55,12};
//动态初始化语法格式
int[] array = new int[5];//这里5表示数组元素个数
//意思为初始化5个长度int类型数组，每个元素默认值0
- JVM调用main方法时，会传一个String的数组过来，所以main方法上面有一个“ String[] args ”数组参数。
public class Test{
public static void main(String[] args){
System.out.println(args.length); // 0
//也就是说args没东西的数组
//没东西的数组 也就是 静态初始化数组不给任何值
String[] str = {};
System.out.println(str.length);//0
}
}
- 数组扩容：Java开发对数组扩容，新建一个大容量数组，将小容量数组一个一个拷贝进大容量数组（这种方式效率低）。
public class Test{
public static void main(String[] args){
//拷贝数组方法：System.arraycopy()
/**public static native void arraycopy(Object src, int srcPos,
* Object dest, int destPos,
* int length);
五个参数含义 （拷贝源，拷贝源起点，拷贝目标，拷贝目标起点，拷贝长度）
*/
//拷贝源
int[] src = {1,11,22,3,4};
//拷贝目标位置
int[] dest = new int[10];//动态初始化一个长度为20的数组，每个元素默认值0
//调用JDK中arraycopy方法完成数组拷贝
System.arraycopy(src,0,dest,3,5);
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i]+ " "); // 0 0 0 1 11 22 3 4 0 0
}
//存储元素是引用的话，也可以拷贝
//拷贝源
String[] strs = {"hello","ice","coffee"};
//拷贝目标位置
String[] dest = new String[10];//动态初始化一个长度为20的数组，每个元素默认值0
//调用JDK中arraycopy方法完成数组拷贝
System.arraycopy(strs,0,dest,0,3);
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i]+ " "); //hello ice coffee null null null null null null null
}
}
}
2.数组练习
- 静态初始化数组使用练习
public class Test {
public static void main(String[] args) {
//静态初始化了一个数组
int[] a = {100,200,300,400,500};
//数组在JAVA也支持C++风格的定义方式，不建议使用。
//int a[] = {100,200,300,400,500};
//length获取元素个数
System.out.println("数组元素个数：" + a.length); //数组元素个数：5
//获取第一个元素
System.out.println("数组第一个元素" + a[0]); //数组第一个元素100
//获取最后一个元素
//由于数组下标从0开始，所以最后一个元素下标是长度-1
System.out.println("数组最后一个元素" + a[a.length-1]); //数组最后一个元素500
//修改第一个元素的值
a[0] = 111;
System.out.println("第一个元素：" + a[0]); //第一个元素：111
}
}
- 静态初始化遍历数组
public class Test {
public static void main(String[] args) {
int[] a = {100,200,300,400,500};
//从前往后遍历
for(int i=0; i<a.length;i++){
System.out.println(a[i]); //100 200 300 400 500
}
System.out.println(a[6]);//ArrayIndexOutOfBoundsException：数组下标越界异常
//从后往前遍历
for(int i=a.length-1; i >= 0;i--){
System.out.println(a[i]); //500 400 300 200 100
}
}
}
- 动态初始化数组练习
public class Test {
//main方法中参数也可以采用C++格式
//public static void main(String args[])
public static void main(String[] args) {
//动态初始化数组，每一个元素都是默认值
//默认值一切向“零”看齐
int[] a = new int[4];
printArray(a);
String[] stray = new String[4];
printArray(stray);
//可以直接new
printArray(new String[3]);
printArray(new int[]{1,2,3});
}
//方法的参数是数组，main方法也是
public static void printArray(int[] array){
for(int i=0; i <array.length;i++){
System.out.println(array[i]); // 0 0 0 0
}
}
//方法的参数是数组，main方法也是
public static void printArray(String[] stray){
for (int i = 0; i < stray.length; i++) {
System.out.println(stray[i]);// null null null null
}
}
}
- 数组中存储引用类型练习
public class Test{
public static void main(String[] args) {
Cat c = new Cat();
Bird b = new Bird();
Animal[] a ={c,b};
for (int i = 0; i < a.length; i++) {
a[i].move();
//a[0].move-->猫在走路
//a[1].move-->鸟在飞
//若要使用子类特有方法，需要强制类型转换
if(a[i] instanceof Cat){
((Cat) a[i]).eat(); //猫在吃猫粮
} else if (a[i] instanceof Bird) {
((Bird) a[i]).catchEat();//鸟在捕猎
}
}
}
}
class Animal{
public void move(){
System.out.println("Animal move...");
}
}
class Cat extends Animal{
//重写父类方法
public void move() {
System.out.println("猫在走路");
}
//子类特有方法
public void eat(){
System.out.println("猫在吃猫粮");
}
}
class Bird extends Animal{
//重写父类方法
public void move() {
System.out.println("鸟在飞");
}
//子类特有方法
public void catchEat(){
System.out.println("鸟在捕猎");
}
}
3.二维数组
- 二维数组是一个特殊的一维数组，特殊在每个数组当中的元素都是一个一维数组。
public class ArrayTest{
public static void main(String[] args){
//一维数组
int[] array = {100,200,300};
//二维数组
int[][] a = {
{100,200,300},
{30,20,40,50,60},
{6,7,8,1},
{0}
};
System.out.println(a.length); //这个二维数组的元素个数为4个。
System.out.println(a[0].length); //二维数组第一个一维数组中的元素个数为3个。
}
}
-
三维数组是一个特殊的二维数组。
-
二维数组中，第一个括号为每个一维数组的下标，第二个括号为每个一维数组中元素的下标。
public class Test {
public static void main(String[] args) {
//二维数组
int[][] a = {
{100,200,300},
{30,20,40,50,60},
{6,7,8,1},
{0}
};
//取出第一个一维数组
int[] a2 = a[0]; //{100,200,300}
//这个一维数组的第二个元素
int a3 = a2[1];
System.out.println(a3); //200
//合并起来取第一个一维数组的第二个元素
System.out.println(a[0][1]); //200
//取第2个数组的第3个元素
System.out.println(a[1][2]); //40
}
}
- 遍历二维数组
public class Test01 {
public static void main(String[] args) {
//二维数组
String[][] a = {
{"咖啡","冰美式","拿铁","卡布奇诺"},
{"爱莉希雅","崩落符华","终焉","雷电芽衣"},
{"手绘","板绘"}
};
//遍历二维数组
for (int i = 0; i < a.length ; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.printf(a[i][j] + " ");
}
System.out.println();
//输出结果：咖啡 冰美式 拿铁 卡布奇诺
//爱莉希雅 崩落符华 终焉 雷电芽衣
//手绘 板绘
}
}
}
4.数组实践1—实现栈数据结构
-
需求：
①、栈可以存储Java中任何引用类型的数据。
②、栈中提供push方法压栈。
③、栈中一共pop方法模拟弹栈。
④、编写测试程序，new栈对象，调用push，pop方法来模拟压栈弹栈的动作。
package MyStack;
public class Test {
public static void main(String[] args) {
MyStack testStack = new MyStack();
//测试默认构造器构造的数组大小
System.out.println(testStack.elements.length); //5
MyStack myStack = new MyStack(3);
myStack.push(new String("杯冰美式")); //入栈成功，入栈元素：杯冰美式
myStack.push(2); //入栈成功，入栈元素：2
myStack.push("这是"); //入栈成功，入栈元素：这是
myStack.push("测试满栈压栈"); //栈已满，不可压栈
myStack.pop(); //这是
myStack.pop(); //2
myStack.pop(); //杯冰美式
System.out.println("-----这是分割线--------");
//测试空栈弹栈
myStack.pop();//栈为空，没有元素可以弹栈
}
}
public class MyStack {
//提供一个数组来存储栈元素，可以存储java中任何引用类型的数据用Object
Object[] elements;
//栈帧：定义栈顶指针
//每增加一个元素，栈帧+1；
//每减少一个元素，栈帧-1；
int index;
//初始化没有给容量大小的默认栈，定义容量大小为5
public MyStack() {
this.elements = new Object[5];
this.index = 0;
}
//初始化有给容量大小的默认栈
public MyStack(int number) {
this.elements = new Object[number];
this.index = 0;
}
//压栈方法
public void push(Object element){
if(this.index>=this.elements.length){
System.out.println("栈已满，不可压栈");
}else if(this.index<this.elements.length){
this.elements[index] = element;
this.index++;
System.out.println("入栈成功，入栈元素：" + element);
}
}
//弹栈方法
public void pop(){
if(this.index<=0){
System.out.println("栈为空，没有元素可以弹栈");
}else if(this.index>0){
System.out.println(this.elements[index-1] + " ");
this.index--;
}
}
}
5.数组实践2—简单实现一个酒店管理系统
-
需求：
编写一个程序实现：酒店管理系统、模拟订房、退房、打印所有房间状态等功能。
①、用户是酒店前台。
②、酒店使用一个二维数组来模拟。“Room[][] rooms;"
③、酒店的每一个房间都是一个java对象：Room
④、每一个房间Room属性：房间编号、房间类型、房间是否空闲。
⑤、系统有一个对外提供功能：
可以预定房间：用户输入房间编号，订房。
可以退房：用户输入房间编号，退房。
可以查看所有房间的状态：用户输入某个指令可以查看所有房间状态。
-
酒店测试类
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
RoomSystem roomSystem = new RoomSystem();
while(true){
System.out.printf("请输入相应功能：1为订房，2为退房，3为查看所有房间状态");
Scanner scanner = new Scanner(System.in);
int sc = scanner.nextInt();
if(sc==1){
System.out.printf("请输入要订购的房间，房间号在1~8之间：");
Scanner scanner1 = new Scanner(System.in);
int sc1 = scanner1.nextInt();
roomSystem.booking(sc1);
}
if(sc == 2){
System.out.printf("请输入要退房的房间，房间号在1~8之间：");
Scanner scanner1 = new Scanner(System.in);
int sc1 = scanner1.nextInt();
roomSystem.cancel(sc1);
}
if(sc == 3){
roomSystem.check();
}
else{
System.out.println("您输入的指令有错，请重新输入");
}
}
}
}
- 酒店房间类
public class RoomSystem {
//定义酒店有4行2列房间
Room[][] rooms = new Room[4][2];
public RoomSystem() {
//初始化房间
for (int i = 0; i < rooms.length; i++) {
for (int j = 0; j < rooms[i].length; j++) {
Room room = new Room();
room.setRoomnumber((i*2)+j);
room.setRoomtype("酒店房间");
room.setRoomstatus(false);
rooms[i][j] = room;
}
}
}
public void booking(int i){
Room room = rooms[(i-1)/2][(i-1)%2];
if(room.getRoomstatus()){
System.out.println("房间已被订购，请重新选房");
}else{
room.setRoomstatus(true);
System.out.println("订房成功，您的房间在第" + ((i+1)/2) +"行，第" + ((i%2)+2) + "列");
}
}
public void cancel(int i){
Room room = rooms[(i-1)/2][(i-1)%2];
if(room.getRoomstatus()){
System.out.println("您的房间第" + ((i+1)/2) +"行，第" + ((i%2)+2) + "列已经退房成功");
}else{
System.out.println("该房间为被订购，请查看房间状态");
}
}
public void check(){
//查看所有房间状态
for (int i = 0; i < rooms.length; i++) {
for (int j = 0; j < rooms[i].length; j++) {
System.out.printf(rooms[i][j].getRoomstatus() + " ");
}
System.out.println();
}
}
- 房间对象
public class Room {
private int roomnumber;
private String roomtype;
private boolean roomstatus;
public int getRoomnumber() {
return roomnumber;
}
public void setRoomnumber(int roomnumber) {
this.roomnumber = roomnumber;
}
public String getRoomtype() {
return roomtype;
}
public void setRoomtype(String roomtype) {
this.roomtype = roomtype;
}
public void setRoomstatus(boolean roomstatus) {
this.roomstatus = roomstatus;
}
public boolean getRoomstatus(){
return roomstatus;
}
}
——本章节为个人学习笔记。学习视频为动力节点Java零基础教程视频：动力节点—JAVA零基础教程视频