java 数组

数组：
一维数组的创建
什么数组：

1. 数组是用来存储一组相同类型数据的数据结构。
2. 数组变量属于引用数据类型。
3. 数组是有固定长度的。
4. 数组中的元素可以是任何数据类型(基本类型和引用类型)。
5. 数组有一个对应的索引，可以通过索引访问数组中的每个元素。（0 –-- n-1）
6. 数组被创建好之后，它的大小（数组长度）是不能改变的，但是数组中的各个元素是可以被改变的。

1 数组的声明
 

 public class Test1 {
    
    	public static void main(String[] args) {
          	//数据类型[]  数组变量名;(java推荐用法)
    		int[] scores;
          	//数据类型 	数组变量名[ ]; 
    		int ages[];
          
          
    	}
    
    }

2 数组的创建

Java中使用关键字new 创建数组对象，指定数组的大小，给数组元素的存储分配空间

格式：数组变量名 = new 数组元素的类型 [数组元素的个数];

  public class Test1 {
    
    	public static void main(String[] args) {
    		int[] scores;
    		//数组变量名 = new 数组元素的类型 [数组元素的个数];
    		scores = new int[5];
    		
    	}
    
    }

3 数组的赋值

3.1 默认值

数组创建之后，如果没有对数组进行初始化，则系统使用默认值对数据进行默认初始化。

1. 数字类型的默认值是0;
2. Boolean值的默认值是false;
3. 引用数据类型的默认值是null;

3.2 静态赋值

所谓的静态初始化是指，在创建数组对象的同时对数组进行初始化。

静态初始化有两种方式：

1、 int[] a = new int[]{1, 2, 3};  //定义并创建数组，并初始化数组的元素为 1、3、3


//同时数组的长度也被限定为为3。

2、 int[] a = {1, 2, 3};   //效果同上

以上两种方式均不需要定义数组的长度，数组的长度由初始化时元素的个数来决定

 public class Test1 {
    
    	public static void main(String[] args) {
          	int[] scores = new int[] { 99 ,  65 , 78 , 89 , 100};
          	//效果同上
    		//int[] scores = { 99 ,  65 , 78 , 89 , 100};
    	}
    }

3.3 动态赋值

所谓动态初始化是指把数组的创建和数组的初始化分开完成。

例如：

int[] a = new int[3];  
a[0] = 3;  //通过元素索引(下标)来给数组元素赋值
a[1]=4;
a[2]=5;

 

public class Test1 {
    
    	public static void main(String[] args) {
    		int[] scores;
    		
    		scores = new int[5];
    		
    		scores[0] = 88;//通过元素索引(下标从0开始)来给数组元素赋值
    		
    		scores[4] = 99;
    	}
    }

数组的访问

 1.通过下标访问指定元素

任何类型的数组，为了便于访问，系统为数组中的每个元素分配了一个下标(索引),可以通过下标来访问到该数组中的每个元素。

假设一个长度为n的数组，则数组的元素下标范围为从 0 — n-1。即：第一个元素的下标为0, 第二个元素的下标为1, …  ,第n个元素的下标为n – 1。所以访问数组时，时刻注意数组的最后一个元素的下标总是比数组的长度小1，否则会出现下标越界。

例如：

int[] a = {20, 30, 2, 50, 5, 66};  //定义一个int类型的数组，并初始化


	System.out.println(a[0]);     //获得第1个元素值，并输出该值


       	System.out.println(a[3]);    //获得第 4个元素的值, 并输出改制

2 循环访问

利用循环可以遍历数组中的每个元素。 
   

 public class Test1 {
    
    	public static void main(String[] args) {
    		int[] scores= {3,4,5,6,7,12,43};
    		
    		int len = scores.length;//获得数组的长度
    		
    		for (int i = 0; i < scores.length; i++) {
    			System.out.println(scores[i]);
    		}
    	}
    
    }

3 增强for循环

该循环方式是java Jdk1.5新加的特性。该种方式的最大特点是只能遍历访问数组中的元素的值，而不能修改数组中元素的值。

使用语法：

for(数组中元素类型 变量名 :  数组名){

  //写访问元素的代码。其中的“变量名”就代表了数组中的每个元素。

  //这种循环方式总是从数组的中的第一个元素开始遍历，直至最后一个元素。

}
    

public class Test1 {
    
    	public static void main(String[] args) {
    		int[] scores= {3,4,5,6,7,12,43};
    		
    		for (int i : scores) {
    			System.out.println(i);
    		}
    	}
    
    }

4 Arrays工具类


操作数组的工具类：可以完成排序、查找、格式化等功能


- 数组转字符串
      int[] scores = { 3, 4, 7, 12, 43, 5,10, 6,1 };
      
      String s = Arrays.toString(scores);//数组转字符串表达
      System.out.println(s);
      
      //将输出：[3, 4, 7, 12, 43, 5, 10, 6, 1]
- 排序
      int[] scores = { 3, 4, 7, 12, 43, 5,10, 6,1 };
      
      Arrays.sort(scores);//对scores数组升序排列
      
      System.out.println(Arrays.toString(scores));
      
      //将输出：[1, 3, 4, 5, 6, 7, 10, 12, 43]
- 查找（先排序）
      int[] scores = { 3, 4, 7, 12, 43, 5,10, 6,1 };
      
      int binarySearch = Arrays.binarySearch(scores, 12);//在数组中找 12 这个值，并返回找到的下标位置，如果不存在，则返回 负数
      
      System.out.println(binarySearch);
      
      //将输出：3
