Java一维数组与二维数组

1.概述

①Java语言中的数组是一种引用数据类型。不属于墓本数据类型。数组的父类是 object
②数组实际上是一个容器,可以同时容纳多个元素。(数组是一个数据的集合。)数组:面意思是一组数据
③数组当中可以存基本数据类型的数据,也可以存引用数据类型的数据。
④数组因为是引用类型,所以数组对象是堆内存当中。(数组是存储在堆当中的)
⑤数组当中如果存的是java对象的话,实际上存的是对象的引用(内存地址)
⑥数组一且创建,在java中规定,长度不可变。(数组长度不可变)
⑦数组的分类:一维数组、二维 数组、三维数组、多维数组…(一维数组较多,二维数组偶尔使用!)
⑧所有的数组对象都有length属性(java自带的),用来获取数组中元素的个数。
⑨java中的数组要求数组中元素的类型统一。比如int类型数组只能存储int类型, Person类型数组只能存 Person类型.(数组中存储的元素类型统一)
⑩数组在内存方面存的时候,数组中的元素内存地址(储存的每一个元素部是有规则的挨着排列的)是连续的。内存地址连续,数组存储元素的特点(特色)。数组实际上是一种简单的数据结构。
⒒所有的数组都是拿第一个小方框的内存地址作为整个数组的内存地址。(数组中首元素的内存地址作为整个数组对象）
⒓数组中每一个元素部是有下标的,下标从0开始,以1递增。最后一个元素的下标是: length-1
下标非常重要,因为我们对数组中元素进行存取的时候,都需要通过下标来进行。
13.数组这种数据结构的优点和缺点是什么
缺点:
第-:由于为了保证数组中每个元素的内存地址连续,所以在数组上随机删除或者增加元素的时候,
效率较低,因为随机增删元素会涉及到后面元素绕一向前或者向后位移的操作。
第二:数组不能存大数据量,为什么?
因为很难在内存空间上找到一块特别大的连续的内存空间。

2.定义一维数组

一.一维数组的声明格式：

数组元素的类型[] 变量名称
int[] array;
double[] array;
boolean[] array3
String[] array;
Object[] arrays

二.初始化一个一维数组

包括两种方式:静态初始化一维数组,动态初始化一维数组。
静态初始化语法搭式
int[] array={100,2100,300,55};
动态初始化语法格式
int[] array= new int[5];//这里的5表示数组的元素个数。
//初始化一个5个长度的int类型数组,每个元素默认0
String[] names= new String[6];//初始化6个长度的String类型数组,每个元素默认篇null。

三.实例

数组名.length的方式来获得数组的长度,即数组元素的个数,所有数组都有length属性
array.length

public class ArrayTest01 {
    public static void main(String[] args) {
        int[] a=new int[4];
        int[] a2={10,20,30,34};
        System.out.println(a.length);
        System.out.println(a2[0]);
        System.out.println(a2[a2.length-1]);
        //数组遍历
        for(int i=0;i<a2.length;i++){
            System.out.println("正序"+a2[i]);
        }
        for (int i= a2.length-1;i>=0;i--){
            System.out.println("倒序"+a2[i]);
        //System.out.println(a2[a.length]);ArrayIndexOutOfBoundsException    
        //数组下标越界异常
        }
    }
}

4
10
34
正序10
正序20
正序30
正序34
倒序34
倒序30
倒序20
倒序10

四.方法的参数是数组

public class ArrayTest03 {
    public static void main(String[] args) {
        int[] x={1,20,30,39};
        ArrayTest03.printArray(x);
        String[] str={"abc","asd","fuck"};
        ArrayTest03.printArray(str);
        System.out.println("---------------");
        int[] y=new int[4];
        printArray(y);
        System.out.println("*******************");
        String[] str2=new String[4];
        printArray(str2);
        System.out.println("******************");
        printArray(new int[3]);
       // printArray({"fuck","wtf","son of bitch"});java: 非法的表达式开始
        printArray(new String[]{"fuck","wtf","son of bitch"});

    }
    public static void printArray(int[] args){
        for (int i=0;i<args.length;i++){
            System.out.println(args[i]);
        }
    }
    public static void printArray(String[] args){
        for (int i=0;i<args.length;i++){
            System.out.println(args[i]);
        }
    }
}

1
20
30
39
abc
asd
fuck

---

0
0
0
0

---

null
null
null
null

---

0
0
0
fuck
wtf
son of bitch

五.main方法的String数组

如果配置了argue环境变量，默认则是0

public class ArrrayTest05 {
    public static void main(String[] args) {
        printArray(args);
        String[] str=new String[0];
        printArray(str);
    }
    public static void printArray(String[] args){
        System.out.println(args.length);
        for (int i=0;i< args.length;i++){
            System.out.println(args[i]);
        }
    }
}

3
abc
fcd
sfd
0

六.数组中存储引用数据类型

public class ArrayTest07 {
    public static void main(String[] args) {
        Animal[] animals=new Animal[2];
 /*       System.out.println(animals[0]);
        System.out.println(animals[1]);*/

        animals[0]=new Bird();
        animals[1]=new Cat();
        for (int i=0;i< animals.length;i++){
           if(animals[i] instanceof Bird){
              Bird bird=(Bird)animals[i];
              bird.Birdfly();
           }
           if (animals[i] instanceof Cat){
               Cat cat=(Cat)animals[i];
               cat.catchMouse();
           }

        }
       /* Cat c=new Cat();
        Bird b=new Bird();*/
/*        Animal[] animals1=new Animal[]{new Bird(),new Cat()};
        for (int i=0;i< animals1.length;i++){
            animals1[i].move();
        }*/
    }
}
class Animal{
    public void move(){
        System.out.println("Animal move");
    }

}
class Cat extends Animal{
    public void move(){
        System.out.println("Cat move");
    }
    public void catchMouse(){
        System.out.println("Catch mouse");
    }
}
class Bird extends Animal{
    public void move(){
        System.out.println("Bird move");
    }
    public void Birdfly(){
        System.out.println("bird fly");
    }
}

各种数据类型在内存的存储方式

七.数组拷贝

关于一维数组的扩容。
在java开发中,数组长度一旦确定不可变,那么数组满了怎么办?
数组满了,需要扩容
java中对数组的扩容是先新建一个大容量的数组,然后将小容量数组中的数据一个一个拷贝到大数组当中。
结论:数组扩容效率较低。因为涉及拷贝的问题。所以在以后的开发中请注意:尽可能少的进行数组的拷贝,可以在创建数组对象的时候预倍计以下多长合适,最好预估准确,这样可以减少数组的扩容次数。提高效率
System类的方法

语法：

System.arraycopy(被拷贝的数组对象，被拷贝数组的起始下标,拷贝的数组对象,拷贝数组对象的起始下标,需拷贝的对象数组长度)

public class ArrayTest08 {
    public static void main(String[] args) {
        int[] x={111,23,32};
        int[] y=new int[6];
        System.arraycopy(x,1,y,1,2);
        for (int i=0;i<y.length;i++){
            System.out.println(y[i]);
        }
        Object[] objs=new Object[]{"abc","cdf","fas"};
        Object[] newObjs=new Object[5];
        System.arraycopy(objs,0,newObjs,0,objs.length);
        for (int i=0;i<newObjs.length;i++){
            System.out.println(newObjs[i]);
        }
    }

}

0
23
32
0
0
0
abc
cdf
fas
null
null

八.二维数组

一.概述

关于java中的二维数组
①二维数组其实是一个特殊的一维数组,特殊在这个一维数组当中的每一个元素是一个一维数组。
②三维数组是什么?
三维数组是一个特殊的二维数组,特殊在这个二维数组中每一个元素是一个一维数组
实际的开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。
③二维数组静态初始化
int[][] array={{1,1,1},{2,3,4,5},{0,0,0,0}};

public class ArrayTest09 {
    public static void main(String[] args) {
        //二位数组初始化
        int[][] x = {{111, 21},
                {24334, 3, 34, 23},
                {24, 254, 345}
        };
        //二维数组length属性
        System.out.println(x.length);
        System.out.println(x[0].length);
        System.out.println(x[1].length);
        System.out.println(x[2].length);
        System.out.println("***************************************");
        //二维数组的元素访问
        int[] y = x[0];
        int y1=y[0];
        System.out.println(y1);//推导过程
        System.out.println(x[0][0]);
        System.out.println(x[2][2]);
       // System.out.println(x[2][3]);java.lang.ArrayIndexOutOfBoundsException
       System.out.println("***************************************");
       //二维数组的遍历
       for(int i=0;i< x.length;i++){
           for (int j=0;j<x[i].length;j++){
               System.out.print(x[i][j]+" ");
           }
           //换行
           System.out.println();
       }
    }
}

    }
}

