数组和作业

数组

1. 数组当中可以存储“基本数据类型”和引用数据类型

2. 数组因为是引用类型，所以数组对象是在堆内存中

3. 数组当中如果存储的是java对象的化，实际上存储的是对象的引用（内存地址）

4. 数组一旦创建，在java中规定，长度不可变

5. 数组有：一维数组，二维数组，.....

6. 所有数组对象都有length属性（java自带的），用来获取数组中元素的个数

7. java中的数组要求数组中元素的类型统一，比如int类型数组只能存储int类型，person类型只能存储person类型

8. 数组在内存的时候，数组中的元素的内存地址都是规则的有规律的排列的

9. 数组的内存地址就是第一个小方框的内存地址

10. 数组的第一个元素小标为0 第二个为1 最后一个为length-1

11. 数组的优缺点

    • 优点：查询某个小标上的元素时效率高

      为什么效率高？

      • 每一个元素的内存地址在空间存储上都是连续的

      • 每一个元素类型相同，所以占用空间大小一样

      • 知道第一个元素内存地址，知道妹妹一个元素占用的空间的大小，通过一个数学表达式可以计算出某个下表上元素的内存地址，直接通过内存地址定位元素

      • 所有无论素组是存储100个元素还是一百万给元素，在元素查询的方面，效率都是相同的，因为数组查找不会一个一个找，而是通过计算，直接定位

    • 缺点：

      • 由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加一个元素，都要将后面的元素向前或者向后移，

      • 数组无法存储大数据量，因为很难找到一块特别大的连续的内存空间

12. 对于数组中最后一个元素增加删除没有影响

13. 声明定义一个一维数组

    • 语法格式

      int[] array1;

      double[] array2;

Object[] array3;

boolean[] array4;

String[] array5;

1. 怎么初始化一个 一维数组？

   • 静态初始化语法格式：

     int[] array1 ={100.200.300.100};

   • 动态初始化语法格式：

     int[] array2 = new int[5];这里的5表示数组的元素的个数（数组长度length为5，每个元素的默认值为 0）

package laodu03;
​
public class Arrat01 {
    public static void main(String[] args) {
​
        //创建一个静态数组数组
        int[] a = {100,200,300,400,500,600};
        System.out.println("该数组长度为"+a.length);
        System.out.println("该数组第一个元素为"+a[0]);
        System.out.println("该数组最后一个元素为"+a[a.length-1]);
        //改变数组元素的值
        a[0] = 10;
        a[a.length-1] = 20;
        System.out.println("该数组第一个元素为"+a[0]);
        System.out.println("该数组最后一个元素为"+a[a.length-1]);
​
        //遍历输出每一个数组的元素
        for (int i = 0; i < a.length; i++) {
            System.out.println("第"+(i+1)+"个元素为"+a[i]);
        }
        System.out.println("-------------------------------------");
        //倒叙输出数组中的每一个元素
        for (int i = a.length-1; i >=0; i--) {
            System.out.println("第"+(i+1)+"个元素为"+a[i]);
        }
    }
}
​

package laodu03;
​
public class Array02 {
    public static void main(String[] args) {
        //创建一个数组
        int[] a = {10,20,14,15,16,78};
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("------------------------------");
        //调用数组打印方法
        int[] b = new int[4];
        b[0] = 1;
        b[1 ] = 2;
          ArrayPrint(b);
          ArrayPrint(a);
​
    }
    //创建一个数组打印方法
    public static void ArrayPrint(int[] pdd){
        for (int i = 0; i < pdd.length; i++) {
            System.out.println(pdd[i]);
        }
    }
}
​

  如果数组中存的是一个引用数据类型

public class Array03 {
    public static void main(String[] args) {
        //创建Animal对象
       /* Animal a1 = new Animal();
        Animal a2 = new Animal();
        //创建Animal 类型的数组
        Animal[] animals = {a1,a2};
        for (int i = 0; i < animals.length; i++) {
            animals[i].move();
        }
*/
        //创建dog和mouth对象
        Dog d = new Dog();
        Mouth m = new Mouth();
        //创建一个Animal类型的数组
        Animal[] a = {d,m};
        //遍历数组并且输出
        for (int i = 0; i < a.length; i++) {
​
            //因为子类中存在特有的方法Animal类型不误调用，所以进行向下转型
            if (a[i] instanceof Dog){
                Dog dog = (Dog)d;
                dog.lache();
                dog.move();
            }else if (a[i] instanceof Mouth){
                  Mouth mouth = (Mouth)m;
                  mouth.dance();
                  mouth.move();
            }
        }
    }
}
class Animal{
    public void move(){
        System.out.println("动物在移动");
    }
}
class Mouth extends Animal{
    //重写move方法
    public void move(){
        System.out.println("杰瑞在偷牛奶");
    }
    //定义一个子类独有的方法
    public void dance(){
        System.out.println("杰瑞在和汤姆跳舞");
    }
​
}
class Dog extends Animal{
    //重写move方法
    public void move(){
        System.out.println("萨摩耶在微笑");
    }
    //定义一个子类独有的方法
  public void lache(){
      System.out.println("雪橇三傻在啦车");
  }
}
​

数组的扩容

1. 在java开发中，数组长度一旦确定不可变，那么数组满了怎么办？

   • 数组满了，需要扩容。

   • java中对数组的扩容是： 先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大容量的数组中

   • 结论：数组扩容效率较低

   //把这个数组拷贝到另外一个数组这个数组我们叫他源
   int[] a = {1,2,3,4,5,6};
   //这个数组为目标数组 目标数组长度为10
   int[] b = new int[10];
   //开始拷贝，拷贝调用的是system.arraycopy的方法
    System.arraycopy(a ,0 ,b ,0 ,a.length)//里面的值分别是源数组，拷贝的起始位置，目标数组，目标数组的起始位置，拷贝的长度
        

   二维数组

   1. 二维数组其实就是一个特殊的以为数组，特殊在这个二维数组当中每一个元素都是一个一维数组

      //定义一个一维数组
      int[] a = {1,2,3,4,5,60};
      //定义一个二维数组
      int[][] b = {{1，2，3，4，5},{1，4，5，9},{2，5，9},{7，9}}//每一个元素都是一个以为数组
      ​

   2. 遍历二维数组(静态的)

      public class Test05 {
          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++) {
                      String c = a[i][j];
                      System.out.print(c+" ");
                  }
                  System.out.println();
              }
          }
      }
      ​

   3. 动态的二维数组与静态差不多

public class Test05 {
    public static void main(String[] args) {
        String[][] a = new String[3][4];
        //遍历二维数组
        for (int i = 0; i < a.length; i++) {
            //里面再套一个循环
            for (int j = 0; j < a[i].length; j++) {
                String c = a[i][j];
                System.out.print(c+" ");
            }
            System.out.println();
        }
    }
}

1. 作业

   • 编写程序，使用一维数组，模拟栈数据结构

     • 要求这个栈可以存储java中的任何引用类型的数据

     • 在栈中提供push方法模拟压栈

     • 在栈中提供pop方法模拟弹栈

     • 编写测试程序，new栈对象，条用push pop方法来模拟压栈弹栈动作

！：父类的数组中可以存储子类的类型元素如上面的Animal

Animal a = {new Cat（），new Dog（），new Mouth（）}；

在如Object是所有类的父类，所以他什么元素都可以存

package laodu03;
​
public class HomeWork {
 public static void main(String[] args) {
     Object[] a ={ new MyStack()，new Wife(),"张三"，123}
​
 }
​
}
​
 class MyStack{
​
​
 }
class Wfie{
    
}
​