java数组的三种扩容方式以及程序实现详解

java数组的三种扩容方式以及程序实现详解

因为数组是在内存中连续的一段存储空间，所以数组一旦被创建，空间就固定了，长度是不能扩增的。

数组的长度是固定的，如果需要扩充**，必须创建新数组，原数组的长度要复制到新数组中 。**

java中，数组类型的变量传值的时候，事实上传递的是数组的地址 。

Java数组扩容的原理

1）Java数组对象的大小是固定不变的，数组对象是不可扩容的。

2）利用数组复制方法可以变通的实现数组扩容。

3）System.arraycopy()可以复制数组。

4）Arrays.copyOf()可以简便的创建数组副本。

5）创建数组副本的同时将数组长度增加就变通的实现了数组的扩容。

数组扩容的三种方式：

新建一个数组，把原来数组的内容搬到 新数组中。

用系统定义函数system.arraycopy实现扩容；

用系统定义函数copyof函数实现扩容；

下面用程序来实现这三种扩容

class expand2{

//利用函数的方法进行数组的扩充

public static void main(String[] args) {

//定义一个小型的数组

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

//调用扩容函数

//a=expand2(a);

//a=expand3(a);

a=expand4(a);

//测试是否扩容完成，输出此时数组a中的值

for (int i=0;i

System.out.println("aaaa:"+a[i]);

}

}

//扩容函数，

public static int[] expand2(int a[]){

//定义一个新数组b，并为其赋值长度为数组a的二倍

int b[] = new int[a.length*2];

//将数组a的元素循环遍历到数组b中

for (int i=0;i

b[i] = a[i];

}

//返回扩容后的数组b

return b;

}

//数组扩容方法3，利用系统函数arraycopy进行扩容

public static int[] expand3(int a[]){

int[] b = new int[a.length*2];

//系统函数进行扩容，将a[]的值赋值到b[]中，共a.length个长度。

//相当于第19-21行

System.arraycopy(a,0,b,0,a.length);

return b;

}

//数组扩容方法4，利用系统函数copy进行扩容

public static int[] expand4(int a[]){

//可以查看api文档，java.util.Arrays.copyOf的详细使用；

return java.util.Arrays.copyOf(a,a.length*2);

}

}

实现案例：

案例1 : 统计一个字符在字符串中的所有位置.

字符串: 统计一个字符在字符串中的所有位置

字符: '字'

返回: {4,7}

public class CountCharDemo {

public static void main(String[] args) {

char key = '字';

String str = "统计一个字符在字符串中的所有位置";

int[] count=count(str,key);

System.out.println(Arrays.toString(count));//[4, 7]

}

public static int[] count(String str,char key){

int[] count={};

for(int i=0;i

char c=str.charAt(i);

if(c==key){

//扩展数组

count=Arrays.copyOf(count, count.length+1);

//添加序号i

count[count.length-1]=i;

}

}

return count;

}

}

char[]、String、StringBuilder

char[]:字符序列, 只有字符数据, 没有操作, 如果算法优秀, 性能最好。

String: char[] + 方法(操作, API功能)

StringBuilder: char[] + 方法(操作char[] 的内容)

String：内部包含内容不可变的char[]，表现为String对象不可变。String包含操作(API方法)，是对char[]操作，但不改变原对象经常返回新的对象，很多String API提供了复杂的性能优化算法，如：静态字符串池。

StringBuilder：内部也是一个char[]，但是这个数组内容是可变的，并且自动维护扩容算法，因为数据内容可变，所以叫：可变字符串。StringBuilder API方法，是动态维护char[]内容，都可以改变char[]内容。

public abstract clhttp://ass AbstractStringBuilder {

/** The value is used for character storage.*/

char value[];

/** The count is the number of characters used.*/

int count;

/** Returns the length (character count).*/

public int length() {

return count;

}

public AbstractStringBuilder append(String str) {

if (str == null)

str = "null";

int len = str.length();

if (len == 0)

return this;

int newCount = count + len;

if (newCount > value.length)

expandCapacity(newCount);

str.getChars(0, len, value, count);

count = newCount;

return this;

}

/**

* 自动实现Java数组扩容

*/

void expandCapacity(int minimumCapacity) {

int newCapacity = (value.length + 1) * 2;

if (newCapacity < 0) {

newCapacity = Integer.MAX_VALUE;

} else if (minimumCapacity > newCapacity) {

newCapacity = minimumCapacity;

}

value = Arrays.copyOf(value, newCapacity);

}

}

字符串数组与String类的原理

