Java入门基础(二)——数组

166 阅读3分钟

一起养成写作习惯!这是我参与「掘金日新计划 · 4 月更文挑战」的第12天,点击查看活动详情

Java 数组

定义
要使用java语言的数组,一般经过三个步骤:声明数组 ,创建空间,建数组元素并赋值。

int[] x; //声明数组
x = new int[10]; //创建空间 
int[] x=new int[10]; //合并写法

声明数组变量

首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法:
dataType[] arrayRefVar; // 首选的方法

dataType arrayRefVar[]; // 效果相同,但不是首选方法
注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ,在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

double[] myList; // 首选的方法 
或
double myList[]; // 效果相同,但不是首选方法

一维数组按照如下方式定义:

数据类型 [] 数组名 = new 数据类型[length];

数据类型 [] 数组名 = {数据,…};

二维数组按照如下方式定义:

数据类型 [][] 数组名 = new 数据类型[row][column];

数据类型 [][] 数组名 = {undefined{数据,…},…};

创建数组

Java语言使用new操作符来创建数组,语法如下:

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事:

使用 dataType[arraySize] 创建了一个数组。
把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明,和创建数组可以用一条语句完成,如下所示:

dataType[] arrayRefVar = new dataType[arraySize];  

//静态初始化:创建+赋值
int[] a = {1,2,3,4,5}; int[0] a =1;

另外,你还可以使用如下的方式创建数组。

dataType[] arrayRefVar = {value0, value1, …, valuek}; 
//动态初始化:包含默认初始化,数组也是引用类型,其元素相当于类的实例变量,因此数组一经分配空间
//其中每个元素也按照实例变量同样的方式被隐式初始化
int[] b = new int[10]; b[0] = 10; //b[0] = 10,此时没有被初始化的b[1]...b[9]都将默认赋值为0

数组的元素是通过索引访问的。数组索引从 0 开始,所以索引值从 0 到 arrayRefVar.length-1。

实例:
下面的语句首先声明了一个数组变量 myList,接着创建了一个包含 10 个 double 类型元素的数组,并且把它的引用赋值给 myList 变量。

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为: " + total);
   }
}

以上实例输出结果为:
总和为: 11367.373
利用循环对数组元素进行赋值:

int i;
int[] a; //声明数组
a=new int[5];  //分配空间
for(i=1;i<5;i++){  //循环对数组元素进行赋值
	a[i] = i;
}
for(i=0;i<a.length;i++){  //循环输出数组
	System.out.print("a["+i+"]="+a[i]+"\t");
}

//输出结果
//a[0]=0 a[1]=1	a[2]=2 a[3]=3 a[4]=4

处理数组

数组的元素类型和数组的大小都是确定的,所以当处理数组元素时候,我们通常使用基本循环或者 For-Each 循环。
示例
该实例完整地展示了如何创建、初始化和操纵数组:

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

以上实例编译运行结果如下:

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

反转数组:使用自定义的 reverse 方法将数组进行反转

static void reverse(int a[],int n){
		int[] b = new int[n];
		int j = n;
		for(int i=0;i<n;i++){
			b[j-1]=a[i];
			j=j-1;
		}
		for(int k=0;k<n;k++){
			System.out.println(b[k]);
		}
	}
	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5};
		reverse(arr,arr.length); 
	}

For-Each 循环

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

for(type element: array)
{
    System.out.println(element);
}

实例 该实例用来显示数组 myList 中的所有元素:

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

多维数组

多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组,例如:
String str[][] = new String[3][4];
多维数组的动态初始化(以二维数组为例)

声明方式

int[][] a;  //声明整型数组a  
a = new int[3][4];  //分配一块内存空间,供3行4列的整型数组a使用  
//合并写法  
int[][] a = new int[3][4];  

初始赋值

int[][] a = {
	{1,2,3,4,5,6},
	{6,5,4,3,2,1},
	{1,3,5,2,4,6}
};

Arrays类

数组的工具类 **java.util.Arrays ** 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是"不能"")
具有以下常用功能:
给数组赋值: 通过fill方法。
对数组排序: 通过sort方法,按升序。
比较数组: 通过equals方法比较数组中元素值是否相等。
查找数组元素: 通过binarySearch方法能对排序好的数组进行二分查找法操作

import java.util.Arrays;
	int[] a = {1,3,4,5,2};
	//Arrays.toString(a)打印数组元素
	Arrays.sort(a);//排序
	System.out.println(Arrays.toString(a));	//[1, 2, 3, 4, 5]
	Arrays.fill(a,2,4,0);//在第二个和第四个元素之间使用0来填充(左闭右开)
	System.out.println(Arrays.toString(a));	//[1, 2, 0, 0, 5]

冒泡排序


public static void main(String[] args) {
		int[] array = {1,4,6,3,2,6,3,2,3};
		int[] sort = sort(array);
		System.out.println(Arrays.toString(sort));
	}
	public static int[] sort(int[] array){
	//临时变量
	int temp = 0;
		for(int i=0;i<array.length-1;i++){
			boolean flag = false; //减少无意义的比较,降低复杂度
			for(int j=0;j<array.length-1-i;j++){
				if(array[j]>array[j+1]){
					temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
					flag = true;
				}
			}
			if(flag==false){
				break;
			}
		}
		return array;