Java中数组的操作（一）

Java中数组的操作（一）

一、说明

1.数组是最常见的一种数据结构，可以用于存储多个数据，每个数组元素存放一个数据，可以通过索引检索数组元素。通过数组名加数组下标，来使用数组中的数据。下标从 0 开始排序。

2.一个数组里只能存在一种数据类型，如果存储对象的话，则该对象必须具有继承关系。

3.Java中的数组可以存储基本数据类型，也可以存储引用数据类型，只要数据元素的类型相同即可，。

4数组是一种引用类型的变量，因此使用数组定义一个变量的时候，仅仅表示定义了一个引用变量。这个引用变量还没有指向任何有效的内存，因此定义数组时不能指定数组的长度，所以还不能使用，必须进行初始化。



5数组的定义

1.type[] arrayName; //推荐这种方式，比较易读

2.type arrayName[];

例如

Int array[];

String strArray[];

Boolean boolArray[];

6.数组的初始化

1.对数组的初始化就是对数组的数组元素分配内存空间，并为每个数组元素赋初始值。

2.初始值的指定可以由系统指定或者由程序员在初始化时自己指定

3.数组的初始化（也称为实例化）有两种方式

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

2.动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值

注意：不要同时使用静态初始化和动态初始化。

动态初始化元素初始值的分配根据具体数据类型决定

1.byte ，short ,intlong 数组元组的值为0；

2.float，double 数组元素的值是0.0；

3.char 数组元素的值是‘\u0000’;

4.boolean 数组元素的值是false；

5.引用类型（类，接口，数组），数组元素的值是null；

二、数组的使用

1.数组最常用的就是访问数组元素，赋值，取值,遍历

2.数组下标一般是从0开始的，

3.如果访问数组元素时指定的索引值小于0，或者大于等于数组的长度，编译不会出错，但是运行时出现异常：数组下标越界，java.long.ArrayIndexOutOfBoundsExceptino: N

4.遍历数组的方式有很多，for循环，增强for循环等，

实例代码1：

package cn.com.basicFive;

/**
 * 
 * @author fcs
 * 2014年9月5日
 * 说明：使用foreach循环迭代数组元素的时候，并不能改变数组元素的值，因此不要对foreach的循环变量进行赋值。
 * 
 */
public class ArraryDemo {
     public static void main(String[] args) {
		int  intArray [] = new int []{2,3,4,5,3}; // 声明并静态初始化
		String strArray [] ;   //声明String类型的数组
		strArray  = new String [] {}; //静态初始化,这种方式没有指定初始值
		String strArray1 [] ;
		strArray1 = new String  []{"asdfkla","asdfawe","asd","we24e","sdw234"};
        System.out.println(strArray1.length);
	    
        boolean boolArray [] = new boolean [20];  //动态初始化，系统自动初始化元素值
        System.out.println(boolArray[0]+"---"+boolArray[2]);
        //数组的遍历
        for(int i = 0 ;i < strArray1.length;i ++){
        	System.out.println(strArray1[i]);
        }
        System.out.println("--------------------------------------");
        //foreach遍历，也叫增强for循环
        for(String str : strArray1){
        	System.out.println(str);
        }        
     }
}

三、深入数组

1.内存中的数组

说明;数组引用变量只是一个引用，引用变量是访问真实对象的根本方式。实际的数组对象被存储在堆内存中，如果引用该数组对象的数组引用变量是个局部变量（在方法中声明），则被存储在栈内存中

2.如果堆内存中的数组不再有任何引用变量指向自己，则这个数组将成为垃圾，该数组所占的内存将会被系统的垃圾回收机制回收。可以将该数组变量赋值为null，也就切断了数组引用变量和实际数组之间的引用关系，实际的数组也就是成了垃圾。

3.定义并初始化一个数组后，在内存中分配了两个空间，一个用于存放数组的引用变量，另一个用于存放数组本身。

4.引用类型数据的数组初始化和使用

实例代码2

package cn.com.basicFive;

public class ArrayDemo2 {
   public static void main(String[] args) {
	   Person [] personArray = new Person[3];
       Person p1 = new Person("张三","南京");
       Person p2 = new Person("李四","北京");
       Person p3 = new Person("王五","东京");
       personArray [0] = p1;;
       personArray[1] = p2;
       personArray[2] = p3;
       
     for(Person p : personArray){
    	 if(p.getName().equals("张三")){
    		 System.out.println(p);
    	 }
     }   
   }   
}
package cn.com.basicFive;