/** 字符串数组与String类的原理 */

public class CharArrayDemo {

publVVoZvQBFmic static void main(String[] args) {

/* Java 可以将char[]作为字符串处理 */

char[] ch1={'中','国','北','京'};

char[] ch2={'欢','迎','您'};

System.out.println(ch1);//中国北京

System.out.println(ch2);//欢迎您

/* char[]运算需要编程处理,如连接: */

char[] ch3=Arrays.copyOf(ch1, ch1.length+ch2.length);

System.arraycopy(ch2, 0, ch3, ch1.length, ch2.length);

System.out.println(ch3);//中国北京欢迎您

/* String API提供了简洁的连接运算: */

String str1="中国北京";

String str2="欢迎您";

String str3=str1.concat(str2);

System.out.println(str3);//中国北京欢迎您

/* 字符串转大写: */

char[] ch4={'A','a','c','f'};

char[] ch5=Arrays.copyOf(ch4, ch4.length);

for(int i=0;i

char c=ch5[i];

if(c>='a' && c<='z'){

ch5[i]=(char)(c+('A'-'a'));

}

}

System.out.println(ch5);//AACF, 原数组ch4不变

String str4="Aacf";

String str5=str4.toUpperCase();//原字符串str4保持不变

System.out.println(str5);//AACF

}

}

System.out.println("aaaa:"+a[i]);

}

}

//扩容函数，

public static int[] expand2(int a[]){

//定义一个新数组b，并为其赋值长度为数组a的二倍

int b[] = new int[a.length*2];

//将数组a的元素循环遍历到数组b中

for (int i=0;i

b[i] = a[i];

}

//返回扩容后的数组b

return b;

}

//数组扩容方法3，利用系统函数arraycopy进行扩容

public static int[] expand3(int a[]){

int[] b = new int[a.length*2];

//系统函数进行扩容，将a[]的值赋值到b[]中，共a.length个长度。

//相当于第19-21行

System.arraycopy(a,0,b,0,a.length);

return b;

}

//数组扩容方法4，利用系统函数copy进行扩容

public static int[] expand4(int a[]){

//可以查看api文档，java.util.Arrays.copyOf的详细使用；

return java.util.Arrays.copyOf(a,a.length*2);

}

}

实现案例：

案例1 : 统计一个字符在字符串中的所有位置.

字符串: 统计一个字符在字符串中的所有位置

字符: '字'

返回: {4,7}

public class CountCharDemo {

public static void main(String[] args) {

char key = '字';

String str = "统计一个字符在字符串中的所有位置";

int[] count=count(str,key);

System.out.println(Arrays.toString(count));//[4, 7]

}

public static int[] count(String str,char key){

int[] count={};

for(int i=0;i

char c=str.charAt(i);

if(c==key){

//扩展数组

count=Arrays.copyOf(count, count.length+1);

//添加序号i

count[count.length-1]=i;

}

}

return count;

}

}

char[]、String、StringBuilder

char[]:字符序列, 只有字符数据, 没有操作, 如果算法优秀, 性能最好。

String: char[] + 方法(操作, API功能)

StringBuilder: char[] + 方法(操作char[] 的内容)

String：内部包含内容不可变的char[]，表现为String对象不可变。String包含操作(API方法)，是对char[]操作，但不改变原对象经常返回新的对象，很多String API提供了复杂的性能优化算法，如：静态字符串池。

StringBuilder：内部也是一个char[]，但是这个数组内容是可变的，并且自动维护扩容算法，因为数据内容可变，所以叫：可变字符串。StringBuilder API方法，是动态维护char[]内容，都可以改变char[]内容。

public abstract clhttp://ass AbstractStringBuilder {

/** The value is used for character storage.*/

char value[];

/** The count is the number of characters used.*/

int count;

/** Returns the length (character count).*/

public int length() {

return count;

}

public AbstractStringBuilder append(String str) {

if (str == null)

str = "null";

int len = str.length();

if (len == 0)

return this;

int newCount = count + len;

if (newCount > value.length)

expandCapacity(newCount);

str.getChars(0, len, value, count);

count = newCount;

return this;

}

/**

* 自动实现Java数组扩容

*/

void expandCapacity(int minimumCapacity) {

int newCapacity = (value.length + 1) * 2;

if (newCapacity < 0) {

newCapacity = Integer.MAX_VALUE;

} else if (minimumCapacity > newCapacity) {

newCapacity = minimumCapacity;

}

value = Arrays.copyOf(value, newCapacity);

}

}

