3 java se(3)----数组

一 数组的定义和操作

1 定义：int[] a;  （只是声明数组变量，并没有定义；声明时不能指定）

        int[] a = new int[10];（int[] a = new int[];是错误的，定义必须声明长度或直接初始化）  

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

2 数组和集合类：数组是长度不可变的集合类

3 java中的数组内存分配在堆中，而且都有默认的初始值

4 数组的拷贝

（1）一个一个元素的拷贝 T（n）= O(n);

（2）由于数组是内存中连续的一块，直接把整个内存拷贝。

用java.lang.System.arrayCopy((Object src, int srcPos,Object dest,int destPos,int length)

例如： int[] a = {1,2,3,4,5,6,7,8};

       int[] b = new int[8];

       System.arrayCopy(a,1,b,1,lenght);

 (源数组，源数组起始位置，目标数组，目标数组起始位置，要复制几个数)

 

二 多维数组

1 多维数组理解为：数组的数组；用集合的想法思考多维数组，数据都存在最后的那个花括号里，前面的都是花括号没有数据；所以从最后层开始构建集合

                 例如：a[2][3][2] { { {1,2} {2,3}{3,5} } { {1,2} {99,111} } }

2 int[][] a = new int[2][10];

 a.lenght是2   a[1]的长度是10

三 String StringBuffer StringBuilder(转载)

1 String  StringBuffer  StringBuilder

(1)String               不可变字符序列
StringBuffer          线程安全的可变字符序列
StringBuilder         非线程安全的可变字符序列 

(2) 为什么String不可变而StringBuffer和StingBuilder可变  看下面部分源码

Char value[]是用来存储字符的，注意String的类型是final；而StringBuffer中的value[]就是一个很普通的数组，而且可以通过append()方法将新字符串加入value[]末尾。这样也就改变了value[]的内容和大小了。 

1. public final class String  

2. {  

3.         private final char value[];  

4.   

5.          public String(String original) {  

6.               // 把原字符串original切分成字符数组并赋给value[];  

7.          }  

8. }  

9.   

10. //StringBuffer   

11. public final class StringBuffer extends AbstractStringBuilder  

12. {  

13.          char value[]; //继承了父类AbstractStringBuilder中的value[]  

14.          public StringBuffer(String str) {  

15.                  super(str.length() + 16); //继承父类的构造器，并创建一个大小为str.length()+16的value[]数组  

16.                  append(str); //将str切分成字符序列并加入到value[]中  

17.         }  

18. }  

（3）StringBuffer与StringBuilder线程安全

 StringBuffer和StringBuilder可以算是双胞胎了，这两者的方法没有很大区别。但在线程安全性方面，StringBuffer允许多线程进行字符操作。这是因为在源代码中StringBuffer的很多方法都被关键字synchronized 修饰了，而StringBuilder没有。
      有多线程编程经验的程序员应该知道synchronized。这个关键字是为线程同步机制 设定的。我简要阐述一下synchronized的含义：
      每一个类对象都对应一把锁，当某个线程A调用类对象O中的synchronized方法M时，必须获得对象O的锁才能够执行M方法，否则线程A阻塞。一旦线程A开始执行M方法，将独占对象O的锁。使得其它需要调用O对象的M方法的线程阻塞。只有线程A执行完毕，释放锁后。那些阻塞线程才有机会重新调用M方法。这就是解决线程同步问题的锁机制。 
      了解了synchronized的含义以后，大家可能都会有这个感觉。多线程编程中StringBuffer比StringBuilder要安全多了 ，事实确实如此。如果有多个线程需要对同一个字符串缓冲区进行操作的时候，StringBuffer应该是不二选择。
      注意：是不是String也不安全呢？事实上不存在这个问题，String是不可变的。线程对于堆中指定的一个String对象只能读取，无法修改。试问：还有什么不安全的呢？