- 格式化
      int[] scores = { 3, 4, 7, 12, 43, 5,10, 6,1 };
      
      Arrays.fill(scores, 5);//将数组的所有值 替换成  5
      
      System.out.println(Arrays.toString(scores));
      //将输出：[5, 5, 5, 5, 5, 5, 5, 5, 5]


以上测试均为 int[] ；其他类型数组，数据类型不同，用法一致。

注：boolean[] 不能排序

二维数组的创建

1 数组的声明


    int[][] a;//定义一个int二维数组


2 数组的创建


    int[][] a;//定义一个int二维数组
    a = new int[3][4];//为 二维数组 a 分配一个 3行4列的连续空间大小


3 数组的赋值

3.1静态赋值

    int[][] a={{2,3,4},{5,6},{7,8,9,10}};//边声明，边赋值
    //int[][] a=new int[][]{{2,3,4},{5,6},{7,8,9,1}};  //效果与上面语法等同

注：

- 每个{}代表一列。多个 {} 代表多列。
- 静态赋值的时候，每一列的个数可以不一样。


3.2 动态赋值
 

   int[][] a = new int[3][4];
    a[1][2] = 24；//第1列，第2行的位置。赋值为 24
    
    //通过两层循环 动态赋值；
    for (int i = 0; i < 3; i++) {
    	for (int j = 0; j < 4; j++) {
    		a[i][j] = 5;
    	}
    }

4 二数组的访问

4.1通过下标访问指定元素

 int[][] a=new int[3][4];
    		
    System.out.println(a[1][2]);//访问1列，2行的数据

4.2循环访问数组

  int[][] a=new int[3][4];
    for (int i = 0; i < a.length; i++) {
    	int b[] = a[i];//访问每一列 数组
    	for (int j = 0; j < b.length; j++) {
    		System.out.print(b[j]);//访问当前列 指定下标的数据
    	}
    	System.out.println();//换行
    }

4.3 增强for循环

  int[][] a=new int[3][4];
    for (int[] b : a) {
    	for (int i : b) {
    		System.out.print(i);
    	}
    	System.out.println();
    }

示例代码：

packagemain;

import java.util.Arrays;
import java.util.Random;

public class Test {
	// 随机输出10个整数，编写一个程序，进行排序，升序或者降序
	public static void main(String[] args) {
		Random random = new Random();
		int rand;
		// int rand =random.nextInt(10);
		int[] arrays = new int[5];
		int temp = 0;
		// 随机生成10个值 存放在数组中
		System.out.println("原始数据：");
		for (int i = 0; i < arrays.length; i++) {
			rand = random.nextInt(10);
			arrays[i] = rand;
			System.out.print(arrays[i] + " ");
		}

		System.out.println();
		System.out.println("---------开始排序------------");
		// 开始排序
		for (int i = 0; i < arrays.length - 1; i++) {
			for (int j = i + 1; j < arrays.length; j++) {
				if (arrays[i] > arrays[j]) {
					temp = arrays[i];
					arrays[i] = arrays[j];// 互换位置
					arrays[j] = temp;
				}
			}
			System.out.println("第" + (i + 1) + "次排序");
			for (int a = 0; a < arrays.length; a++) {
				System.out.print(arrays[a] + " ");
			}
			System.out.println();
		}
		// 输出结果
		System.out.println();
		System.out.println("------------升序---------");
		for (int i = 0; i < arrays.length; i++) {
			System.out.print(arrays[i] + " ");
		}

		System.out.println();
		// 利用工具排序
		System.out.println("------------利用工具排序---------");
		int[] array1 = { 22, 25, 66, 53, 22, 22, 66 };
		Arrays.sort(array1);
		for (int index : array1) {
			System.out.print(index + " ");
		}
		// 查找
		System.out.println();
		System.out.println("------------查找---------");
		int binarySearch = Arrays.binarySearch(array1, 25);
		System.out.print("25 位置：" + binarySearch);
		// 数组转字符串
		System.out.println();
		System.out.println("------------数组转字符串---------");
		String s = Arrays.toString(array1);
		System.out.println(s);

		// 二维数组
		// int[][] twoArrays;//定义一个int二维数组
		// twoArrays=new int[3][4];

		int[][] twoArrays1 = { { 2, 3, 4 }, { 5, 6 }, { 7, 8, 9, 10 } };
		// 打印输出每个元素
		System.out.println();
		System.out.println("-----------打印输出二维数组每个元素-----------");
		for (int i = 0; i < twoArrays1.length; i++) {
			for (int j = 0; j < twoArrays1[i].length; j++) {
				System.out.print(twoArrays1[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println();
		// 心态[4][5] 数组 采用随机数赋值
		int[][] c = new int[4][5];
		for (int i = 0; i < c.length; i++) {
			for (int j = 0; j < c[i].length; j++) {
				rand = random.nextInt(10);
				c[i][j] = rand;
			}
		}
		System.out.println();
		System.out.println("-----------增强for遍历二维数组每个元素-----------");
		for (int[] d : c) {
			for (int i : d) {
				System.out.print(i + " ");
			}
			System.out.println();
		}
		System.out.println();
		System.out.println("-----------普通for遍历二维数组每个元素-----------");
		for (int i = 0; i < c.length; i++) {
			for (int j = 0; j < c[i].length; j++) {
				System.out.print(c[i][j] + " ");
			}
			System.out.println();
		}
	}
}