字符串数组与String类的原理

/** 字符串数组与String类的原理 */

public class CharArrayDemo {

publVVoZvQBFmic static void main(String[] args) {

/* Java 可以将char[]作为字符串处理 */

char[] ch1={'中','国','北','京'};

char[] ch2={'欢','迎','您'};

System.out.println(ch1);//中国北京

System.out.println(ch2);//欢迎您

/* char[]运算需要编程处理,如连接: */

char[] ch3=Arrays.copyOf(ch1, ch1.length+ch2.length);

System.arraycopy(ch2, 0, ch3, ch1.length, ch2.length);

System.out.println(ch3);//中国北京欢迎您

/* String API提供了简洁的连接运算: */

String str1="中国北京";

String str2="欢迎您";

String str3=str1.concat(str2);

System.out.println(str3);//中国北京欢迎您

/* 字符串转大写: */

char[] ch4={'A','a','c','f'};

char[] ch5=Arrays.copyOf(ch4, ch4.length);

for(int i=0;i

char c=ch5[i];

if(c>='a' && c<='z'){

ch5[i]=(char)(c+('A'-'a'));

}

}

System.out.println(ch5);//AACF, 原数组ch4不变

String str4="Aacf";

String str5=str4.toUpperCase();//原字符串str4保持不变

System.out.println(str5);//AACF

}

}

b[i] = a[i];

}

//返回扩容后的数组b

return b;

}

//数组扩容方法3，利用系统函数arraycopy进行扩容

public static int[] expand3(int a[]){

int[] b = new int[a.length*2];

//系统函数进行扩容，将a[]的值赋值到b[]中，共a.length个长度。

//相当于第19-21行

System.arraycopy(a,0,b,0,a.length);

return b;

}

//数组扩容方法4，利用系统函数copy进行扩容

public static int[] expand4(int a[]){

//可以查看api文档，java.util.Arrays.copyOf的详细使用；

return java.util.Arrays.copyOf(a,a.length*2);

}

}

实现案例：

案例1 : 统计一个字符在字符串中的所有位置.

字符串: 统计一个字符在字符串中的所有位置

字符: '字'

返回: {4,7}

public class CountCharDemo {

public static void main(String[] args) {

char key = '字';

String str = "统计一个字符在字符串中的所有位置";

int[] count=count(str,key);

System.out.println(Arrays.toString(count));//[4, 7]

}

public static int[] count(String str,char key){

int[] count={};

for(int i=0;i

char c=str.charAt(i);

if(c==key){

//扩展数组

count=Arrays.copyOf(count, count.length+1);

//添加序号i

count[count.length-1]=i;

}

}

return count;

}

}

char[]、String、StringBuilder

char[]:字符序列, 只有字符数据, 没有操作, 如果算法优秀, 性能最好。

String: char[] + 方法(操作, API功能)

StringBuilder: char[] + 方法(操作char[] 的内容)

String：内部包含内容不可变的char[]，表现为String对象不可变。String包含操作(API方法)，是对char[]操作，但不改变原对象经常返回新的对象，很多String API提供了复杂的性能优化算法，如：静态字符串池。

StringBuilder：内部也是一个char[]，但是这个数组内容是可变的，并且自动维护扩容算法，因为数据内容可变，所以叫：可变字符串。StringBuilder API方法，是动态维护char[]内容，都可以改变char[]内容。

public abstract clhttp://ass AbstractStringBuilder {

/** The value is used for character storage.*/

char value[];

/** The count is the number of characters used.*/

int count;

/** Returns the length (character count).*/

public int length() {

return count;

}

public AbstractStringBuilder append(String str) {

if (str == null)

str = "null";

int len = str.length();

if (len == 0)

return this;

int newCount = count + len;

if (newCount > value.length)

expandCapacity(newCount);

str.getChars(0, len, value, count);

count = newCount;

return this;

}

/**

* 自动实现Java数组扩容

*/

void expandCapacity(int minimumCapacity) {

int newCapacity = (value.length + 1) * 2;

if (newCapacity < 0) {

newCapacity = Integer.MAX_VALUE;

} else if (minimumCapacity > newCapacity) {

newCapacity = minimumCapacity;

}

value = Arrays.copyOf(value, newCapacity);

}

}

字符串数组与String类的原理

/** 字符串数组与String类的原理 */

