因为数组是在内存中连续的一段存储空间，所以数组一旦被创建，空间就固定了，长度是不能扩增的。
数组的长度是固定的，如果需要扩充**，必须创建新数组，原数组的长度要复制到新数组中 。**
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<a.length;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<a.length;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<str.length();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 class 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 {
public 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<ch5.length;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
}
}
