02 数组及使用

1 数组的概述

数组(Array), 是多个相同类型数据按一定顺序排列的集合, 并使用一个名字命名, 并通过编号的方式对这些数据进行统一管理。

  • 数组本身是引用数据类型, 而数组中的元素可以是任何数据类型, 包括基本数据类型和引用数据类型。
  • 创建数组对象会在内存中开辟一整块连续的空间, 而数组名中引用的是这块连续空间的首地址。
  • 数组的长度一旦确定, 就不能修改
  • 我们可以直接通过下标(或索引)的方式调用指定位置的元素, 速度很快。
  • 数组的分类:

    按照维度:一维数组、 二维数组、 三维数组、 …
    按照元素的数据类型分:基本数据类型元素的数组、 引用数据类型元素的数组(即对象数组)

2 一维数组的使用

2.1 一维数组的声明方式:

type[] vartype var[]
例如:
int a[];
int[] a1;
double b[];
String c[];//引用类型变量数组
Java语言中声明数组时不能指定其长度

2.2 一维数组的使用:初始化

  • 动态初始化:数组声明且为数组元素分配空间与赋值的操作分开进行
    栗子1:

      int[] arr = new int[];
      arr[0] = 2;
      arr[1] = 4;
      arr[2] = 6;
    

    栗子2:

      	String[] names;
      	names = new String[3];
      	names[0] = "张三";
      	names[1] = "李四";
      	names[2] = "王五";
    
  • 静态初始化:在定义数组的同时就为数组元素分配空间并赋值。

      int arr[] = new int[]{3,9,4};		//int arr[] = {3,9,4};
      String[] names = {"张三","李四","王五"};
    

2.3 一维数组的使用:数组元素的引用

  • 定义并用运算符new为之分配空间后,才可以引用数组中的每个元素;
  • 数组元素的引用方式:数组名[数组元素下标]

    数组元素下标可以是整型常量或整型表达式。
    数组元素下标从0开始;长度为n的数组合法下标取值范围: 0 --> n-1;

  • 每个数组都有一个属性length指明它的长度(数组一旦初始化,其长度是不可变的)
  • 数组是引用类型,它的元素相当于类的成员变量,因此数组一经分配空间,其中的每个元素也被按照成员变量同样的方式被隐式初始化。

    对于基本数据类型而言,默认初始化值各有不同
    对于引用数据类型而言,默认初始化值为null

2.4 一维数组的使用:数组元素的默认初始化值

数组元素类型元素默认初始值
byte0
short0
int0
long0L
float0.0F
double0.0
char0或’\u0000’
booleanfalse
引用类型null

3 多维数组的使用

格式1(动态初始化)int[][] arr = new int[3][2];

定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是: arr[0][1] = 78;

格式2(动态初始化) : int[][] arr = new int[3][];

二维数组中有3个一维数组。
每个一维数组都是默认初始化值null (注意:区别于格式1)
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];

格式3(静态初始化) :int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组,二维数组中有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式: arr[2].length;

注意特殊写法情况: int[] x,y[]; x是一维数组, y是二维数组。

4 数组中涉及到的常见算法

