java基础八（数组一）

Java 数组一：一维数组

存储同一种数据类型的多个元素的集合，这里指的是定长数组。

《一》声明数组变量

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

        dataType[] arrayVar;  例如：double[] arr;   String[] str;

《二》创建数组

数组通过new关键字在堆内存开辟一段内存，并在栈内存开辟引用对象指向堆内存。例如：

int[] arr= new int[10];

该过程包含两步：

一、使用 new int[10] 在堆内存开辟存储10个整型元素空间。

二、栈内存开辟引用变量arr指向堆内存空间。

《三》数组的初始化
A: int[] arr = new int[3];
    之后通过逐个赋值方式进行元素初始化；例如：arr[0] = 10; arr[1] = 20; arr[2] = 30;
B: 静态初始化; 创建时候赋初值，注：不能指定长度

例如：int[] arr = {10, 20 ,30};    

《四》数组基本操作

    数组常见操作分为两类，一类是需要自己实现的操作，比如数组元素遍历；另一类是Arrays提供的静态方法：

    常见操作一：

public class Test1
{
	public static void initArray(double[] str)//初始化
	{
		for (int i = 0; i < str.length; i++)
		{
			str[i] = Math.random() * 100;//调用Math类random()方法产生随机数
		}
	}
	public static void showArray(double[] str)//数组打印，形参传递类型为数组
	{
		//System.out.println("----------数组遍历一 ---------");
		for (int i = 0; i < str.length; i++)
		{
			System.out.printf("%3.1f ",str[i]);
		}
		/*System.out.println("\n----------数组遍历二 ---------");
		for (double s : str)
		{
			System.out.printf("%3.1f ",s);
		}*/
	}
	
	public static double[] reverseArray(double[] str)//java允许返回值为数组类型
	{
		double tmp;
		for (int i = 0; i < str.length/2; i++)
		{
			tmp = str[i];
			str[i] = str[str.length-1-i];
			str[str.length-1-i] = tmp;
		}
		return str;
	}
	
	public static double[] sortArray(double[] str)//数组排序
	{
		//选择排序：
		double tmp;
		for (int i = 0; i < str.length - 1; i++)
		{
			int k = i;
			for (int j = i+1; j < str.length ; j++)
			{
				if(str[j] < str[k])
					k = j;
			}
			if(k != i)
			{
				tmp = str[k];
				str[k] = str[i];
				str[i] = tmp;
			}
		}
		return str;
	}

	public static void main(String[] args)
	{
		//数组的基本操作：注明，这里为方便期间，写的都是静态方法，静态方法属于类可以直接调用；
		double[] array = new double[10];
		initArray(array);
		System.out.println("----------------------数组遍历---------------------");
		showArray(array);
		
		System.out.println("\n----------------------数组排序---------------------");
		showArray(sortArray(array));
		
		System.out.println("\n----------------------数组逆序---------------------");
		showArray(reverseArray(array));
        }
}

 常见操作二：Arrays类也为我们提供了如下静态方法：

import java.util.Arrays;
import java.util.Scanner;

public class Test2
{
	public static <E> void showArray(E[] arr)//使用泛型
	{
		for(E t : arr)//增强for循环遍历
		{
			System.out.print(t + " ");
		}
	}
	
	public static void main(String[] args)
	{
		/*
		 * Arrays类的常用方法
		 */
		System.out.println("---------下面测试Arrays.fill()---------");
		Character[] arr = new Character[10];//Character[] arr = new Character[10];//注意为了使用泛型，这里只能使用Character类创建对象
		Arrays.fill(arr, 'c');//使用Arrays类的静态方法fill()填充初值
		showArray(arr);	//打印数组
		
		System.out.println("\n\n---------下面测试Arrays.sort()---------");
		Integer[] str = new Integer[10];
		for (int i = 0; i < str.length; i++)//动态初始化
		{
			str[i] = (int)(Math.random()*10000 ) % 100;
		}
		
		System.out.print("str数组排序前:");
		showArray(str);
		
		Arrays.sort(str);//使用Arrays类的静态方法sort()排序
		
		System.out.print("\nstr数组排序后:");
		showArray(str);
		
		System.out.println("\n\n---------下面测试Arrays.binarySearch()---------");
		System.out.print("请输入待查找数字：");
		Scanner scanner = new Scanner(System.in);
		int t = scanner.nextInt();
		System.out.println(t + "在数组str中的位置为：" + Arrays.binarySearch(str, t));
		
		System.out.println("\n---------下面测试Arrays.equals()---------");
		Integer[] str1 = str; 
		System.out.println("str1 与 str 数组equals吗？  " + Arrays.equals(str1, str));
		
	}

}

总结Arrays 类：java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。查找成功，返回搜索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(int[] str1, int[] str2) 比较数组：通过 equals 方法比较数组中元素值是否相等。如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 给数组赋值：通过 fill 方法。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对数组排序：通过 sort 方法,按升序。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

还有其他关于数组操作如：

数组作为函数的参数；数组作为函数的返回值

思考：

1：int[] ss = new int[10]  与 Integer[] ss = new Integer[10] 区别；

2：int a = 10;    int b = a;    b = 20;    最后a=10; b=20; //a的值没变化，b的值改变

     int[5] s1 = {1,2,3,4,5};    s2 = s1;    s2[0] = 10；最后 s1= {10,2,3,4,5}; s2= {10,2,3,4,5};   //数组a,b值均改变

import java.util.Arrays;

public class Test3
{
	public static void main(String[] args)
	{
		int a = 10;
		int b = a;
		System.out.println("改变前：");
		System.out.println("a : " + a);
		System.out.println("b : " + b);
		b = 20;
		System.out.println("改变后：");
		System.out.println("a : " + a);
		System.out.println("b : " + b);

		int[] s1 = {1,2,3,4,5};
		int[] s2 = s1;
		System.out.println("改变前：" );
		System.out.println( "数组s1:"+ Arrays.toString(s1));
		System.out.println( "数组s2:"+ Arrays.toString(s2));
		s2[0] = 10;
		System.out.println("改变后：" );
		System.out.println( "数组s1:"+ Arrays.toString(s1));
		System.out.println( "数组s2:"+ Arrays.toString(s2));
	}

}

3：空指针异常与数组越界：

public class Test4
{
	public static void main(String[] args)
	{
		int[] ss = {1,2,3};
		try
		{
			System.out.println(ss[3]);
		} catch (Exception e)
		{
			System.out.println("数组越界");
		}
		ss = null;//将ss数组指向空
		System.out.println("*************");
		try
		{
			System.out.println(ss[1]); 		//
		} catch (Exception e)
		{
			System.out.println("空指针错误");
		}
		
	}
}