public class Person {
   private String name ;
   private String addr;
   public Person(String name, String addr) {
	this.name = name;
	this.addr = addr;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public String getAddr() {
	return addr;
}
public void setAddr(String addr) {
	this.addr = addr;
}
   
}

2.java中的多维数组

在java中可以声明多维数组，但是在java中的底层机制中，是没有多维数组的，java语言里的数组类型是引用类型，因此，数组变量其实是一个引用，这个引用指向真实的数组内存，数组元素的类型也可以是引用，如果数组元素的引用再次指向真实的数组内存，这种情形看上去很像多维数组，

一般对数组的应用不会超过三维。超过三维比较麻烦，而且程序不易读。

以二维数组为例

定义语法：

Type [][] arrName；

声明：

arrName = new type[length][];

其实质还是一维数组，只是其数组元素也是引用，数组元素里保存的引用指向一维数组。

实例代码三：

package cn.com.basicFive;

public class DoubleArray {
     public static void main(String[] args) {
		int [] [] array;   //定义一个二维数组
		array = new int [4][];  //把array 当成一维数组初始化，长度为4
		array[0] = new int[3];  //对二维数组中的一维数组进行初始化,一定要对所有的一维数组进行初始化
		                        //，指定其长度，否则在循环遍历的时候，会出现空指针
		array[2] = new int [6]; 
		array[1] = new int [2];
		array[3] =  new int [2];
		array[2][1] =100;
		for(int i =0;i< 4;i++){
			for(int j = 0;j<array[i].length;j++){
				System.out.print(array[i][j]+" ");
			}
			System.out.println();
		}
		String strArray [][] = new String  [2][3]; //这样就不会出现上面的问题了
		strArray[1][2] = "sdwewew2r2";
		for(int i  =0 ;i<strArray.length;i++){
			for(int j =0;j< strArray[i].length;j++){
				System.out.println(strArray[i][j]);
			}
		}
	}
}

四、操作数组的工具

Java中提供Arrays类进行直接操作数组。包含下面的方法

1.int binarySearch(type [] a, type key):使用二分查找key元素值在数组中出现的索引，若果a数组不包含key元素值，则返回负数，调用该方法时，要求数组a按升序排列

2.Int binarySearch(type [] a,int fromIndex,int toIndex,type key),与1几乎一样，搜索 fromIndex ----->toIndex范围的数据

3.Type [] copyOf(type []original ,int newLength):将origianl数组复制成一个新数组。长度根据newLength，与原来数组的长度决定。

4.Type [] copyOfRange(type [] original,int from,int to)

复制从from ----> to的元素。

5.boolean equals (type a[] ,type a2 [])c:a和a2的长度和数组元素全部相同返回true，否则返回false

6.Void Fill(type [] a,typeval):把a数组的所有元素都赋值为val

7.Void fill(type [] a,int fromIndex ,int toIndex ,type val):赋值从 fromIndex ----- > toIndex的元素。

8.Void sort(type a[]):该方法对a数组的数组元素进行排序。

9.Void sort(type [] a ,int fromIndex,int toIndex):对指定范围的数据进行排序。

实例代码5：

package cn.com.basicFive;

import java.util.Arrays;
import java.util.List;

public class ArrayTest {
     public static void main(String[] args) {
		int arr [] = new int []{2,352,15,62,56,2,53,2,42};
	    Arrays.sort(arr);   //对数组进行排序
	    for (int i = 0; i < arr.length; i++) {
			int j = arr[i];
			System.out.print(j+"  ");
		}
	    System.out.println("-------------------------------");
	    int a = Arrays.binarySearch(arr, 2);      //二分查找
	    System.out.println(a);
	    int b = Arrays.binarySearch(arr, 23);     //返回值为负数不确定  
	    System.out.println(b);
	    int [] newArr  = Arrays.copyOf(arr, 3);  //复制三个元素到新数组中
		System.out.println(newArr.length);  
		int  [] newArr2 = Arrays.copyOf(arr, 102); //当要复制的元素超过原来数组的长度，后，原来数组的值复制到新数组中
		System.out.println(newArr2.length);  
		List<int[]> list = Arrays.asList(arr);   //将数组用list包装
		for (int[] is : list) {
			for(int i =0;i<is.length;i++){
				System.out.print(is[i]+"  ");
			}
		}
		System.out.println("---------------------------------");
		List<String> strList = Arrays.asList("adsa","asdwe","sdw");   //将列表元素转换为list
		for (String string : strList) {
			System.out.print(string+"  ");
		}
		System.out.println("---------------------------------");
		Arrays.fill(newArr2,242409240);   //将newArr2全部值设置为242409240
		for (int i = 0; i < newArr2.length; i++) {
			System.out.println( newArr2[i]);	
		}
	 
        String newStr =  Arrays.toString(newArr); //将int类型的数组转换为String
        System.out.println(newStr);
     }
10.}