4.1. 数组元素的赋值(杨辉三角、回形数等)

  1. 回形数

    回形数格式方阵的实现
    从键盘输入一个整数(1~20)
    则以该数字为矩阵的大小,把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如: 输入数字2,则程序输出:
    1 2
    4 3
    输入数字3,则程序输出:
    1 2 3
    8 9 4
    7 6 5
    输入数字4, 则程序输出:
    1 2 3 4
    12 13 14 5
    11 16 15 6
    10 9 8 7

     import java.util.Scanner;
     
     public class Test2 {
     /**
      * @Description: 回形数格式方阵的实现方式一
      */
     	public static void method1() {
     		Scanner scanner = new Scanner(System.in);
     		System.out.print("方法一:请输入一个整数(1-20):");
     		int len = scanner.nextInt();
     		int[][] arr = new int[len][len];//创建二维数组用于保存数字
     		int i = 0 , j = 0;//用于控制二维数组的两个下标
     		int sum = len * len;
     		int turn = 1;//turn=1 右,turn=2 下,turn=3 左,turn=4 上 
     		for(int show = 1; show <= sum; show++) {
     			if(turn == 1) {
     				if(j < len && arr[i][j] == 0) {
     					arr[i][j++] = show;
     				}else {
     					turn = 2;
     					i++;
     					j--;
     					show--;
     				}
     			}else if(turn == 2) {
     				if(i < len && arr[i][j] == 0) {
     					arr[i++][j]  = show;
     				}else {
     					turn = 3;
     					i--;
     					j--;
     					show--;
     				}
     			}else if(turn == 3) {
     				if(j >= 0 && arr[i][j] == 0) {
     					arr[i][j--] = show;
     				}else {
     					turn = 4;
     					i--;
     					j++;
     					show--;
     				}
     			}else if(turn == 4) {
     				if(i>= 0 && arr[i][j] == 0) {
     					arr[i--][j] = show;
     				}else {
     					turn = 1;
     					i++;
     					j++;
     					show--;
     				}
     			}
     			
     		}
     		for(int m = 0; m < arr.length; m++) {
     			for(int n = 0; n < arr[m].length; n++) {
     				System.out.print(arr[m][n]+"\t");
     			}
     			System.out.println();
     		}
     	}
     	
     	/**
     	 * @Description: 回形数格式方阵的实现方式二
     	 */
     	public static void method2() {
     		System.out.print("方法二:请输入一个整数(1-20):");
     		Scanner scanner = new Scanner(System.in);
     		int len = scanner.nextInt();
     		int count = len * len;//显示的总数字
     		
     		int[][] arr = new int[len][len];//用于保存数据的二维数组
     		int minX = 0;//x轴的最小值
     		int maxX = len-1;//x轴的最大值
     		int minY = 0; //y轴的最小值
     		int maxY = len-1;//y轴的最大值
     		
     		for(int show = 1; show <= count; ) {
     			for(int x = minX; x <= maxX; x++) {
     				arr[minY][x] = show++;
     			}
     			minY++;
     			for(int y = minY; y <= maxY; y++) {
     				arr[y][maxX] = show++;
     			}
     			maxX--;
     			for(int x = maxX; x >= minX; x--) {
     				arr[maxY][x] = show++;
     			}
     			maxY--;
     			for(int y = maxY; y >= minY; y--) {
     				arr[y][minX] = show++;
     			}
     			minX++;
     		}
     		for(int m = 0; m < arr.length; m++) {
     			for(int n = 0; n < arr[m].length; n++) {
     				System.out.print(arr[m][n] + "\t");
     			}
     			System.out.println();
     		}
     	}
     	/**
     	 * 调用主方法,使用方法一或者方法二
     	 * @param args
     	 */
     	public static void main(String[] args) {
     		method1();
     		method2();
     	}
     }
    

4.2. 求数值型数组中元素的最大值、最小值、平均数、总和等

public class ArraySum {

	public static void main(String[] args) {
		int[] data = new int[] {-12,123,1231,-112,23,-23, 23,222 ,232};
		int min = data[0];
		int max = data[0];
		int sum = data[0];
		for(int i = 1; i < data.length; i++) {
			sum += data[i];
			if(data[i] < min ) {
				min = data[i];
			}
			if(data[i] > max) {
				max = data[i];
			}
		}
		System.out.println("总和为:" + sum);
		System.out.println("平均值为:" + sum/data.length);
		System.out.println("最大值为:" + max);
		System.out.println("最小值为:" + min);
	}
	
}

