java学习初探八之数组一维数组、二维数组

一、一维数组

1.数组

（1）数组是一种引用类型。

（2）数组是一种简单的数据结构，线性的结构。

（3）数组是一个容器，可以用来存储其他元素。

数组是可以存储任意数据类型的元素。

（4）数组分为：一维数组、二维数组、三维数组、多维数组。

（5）数组中存储的元素类型是统一的。

（6）数组长度不可改变，数组一旦创建，长度是不可改变的，固定的。

数组优点：查找效率高。因为数组中的存储元素的类型是统一的，每个元素在内存中所占的空间大小是相同的，知道数组的首元素的内存地址，要查找的元素只要知道下标就可以快速的计算出偏移量，通过首元素内存地址加上偏移量快速计算出要查找元素的内存地址，通过内存地址快速定位该元素，所以数组查找元素的效率高。

缺点：随机的增删元素效率比较低。因为当增加元素的时候，为了保证数组中元素在空间存储上是有序的，所以被添加元素位置后面的所有元素都要向后移动。删除元素也是，后面所有的元素向前移动，所以数组的增删效率很低。

2.一维数组数组静态初始化

public class ArrayTest01 {
public static void main(String[] args) {
// 声明一个一维数组，用来存储int类型
int[] a1={100,200,150,300 };//静态初始化一维数组
//boolean类型数组
boolean[] a2={true,false,false};
//string类型数组
String[] str={"AB","CD","EF"};
//object数组
Object[] obj={'a','b','c'};
Object o1=new Object();
Object o2=new Object();
Object o3=new Object();
Object[] objs={o1,o2,o3};
}
}

下图是数组内存分析



一维数组初始化:静态和动态

public class ArrayTest02 {
public static void main(String[] args) {
// 静态初始化一个int类型的一维数组
int [] a1={10,20,30};
//以下方式声明也可以
//int a1[]={10,20,30};
System.out.println("第一个元素："+a1[0]);
System.out.println("最后一个元素："+a1[a1.length-1]);
System.out.println("数组中元素的个数："+a1.length);
//遍历一维数组
for(int i=0;i<a1.length;i++){
System.out.println(a1[i]);
}
//将第二个元素修改为100
a1[1]=100;
System.out.println("重新赋值后的元素："+a1[1]);
//动态声明一个int类型的数组，最多可以存储4个元素
int [] b=new int[4];

}
}

2.动态初始化一维数组详解

/*
* 1.动态初始化一维数组，会现在堆内存中分配这个数组，并且数组中每个元素都采用默认值。
*  byte,short,int,long 0
*  float double 0.0
*  boolean false
*  char \0000
*  引用 null
* 2.无论动态初始化还是静态初始化，最终在内存的分别都是一样的。
* 3.如果在创建数组的时候，知道数组中应该存储什么数据，这个时候当然采用静态初始化
*  如果在创建数组的时候，无法预测数组中存储什么数据，只是先开辟空间，这个时候采用动态初始化
*
*/
public class ArrayTest04 {
public static void main(String[] args) {
//动态声明一个int类型的数组，最多可以存储4个元素
int [] a1=new int[4];
//遍历
for(int i=0;i<a1.length;i++){
System.out.println(a1[i]);
}
//赋值
a1[0]=21;
a1[1]=22;
a1[2]=23;
a1[3]=24;
//遍历
for(int i=0;i<a1.length;i++){
System.out.println(a1[i]);
}
//引用类型的数组
Object[] objs=new Object[3];
objs[0]=1;
for(int index=0;index<objs.length;index++){
Object o=objs[index];
System.out.println(o);
}
}
}

3.深入一维数组

import javax.management.InstanceAlreadyExistsException;

