java的数组知识

1.定义数组

格式：type[ ] arrayname(type arrayname[]),建议使用第一种，符合语法习惯，type[ ]是一种类型。

数组是一种引用类型的变量，因此使用他定义的一个变量时，仅仅表示定义了一个引用变量（也就是定义了一个指针），这个引用变量还未指向任何有效的内存，因此定义的时候不能指定数组的长度，并且在没有初始化之前也是不能用的。

2.数组的初始化

(1)静态初始化：初始化时由程序员显示的指定每个数组元素的初始值，由系统决定数组的长度。

格式 arrayname = new type[ ]{element1,element2,element3...}; (前提有定义)   

or type[ ] arrayname = {element1,element2,element3...};

由于java语言很好的继承性，数组的类型和元素的类型可以使一样也可以是父子关系。例如：

int[] intArray;
intArray=new int[]{5,6,7,8};
Object[] objArr;
objArr=new String[]{"hello","fine"};//数组类型时定义的数组的子类
Object[] objArr1;
obj1Arr=new Object[]{"java"};//元素类型时数组类型的子类

(2)动态初始化，初始化时只能指定数组长度，由系统为数组元素分配初始值。

格式  arrayname = new type[length];

执行动态初始化时，程序员只需要指定数组的长度，系统自动赋予初始值，有如下的规则：

(1)数组元素的类型是基本类型中的整型类型（byte，short,  int  和 long），则元素为0。

(2)数组元素的类型是基本类型中的浮点类型（float, double），则元素为0.0。

(3)数组元素的类型是基本类型中的字符类型（char），则元素为‘\u0000’。

(4)数组元素的类型是基本类型中的布尔类型（boolean），则元素为‘false。

(3)数组元素的类型是引用类型（类，接口和数组），则元素为null

注意：不要同时使用静态初始化和动态初始化，即不要既指明长度又为每个元素赋初始值。

(3)foreach循环

一般遍历一个数组要获取他的属性length的值，但是foreach循环会自动遍历数组的每一个元素。

格式 for(type variableName:array)

         {

          //variableName自动迭代访问每个元素，不要对该变量赋值

         }

public class test{
	public static void main()(String [] args){
       		String [] book={"ab","cd","ef"};
           	for(String book:books)
               System.out.println(book);
		}
}

3.深入了解数组

(1)内存中的数组

  实际的数组对象被存储在堆(heap)内存中，如果引用该数组对象的数组引用变量是一个局部变量，那么它被存储在栈（stack）内存中。数组在内存中的存储示意图如下：

  如果堆内存中数组不再有任何引用变量指向自己，则这个数组将成为垃圾，该数组所占用的内存空间将会被系统的垃圾回收机制回收。

  只要类型相互兼容，就可以让一个数组变量指向另一个实际的数组，这会让人产生数组的长度可变的错觉。如下代码：

public class arrayTest{
	public static void main(){
	  int [] a= {5,7,20};
	  int [] b= new int[4];
	  System.out.println("b数组的长度为:"+b.length);
          for(int num:a)
             System.out.println(num);
          for(int i=0;i<b.length;i++)
             System.out.println(b[i]);
          b=a;
          System.out.println("b数组的长度"+b.length);
	}
}

执行b=a后

(2)引用类型的初始化

先定义一个Person 类

class Person{
	public int age;
	public double height;
	public void info(){
		System.out.println("我的年龄是"+age+",我的身高是："+height);
		}
}

public class ArrayTest{
	public static void main(String[] args) {
		Person[] students;
		students=new Person[2];
		Person zhang=new Person();
		zhang.age=15;
		zhang.height=158;
		Person cheng=new Person();
		zhang.age=16;
		zhang.height=161;
		students[0]=zhang;
		students[1]=cheng;
		cheng.info();
		students[1].info();
	}
}

第一步：执行 Person[ ] students，此时仅仅在栈内存中定义了一个引用变量，也是一个指针，该指针没有指向任何内存区。

第二步：动态初始化：students=new Person[2],每个元素的值为null（引用类型的默认值）。

第三步：students数组的两个数组元素都是引用，这个引用没有指向人格有效的内存，这意味着依然不能使用students数组。接下来定义两个变量zhang和cheng。

第四步：依次把zhang和cheng赋值给students数组的两个元素，他们属于同意内存区，注意内存中加引号是代表的这个person对象。

4.Array类

java提供的Array类里包含了一些static修饰的方法可以直接操作数组（可以直接通过类名调用）：

(1)int binarySearch(type[ ] a,type key):二分法查找要求已经升序排列，没有找到则返回负数。

(2)int binarySearch(type[ ] a,int fromIndex,int toIndex,type key):和第一个类似规定了范围查找。

(3)type[ ] copyOf(type[ ] original,int length):把original数组复制到一个新的数组，length是新数组的长度，如果length小于原数组长度就截取length长度的元素，大于的话在后面补充0（数值类型），false（布尔类型）和null（引用类型）。

(4)type[ ] copyOfRange(type[ ] original,int from,int to)：加范围复制。

(5)boolean equals(type[ ] a,type[ ] a2):如果长度相等且元素一致返回true。

(6)void fill(type[ ] a,type val):把数组a中的所有元素赋值val。

(7)void fill(type[ ] a,int fromIndex,int toIndex,type val ):加了范围.

(8)void sort(type[ ] a)：从小到大排序。

(9)void sort(type[ ] a,int fromIndex,int toIndex).

(10)String toString(type[ ] a)：将数组转换为字符串。

//在这里补充一下：

java为8中基本类型提供了对应的包装类：boolean对应Boolean，byte对应Byte，short对应Short，int对应Integer，long对应Long，char对应Character，float对应Float，double对应Double，可以通过调用函数parseXxx来把字符串类型转换成基本类型。

String a=“45”;
int val=integer.parseInt(a);//val=45