public class CharArrayDemo {

publVVoZvQBFmic static void main(String[] args) {

/* Java 可以将char[]作为字符串处理 */

char[] ch1={'中','国','北','京'};

char[] ch2={'欢','迎','您'};

System.out.println(ch1);//中国北京

System.out.println(ch2);//欢迎您

/* char[]运算需要编程处理,如连接: */

char[] ch3=Arrays.copyOf(ch1, ch1.length+ch2.length);

System.arraycopy(ch2, 0, ch3, ch1.length, ch2.length);

System.out.println(ch3);//中国北京欢迎您

/* String API提供了简洁的连接运算: */

String str1="中国北京";

String str2="欢迎您";

String str3=str1.concat(str2);

System.out.println(str3);//中国北京欢迎您

/* 字符串转大写: */

char[] ch4={'A','a','c','f'};

char[] ch5=Arrays.copyOf(ch4, ch4.length);

for(int i=0;i

char c=ch5[i];

if(c>='a' && c<='z'){

ch5[i]=(char)(c+('A'-'a'));

}

}

System.out.println(ch5);//AACF, 原数组ch4不变

String str4="Aacf";

String str5=str4.toUpperCase();//原字符串str4保持不变

System.out.println(str5);//AACF

}

}

char c=str.charAt(i);

if(c==key){

//扩展数组

count=Arrays.copyOf(count, count.length+1);

//添加序号i

count[count.length-1]=i;

}

}

return count;

}

}

char[]、String、StringBuilder

char[]:字符序列, 只有字符数据, 没有操作, 如果算法优秀, 性能最好。

String: char[] + 方法(操作, API功能)

StringBuilder: char[] + 方法(操作char[] 的内容)

String：内部包含内容不可变的char[]，表现为String对象不可变。String包含操作(API方法)，是对char[]操作，但不改变原对象经常返回新的对象，很多String API提供了复杂的性能优化算法，如：静态字符串池。

StringBuilder：内部也是一个char[]，但是这个数组内容是可变的，并且自动维护扩容算法，因为数据内容可变，所以叫：可变字符串。StringBuilder API方法，是动态维护char[]内容，都可以改变char[]内容。

public abstract clhttp://ass AbstractStringBuilder {

/** The value is used for character storage.*/

char value[];

/** The count is the number of characters used.*/

int count;

/** Returns the length (character count).*/

public int length() {

return count;

}

public AbstractStringBuilder append(String str) {

if (str == null)

str = "null";

int len = str.length();

if (len == 0)

return this;

int newCount = count + len;

if (newCount > value.length)

expandCapacity(newCount);

str.getChars(0, len, value, count);

count = newCount;

return this;

}

/**

* 自动实现Java数组扩容

*/

void expandCapacity(int minimumCapacity) {

int newCapacity = (value.length + 1) * 2;

if (newCapacity < 0) {

newCapacity = Integer.MAX_VALUE;

} else if (minimumCapacity > newCapacity) {

newCapacity = minimumCapacity;

}

value = Arrays.copyOf(value, newCapacity);

}

}

字符串数组与String类的原理

/** 字符串数组与String类的原理 */

public class CharArrayDemo {

publVVoZvQBFmic static void main(String[] args) {

/* Java 可以将char[]作为字符串处理 */

char[] ch1={'中','国','北','京'};

char[] ch2={'欢','迎','您'};

System.out.println(ch1);//中国北京

System.out.println(ch2);//欢迎您

/* char[]运算需要编程处理,如连接: */

char[] ch3=Arrays.copyOf(ch1, ch1.length+ch2.length);

System.arraycopy(ch2, 0, ch3, ch1.length, ch2.length);

System.out.println(ch3);//中国北京欢迎您

/* String API提供了简洁的连接运算: */

String str1="中国北京";

String str2="欢迎您";

String str3=str1.concat(str2);

System.out.println(str3);//中国北京欢迎您

/* 字符串转大写: */

char[] ch4={'A','a','c','f'};

char[] ch5=Arrays.copyOf(ch4, ch4.length);

for(int i=0;i

char c=ch5[i];

if(c>='a' && c<='z'){

ch5[i]=(char)(c+('A'-'a'));

}

}

System.out.println(ch5);//AACF, 原数组ch4不变

String str4="Aacf";

String str5=str4.toUpperCase();//原字符串str4保持不变

System.out.println(str5);//AACF

}

}

char c=ch5[i];

if(c>='a' && c<='z'){

ch5[i]=(char)(c+('A'-'a'));

}

}

System.out.println(ch5);//AACF, 原数组ch4不变

String str4="Aacf";

String str5=str4.toUpperCase();//原字符串str4保持不变

System.out.println(str5);//AACF

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。