数组

数组

介绍

• 引用数据类型

• 保存多个同类型的数据

• 可存储基本数据类型数据，也可以存储引用数据类型的数据

• 存储的数据内存地址连续

优缺点

• 优点

  • 查找某个元素的效率极高

    • 下标的计算不复杂：首地址+下标x类型在内存中所占大小

• 缺点

  • 删除或者修改的时候，为了保证内存地址连续，需要将后面所有的数据向前或者向后迁移，效率降低

  • 不能存储大数据量，因为需要保证一段连续的内存地址

数组的使用

声明数据

int [] iarray;

初始化数组

int [] iarray = new int[5]; // 什么5个元素的数组，初始值为0
 String[] sarray = new String[5];
 int[] iarray = {1,2,3,4} // 静态初始化
 System.out.println(iarray[0]);
 System.out.println(iarray[iarray.length-1])

• 每个数组都有length属性，标志数组的长度

• 静态初始化 int[] array = {....}

• 动态初始化 int[] array = new int[5]

遍历数组

for(int i = 0;i System.out.println(iarray[i]);
 }

// 倒叙
 for(int i = array.length-1;i>=0;i--){
 System.out.println(iarray[i]);
 }

方法参数为数组

public void printArray(int[] array){
 for(int i = 0;i System.out.println(array[i]);
 }
 }

// 调用
 int[] array = new int[4];
 array = {1,2,3,4};
 printArray(array);
 printArray(new int[4]);
 printArray(new int[]{1,2,3,4});

引用数据类型

class Animal{
 public void move(){
 System.out.println("动物");
 }
 }
 class Bird extends Animal{
 public void move(){
 System.out.println("鸟");
 }
 }
 public class Test{
 public static void main(String[] args){
 Animal[] animals = new Animal[4];
 for(int i = 0;i<4;i++){
 animals[i] = new Bird();
 }
 animals[1].move();
 }
 }

数组扩容

• 数组满了，需要新建一个大的数据，进行所有数据的迁移，这种行为会涉及到数据的拷贝，使运行效率降低

数组拷贝

System.arraycopy()

 int[] src = {1,2,3,4};
 int[] dest = new int[20];
 System.arraycopy(src,0,dest,0,src.length);
 for(int i =0;i System.out.println(dest[i]);
 }

二维数组

定义

二维数组的元素是一维数组

初始化

int[][] arrs = {{1,2,3,4},{1},{2,3}};

二维数组的长度

Tips： java 数组不是矩阵类型的，二维数组的每个一维数组元素的长度可以不相同。不会自动填充

int[][] arrays = {{1,3,4},{1}};
 for(int[] i : arrays){
 for(int a:i){
 System.out.print(a+" ");
 }
 System.out.println();
 }
 arrays.length;

[图片上传失败...(image-4fbc43-1593345186441)]

[图片上传失败...(image-a97007-1593345186441)]

// 作业一：
 public class MyStack {
 Object[] objects;
 int index;
 ​
 public MyStack(int length) {
 this.objects = new Object[length];
 this.index = 0;
 }
 public void push(Object object){
 if(index==objects.length){
 System.out.println("栈满了");
 return;
 }
 objects[index] = object;
 index++;
 }
 public Object pop(){
 index--;
 if(index<0){
 System.out.println("栈空了");
 return null;
 }
 return objects[index];
 }
 ​
 public static void main(String[] args) {
 MyStack myStack = new MyStack(2);
 myStack.push(new Object());
 myStack.push(new Object());
 myStack.push(new Object());
 myStack.pop();
 myStack.pop();
 myStack.pop();
 }
 }
 ​

// 作业2：
 import java.util.Scanner;
 ​
 public class HotelManage {
 private Room[][] rooms;
 ​
 public HotelManage() {
 this.rooms = new Room[][]{{new Room(1), new Room(2)},{new Room(3),new Room(4)}};
 }
 public void bookRoom(int id){
 for (int i = 0; i < rooms.length; i++) {
 for (int j = 0; j < rooms[i].length; j++) {
 if (rooms[i][j].id==id){
 rooms[i][j].isFree=false;
 System.out.println("预定成功");
 return;
 }
 }
 }
 System.out.println("该房间已经被预定了，请重新选择");
 return;
 }
 public void cancelRoom(int id){
 for (int i = 0; i < rooms.length; i++) {
 for (int j = 0; j < rooms[i].length; j++) {
 if (rooms[i][j].id==id){
 rooms[i][j].isFree=true;
 System.out.println("取消成功");
 return;
 }
 }
 }
 System.out.println("该房间没有被预定了，请重新选择");
 return;
 }
 public void roomState(){
 for (int i = 0; i < rooms.length; i++) {
 for (int j = 0; j < rooms[i].length; j++) {
 System.out.println(rooms[i][j].toString());
 }
 }
 }
 ​
 public static void main(String[] args) {
 HotelManage hotelManage =new HotelManage();
 hotelManage.roomState();
 int id;
 Scanner scanner = new Scanner(System.in);
 id = scanner.nextInt();
 System.out.println(id);
 hotelManage.bookRoom(id);
 hotelManage.cancelRoom(id);
 }
 }
 class Room{
 int id;
 boolean isFree;
 RoomType roomType;
 public Room(){
 this.id = 0;
 this.isFree = true;
 this.roomType = RoomType.SMALL;
 }
 ​
 public Room(int id) {
 this.id = id;
 this.isFree = true;
 this.roomType = RoomType.SMALL;
 }
 ​
 public Room(int id, boolean isFree, RoomType roomType) {
 this.id = id;
 this.isFree = isFree;
 this.roomType = roomType;
 }
 ​
 @Override
 public String toString() {
 return "Room{" +
 "id=" + id +
 ", isFree=" + isFree +
 ", roomType=" + roomType +
 '}';
 }
 }
 enum RoomType{
 BIG("大房间"),SMALL("小房间"),MID("中等房间");
 String name;
 ​
 RoomType(String name) {
 this.name = name;
 }
 ​
 @Override
 public String toString() {
 return name;
 }
 }
 ​

数组工具类

• java.util.Arrays

• 数组排序

  • Arrays.sort()

  • 排序算法：

    • 冒泡排序

    • 选择排序

• 查找算法

  • 直接查找

  • 二分法查找

  • 工具类

    • binarySearch 二分法查找

 public static void bubbleSort(int[] arrays){
 for (int i = 0; i < arrays.length - 1; i++) {
 for (int j = 0; j < arrays.length - i - 1; j++) {
 if(arrays[j]>arrays[j+1]){
 int temp = arrays[j];
 arrays[j] = arrays[j+1];
 arrays[j+1] = temp;
 }
 }
 }
 }

// 选择排序算法
 public static void selectSort(int[] arrays){
 for (int i = 0; i < arrays.length-1; i++) {
 int min=i+1;
 for (int j = i+1; j < arrays.length; j++) {
 if (arrays[j] min = j;
 }
 }
 int temp = arrays[min];
 arrays[min] = arrays[i];
 arrays[i] = temp;
 }
 ​
 return;
 }

 // 二分法查找
 public static int binaryFind(int[] arrays,int dest){
 int min = 0;
 int max = arrays.length;
 while (min<=max){
 int middle = (max+min)/2;
 if(arrays[middle]==dest)
 return middle;
 else if(arrays[middle] min = middle+1;
 else
 max = middle-1;
 }
 return -1;
 }