3
2
4
3

---

111
111
345

---

111 21
24334 3 34 23
24 254 345

二.方法的参数是一个二维数组

package com.array;

public class ArrayTest12 {
    public static void main(String[] args) {
        //动态初始化
        int[][] a=new int[3][4];
        for(int i=0;i< a.length;i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("*****************");
        int[][] a1={
            {12,23,34,1},
            {124,2,78,90},
            {12,32,32,43}
        };
        printArray(a1);
    }
    public static void printArray(int[][] x){
        for(int i=0;i< x.length;i++) {
            for (int j = 0; j < x[i].length; j++) {
                System.out.print(x[i][j] + " ");
            }
            System.out.println();
        }
    }
}

三.二维数组是一个引用数据类型

package com.bjpowernode.hotel;

public class Room {
    private int no;
    private boolean status;
    private String type;

    public Room() {
    }

    public Room(int no, boolean status, String type) {
        this.no = no;
        this.status = status;
        this.type = type;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public boolean isStatus() {
        return status;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
    public boolean equals(Object obj){
        Room room=(Room)obj;
        return this.no==room.no;
    }
    public String toString(){
        return no+" "+(status?"有房":"空房")+" "+type;
    }

}
class roomtest{
    public static void main(String[] args) {
       hotel hotels=new hotel();
       hotels.print();
    }
}

package com.bjpowernode.hotel;

public class hotel {
    private Room[][] rooms;
    public hotel(){
        rooms=new Room[3][10];
        for (int i=0;i<=rooms.length-1;i++){
            for (int j=0;j<=rooms[i].length-1;j++){
                if(i==0){
                    rooms[i][j]=new Room(100*(i+1)+j+1,true,"标准间");
                }
                if(i==1){
                    rooms[i][j]=new Room(100*(i+1)+j+1,true,"单人间");
                }
                if(i==2){
                    rooms[i][j]=new Room(100*(i+1)+j+1,true,"双人间");
                }
            }
        }
    }
    public void print(){
        for (int i=0;i<=rooms.length-1;i++){
            for (int j=0;j<=rooms[i].length-1;j++){
                System.out.print(rooms[i][j]);
            }
            System.out.println();
        }
    }

}

3.Arrays工具类

2.2、算法实际上在java中不需要精通,因为java中已经封装好了,要排序就调用方法就行。例如:java中提供了一个数组工具类
java.util. Arrays
Arrays是一个工具类
其中有一个sort()方法和binarySerach(),可以排序和二分法查找。静态方法,直接使用类名调用就行

package com.bjpowernode3;


import java.util.Arrays;

public class ArraysTest01 {
    public static void main(String[] args) {
        int[] arrs={11,78,4,34,343,33};
        Arrays.sort(arrs);
        for(int i=0;i<arrs.length;i++){
            System.out.println(arrs[i]);
        }
        //二分法查找
       int index= Arrays.binarySearch(arrs,33);
        System.out.println(index);
    }
}

4
11
33
34
78
343
2
来自jdk1.8中文文档

binarySearch
public static int binarySearch(double[] a,double key)
使用二进制搜索算法搜索指定值的指定数组。数组必须排序（由 sort(double[])法）进行调用之前。如果它没有排序，结果是不确定的。如果数组包含具有指定值的多个元素，则无法找到一个将被发现的保证。这种方法认为所有的南值是等价的和平等的。 
参数 
a -阵列被搜查 
key -要搜索的价值 
结果 
索引的搜索关键字，如果它是包含在数组；否则， (-(insertion point) - 1)。的插入点被定义为在该点的关键是插入到数组的第一个元素大于：关键指标，或 a.length如果数组中的所有元素都小于指定的关键。请注意，这保证返回值将是> = 0，如果和只有一个键被发现。 

简单解释，binarySerach（查找数组名，查找值），找到则返回对应数组下标，没找到返回-1