4.3. 数组的复制、反转、查找(线性查找、二分法查找)

  1. 复制

     public class CopyArray {
     
     	public static void main(String[] args) {
     		int[] a = new int[] {1,2,3,4,5,6,7,8,9,10};
     		int[] b = new int[10];
     		for(int i = 0; i < a.length; i++) {
     			b[i] = a[i];
     		}
     		for(int i = 0; i < b.length; i++) {
     			System.out.print(b[i] + "  ");
     		}
     	}
     	
     }
    
  2. 反转

     /**
      * 一维数组a[],用java代码将数组元素顺序颠倒
      *
      */
     public class Test4 {
     
     	public static void main(String[] args) {
     		int[] a = new int[] {(int)(Math.random()*1000),
     				(int)(Math.random()*1000),(int)(Math.random()*1000),
     				(int)(Math.random()*1000),(int)(Math.random()*1000),
     				(int)(Math.random()*1000),(int)(Math.random()*1000)};
     		for(int i = 0; i < a.length; i++) {
     			System.out.print(a[i] + " ");
     		}
     		System.out.println();
     		for(int i = 0; i < a.length/2; i++) {
     			int temp;
     			temp = a[i];
     			a[i] = a[a.length-1-i];
     			a[a.length-1-i] = temp;
     		}
     		for(int i = 0; i < a.length; i++) {
     			System.out.print(a[i] + " ");
     		}
     	}
     	
     }
    
  3. 查找

     public class SearchArray {
     
     	public static void main(String[] args){
     		int[] data = new int[] {2,3,4,6,23,34,54,65,454,3453,2342};
     		int key = 23;
     		int low = 0;
     		int high = data.length-1;
     		int mid;
     		boolean isflag = false;
     		while(low <= high) {
     			mid = (low + high)/2;
     			if(data[mid] == key) {
     				System.out.println("找到了'" + key + "',在第" + (mid +1) + "个");
     				isflag = true;
     				break;
     			}else if(data[mid] < key) {
     				low = mid + 1;
     			}else {
     				high = mid - 1;
     			}
     		}
     		if(!isflag) {
     			System.out.println("没找到!");
     		}
     	}
     
     }
    

4.4. 数组元素的排序算法

  1. 冒泡排序

     public class BubbleSort {
     
     	public static void sort1(int[] data) {
     		for(int i = data.length-1; i > 0; i--) {
     			for(int j = 0; j < i; j++) {
     				if(data[i] < data[j]) {
     					int temp = data[i];
     					data[i] = data[j];
     					data[j] = temp;
     				}
     			}
     		}
     	}
     	
     	public static void main(String[] args) {
     		int[] data = new int[]  { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
     		System.out.println("排序前:\n" + java.util.Arrays.toString(data));
     		sort1(data);
     		System.out.println("排序后:\n" + java.util.Arrays.toString(data));
     	}
     }
    
  2. 快速排序

  3. 堆排序

  4. 归并排序

5 Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类, 包含了用来操作数组(比如排序和搜索) 的各种方法。

boolea equals(int[] a, int[] b)判断两个数组是否相等
String toString(int[] a)输出数组的信息
void fill(int[] a, int val)将指定值填充到数组中
void sort(int[] a)
int binarySearch(int[] a, int key)对排序后的数组进行二分法检索指定的值

6 数组使用中的常见异常

  • 数组脚标越界异常(ArrayIndexOutOfBoundsException)

    int[] arr = new int[2];
    System.out.println(arr[2]);
    System.out.println(arr[-1]);
    访问到了数组中的不存在的脚标时发生。

  • 空指针异常(NullPointerException)

    int[] arr = null;
    System.out.println(arr[0]);
    arr引用没有指向实体,却在操作实体中的元素时。

----------------------------------------------华丽分割线---------------------------------------------------------
系统复习java第一弹,本文资源来源于尚硅谷公开课程:尚硅谷_Java零基础教程-java入门必备-初学者从入门到精通全套完整版(宋红康主讲)

©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页