Java-数组

Java数组

1. 相同数据类型元素的集合

2. 是一种数据类型(引用类型)

3. 数组的声明:
   int[] arr = new int[10];

4. 数组的初始化:
   int[] arr = new int[4]; //0,0,0,0
   int[] arr = {1,4,7,9}; //1,4,7,9
   int[] arr = new int[]{1,4,7,9}; //1,4,7,9
   int[] arr;
   arr = {1,4,7,9}; //编译错误
   arr = new int[]{1,4,7,9}; //正确

5. 数组的访问:
   5.1) 通过(数组名.length)可以获取数组的长度(数组元素的个数)
   int[] arr = new int[4];
   System.out.println(arr.length); //4

   5.2) 通过下标/索引来访问数组中的元素
   下标从0开始，最大到(arr.length-1)
   int[] arr = new int[3];
   arr[0] = 100; //给arr中的第1个元素赋值为100
   arr[1] = 200; //给arr中的第2个元素赋值为200
   arr[2] = 300; //给arr中的第3个元素赋值为300
   arr[3] = 400; //发生数组下标越界异常
   System.out.println(arr[arr.length-1]); //输出数组中最后一个元素的值

6. 数组的遍历:

   int[] arr = new int[10];
   for(int i=0;i<arr.length;i++){
     arr[i] = 100;
   }
   for(int i=0;i<arr.length;i++){
     System.out.println(arr[i]);
   }
   for(int i=arr.length-1;i>=0;i--){
     System.out.println(arr[i]);
   }
   

   

数组的复制

• System.arraycopy(a,1,a1,0,4);

  int[] a = {10,20,30,40,50};
  int[] a1 = new int[6]; //0,0,0,0,0,0
  //a:源数组
  //1: 源数组的起始下标
  //a1:目标数组
  //0:目标数组的起始下标
  //4:要复制的元素个数
  System.arraycopy(a,1,a1,0,4); //灵活性好，效率高
  for(int i=0;i<a1.length;i++) {
  	System.out.println(a1[i]); //20，30，40，50，0，0
  }
  

• Arrays.copyOf()方法—数组的扩容

  int[] a = {10,20,30,40,50};
  //数组的扩容(创建了一个新的数组并将原数组数据复制过去)
  //多出来的默认为0，如果长度不足则截取；
  a = Arrays.copyOf(a,a.length+1);
  for(int i=0;i<a.length;i++) {
  	System.out.println(a[i]); //10,20,30,40,50  //若长度为2，则10,20
  }
  

   

数组的排序

Arrays.sort(arr);
后面可加参数比较器

示例：求数组元素的最大值，并将最大值放在数组的最后面

package day06;
/*
 * 求随机数组（大小为10）的最大值，并将最大值放在此数组的最后面
 */
import java.util.Arrays;

public class MaxOfArray {
	public static void main(String[] args) {
		// 声明大小为10的随机数组（0-99）
		int[] arr = new int[10];
		for(int i=0;i<arr.length;i++) {
			arr[i] = (int)(Math.random()*100);
			System.out.println(arr[i]);
		}
		// 求数组中最大值,将第一个元素赋值给max,然后依次和后面元素进行比较,将大的赋值给max
		int max = arr[0];
		for(int i=1;i<arr.length;i++) {
			if(arr[i]>max) {
				max = arr[i];
			}
		}
		System.out.println("最大值为："+max);
		
		// 将最大值放在数组的最后面(扩容)
		arr = Arrays.copyOf(arr, arr.length+1);
		arr[arr.length-1] = max;
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}
}

   

引用类型数组

• Airplane[] as = new Airplane[3]; //创建Airplane数组对象
  as[0] = new Airplane(); //创建Airplane对象
  as[1] = new Airplane();
  as[2] = new Airplane();
  as[1].x = 100; //给第2个小敌机的x坐标赋值为100
  for(int i=0;i<as.length;i++){
  as[i].x = 100;
  System.out.println(as[i].width);
  as[i].step();
  }
• Airplane[] as = new Airplane[]{
  new Airplane(),
  new Airplane(),
  new Airplane()
  }

   

For-Each 循环

• JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

• 语法格式如下：
  for(type element: array)
  {
  System.out.println(element);
  }
  示例：

public class TestArray {
   public static void main(String[] args) {
	  double[] myList = {1.9, 2.9, 3.4, 3.5};
 
	  // 打印所有数组元素
	  for (double element: myList) {
	     System.out.println(element);
	  }
   }
}
编译结果如下：
	1.9
	2.9
	3.4
	3.5

   

注意：

char[] ch = {‘x’,‘y’,‘z’};
System.out.println(ch); // xyz