java 字符串数组拷贝函数_java之数组

一、基础概念

1、数组是一种引用类型

2、数组是一种检点的数据结构，线性结构

3、数组是一个容器，可以用来存储其他元素，数组是可以存储任意数据类型的元素。

4、数组分为：一维数组，二维数组，三维数组、多维数组

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

随机的对数组增删元素，当增加的元素的时候，为了保证数组中的元素，在空间存储上是有序的，所以被添加元素位置后面的所有元素都要向后移动。

删除元素要向前移动，所以数组增删元素效率较低

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

举栗子：

class Test {

public void main(String[] args) {

// 声明一个一维数组，用来存储int类型

int[] a1 = {100,200,150,300}; // 静态初始化

// boolean数组

boolean[] b1 = {true,false,true};

//String数组

String[] strs = {"AB","CD","EF"};

// char数组

char[] c = {'a','b','c'};

//Object数组

Object o1 = new Object();

Object o2 = new Object();

Object o3 = new Object();

Object[] objs = {o1,o2,o3};

}

}

存储结构如图：

二、初始化一维数组有两种方法：

1、静态初始化

2、动态初始化：

动态初始化一维数组，会先在堆内存中分配这个数组，并在数组中每个元素都采取默认值

byte,short,int,long 0

boolean false

引用 null

提问：什么时候使用动态初始化和动态初始化

1、无论动态初始化还静态初始化，最终的内存分布一定一样

2、如果在创建数组的时候，知道数组已应该存储什么数据，这个时候用静态初始化

如果无法预测到数组中存储什么数据，那么用动态初始化

举个栗子：

class Test {

public static void main(String[] args) {

// 静态初始化一维数组

System.out.println("静态初始化一维数组");

int[] a1 = {1,2,3};

// 取值

System.out.println(a1[0]);

System.out.println(a1[1]);

System.out.println(a1[2]);

System.out.println("长度：" + a1.length);

// 遍历

for(int i = 0;i < a1.length;i++) {

System.out.print(a1[i] + " ");

}

// 将第二个元素修改

a1[1] = 100;

System.out.println();

System.out.println("----------");

for(int i = 0;i < a1.length;i++) {

System.out.print(a1[i] + " ");

}

// 动态初始化一维数组

/*

1、动态初始化一维数组，会先在堆内存中分配这个数组，并在数组中每个元素都采取默认值

byte,short,int,long 0

float false

char \u0000

引用 null

* */

System.out.println("动态初始化一维数组");

// 动态声明一个int类型的数组，最多可以存储4个元素

int[] a = new int[4];

a[0] = 1;

a[1] = 2;

a[2] = 3;

a[3] = 4;

for(int i = 0;i < a1.length;i++) {

System.out.print(a[i] + " ");

}

// 引用类型的数组

Object[] objs = new Object[3];

for(int index = 0;index < objs.length;index++) {

Object o = objs[index]; // o = null

// System.out.println(o.toString()); // NullPointerException

// 注意空指针异常，因为引用类型的数组类型默认为null

System.out.println(o); // null null null

}

}

}

三、深入一维数组

父类型的一维数组中放子类

举栗子：

class Test {

public static void main(String[] args) {

Animal1[] a = new Animal1[4];

Dog1 d1 = new Dog1();

Dog1 d2 = new Dog1();

Cat1 c1 = new Cat1();

Cat1 c2 = new Cat1();

a[0] = d1;

a[1] = d2;

a[2] = c1;

a[3] = c2;

// 需求：遍历数组，取出每个对象，如果是dog执行eat，是cat对象执行move

for(int i = 0;i < a.length;i++) {

Animal1 a1 = a[i];

if(a1 instanceof Cat1) {

Cat1 c = (Cat1)a1;

c.run();

}else if(a1 instanceof Dog1) {

Dog1 d = (Dog1)a1;

d.eat();

}

}

}

}

class Animal1{

}

class Dog1 extends Animal1{

public void eat() {

System.out.println("dog is eating");

}

}

class Cat1 extends Animal1{

public void run() {

System.out.println("cat is running");

}

}

输出：

dog is eating

dog is eating

cat is running

cat is running

方法调用传递数组的方式

举栗子：

class Test {

public static void main(String[] args) {

// 第一种方式

int[] a = {1,2,3};

m1(a);

System.out.println("-------------");

// 第二种方式

m1(new int[] {1,2,3});

}

public static void m1(int[] a) {

for(int i = 0; i < a.length;i++) {

System.out.println(a[i]);

}

}

}

主函数中的 String[] args的作用：

1、String[] args是专门用来接收指令参数的

2、例如：java ArrayTest07 abc def aaa

JVM在调用ArrayTest07类的main方法之前 ，先将abc def aaa以空格的方式分割后，然后放在String数组中

即，main方法的String[]数组的设计主要是用来接受命令行参数的

class Test {

public static void main(String[] args) {

System.out.println("String类型的数组中的长度"+args.length);

for(int i = 0;i < args.length;i++) {

System.out.println(args[i]);

}

}

}

输出：

String类型的数组中的长度0

关于数组的拷贝(SDK提供的方法)

class Test {

public static void main(String[] args) {

// arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

// arraycopy(源数组, 源数组的开始下标, 目标数组, 目标数组开始下标, 拷贝的长度)

int[] src = {2,3,4,5,6,7,8};

int[] dest = {10,11,12,13,14,15,6};

// 把src中的4,5,6拷贝到dest数组丛13开始

System.arraycopy(src, 2, dest, 3, 3);

// 遍历

for(int i = 0; i < dest.length;i++) {

System.out.println(dest[i]);

}

}

}