/*
* 深入一维数组
*/
public class ArrayTest05 {

public static void main(String[] args) {
//创建一个数组，也可以存储dog，也可以存储cat
Animal[] animals=new Animal[4];
//给数组每个元素赋值
Dog dog1=new Dog();
Dog dog2=new Dog();
Cat cat1=new Cat();
Cat cat2=new Cat();

animals[0]=dog1;
animals[1]=dog2;
animals[2]=cat1;
animals[3]=cat2;

//需求：遍历数组，取出每个对象，如果是cat执行move。如果是dog，执行eat
for(int i=0;i<animals.length;i++){
System.out.println(animals[i]);
//强制类型转换，向下转型
if(animals[i] instanceof Cat){
Cat cat=(Cat)animals[i];
cat.move();
}
if(animals[i] instanceof Dog){
Dog dog=(Dog)animals[i];
dog.eat();
}
}
}

}
class Animal{

}
class Dog extends Animal{
public void eat(){
System.out.println("Dog eat");
}
}
class Cat extends Animal{
public void move() {
System.out.println("Cat move");
}
}

4.main 方法的 String[] args

（1）方法传递数组方式

/*
* 方法调用的时候，也可以这样传递一个数组
*/
public class ArrayTest06 {
public static void main(String[] args) {
//第一种方式
int[] a={1,2,3,4,5,6};
m1(a);
//第二种方式
m1(new int[]{111,2,3,4,5,6});
}
public static void m1(int[] a){
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
}

（2）String[] args

String[] args是专门用来接收命令行参数的

例如 java ArrayTest07 abc def aaa

JVM在调用ArrayTest07类的main方法前，先将“abc def aaa”以空格的方式分割，然后存储在string数组中。

main方法中String[] args的设计主要是用来接收命令行参数的

/*
* 方法调用的时候，也可以这样传递一个数组
*/
public class ArrayTest06 {
public static void main(String[] args) {
System.out.println("String类型数组中元素的个数是："+args.length);//0
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}
//需求，运行该软件的时候必须提供用户名和密码
//格式：java ArrayTest07 username password
if(args.length!=2){
System.out.println("若使用该系统，必须这样输入：格式：java ArrayTest07 username password");
return;
}
//参数提供正确，如果用户名是admin,密码是123
if("admin".equals(args[0])&&"123".equals(args[1])){//这种方式可以避免空指针异常
System.out.println("登录成功");
}
else{
System.out.println("登录失败");
}
}
}

5.数组的拷贝和扩容

package com.array;
import javax.crypto.spec.DESedeKeySpec;
public class ArrayStudy01 {
public static void main(String[] args) {
//参数分别为源数组，源数组开始下标,目标数组，目标数组下标，长度
//System.arraycopy(src, srcPos, dest, destPos, length);
int [] src= {2,3,4,5,6,7,8};
int [] dest= {10,11,12,13,14,15,16};
//拷贝
System.arraycopy(src, 2, dest, 3, 3);
//遍历
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);//输出结果：10 11 12 4 5 6 16
}
}
}

二、二维数组

（1）二维数组是一个特殊的一维数组

（2）特殊的一维数组，特殊在这个一维数组中每一个元素都是“一维数组”

二维数组静态初始化：

package com.array;

public class ArrayStudy02 {
public static void main(String[] args) {
//静态初始化二维数组
int[][]a = {
{1,2,3},
{45,34},
{0},
{10,23,85,99}
};
//以上这个数组有多少个一维数组
System.out.println(a.length+"个一维数组");
//获取第一个一维数组
int[] a0=a[0];
int a00=a0[0];
System.out.println(a00);//1
//获取第一个一维数组中的第一个元素
System.out.println(a[0][0]);//1
//获
a2b7
取最后一个一维数组中最后一个元素
System.out.println(a[a.length-1][a[a.length-1].length-1]);
//遍历二维数组
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();
}
}
}
输出结果：
1 2 3
45 34
0
10 23 85 99

二维数组动态初始化：

package com.array;

public class ArrayStudy03 {

public static void main(String[] args) {
//3个一维数组
//每个一维数组中有4个元素
//动态初始化二维数组
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();
}
//赋值
a[1][2]=100;

}

}

package com.array;

public class ArrayStudy04 {

public static void main(String[] args) {
m1(new int[][] {{1,2,3},{4,5},{6,7,8,9}});

}
public static void m1(int[][]a) {
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();
}
}
}
//输出结果
1 2 3
4 5
6 7 8 9