java 1.8数组_java数组

1 数组

1.1 创建一维数组

一维数组实质上是一组相同类型数据的线性集合，当在程序中需要处理一组数据或者传递一组数据时，可以用这种类型的数组。

数组作为对象允许使用new关键字进行内存分配。在使用数组之前必须定义数组所属的类型。

声明一维数组有两种方式：

数组元素类型 数组名字[ ];

数组元素类型[ ] 数组名字

创建数组的方式为：

数组元素类型 数组名字[ ]=new 数组元素类型[数组元素的个数]；

注意：

如果声明了数组元素的个数，那就固定了数组的长度；

数组的下标是从0开始的，数组范围为0~length-1，后面尤其要注意数组越界异常的报错；

使用new关键字为数组分配内存时，整个数组中各个元素都有自己的初始值。

基本变量：byte,short,int,long初始化为0；

boolean初始化为false；float,double初始化为0.0；

char初始化为 空字符，相当于‘/u0000’；

引用类型初始化为null(空指针)；

public classDemo {//遍历数组

public static voidmain(String[] args) {boolean[] arr = new boolean [5]; //声明数组

for(int i=0;i<5;i++) { //遍历数组

System.out.println(arr[i]); //通过索引打印数组

}

}

}

输出为五个false。其他数据类型可以同样操作。

数组赋值还可以直接使用索引,如arr[0]=1,arr[1]=2

1.2 初始化一维数组

数组的初始化可以分别初始化数组中的每个元素。

数组的初始化有以下两种形式：

int arr1[]=new int[1,2,3,4,5];                       //第一种形式

int arr2[]={1,2,3,4,5};                                  //第二种形式

1.3 数组中常见的两个异常

(1)数组的索引越界异常(ArrayIndexOutofBoundsException)

(2)空指针异常(.所谓的空指针，就是指针的内容为空，如果数组对象赋值null,就是空指针。所谓的空指针异常，就是一个指针是空指针，你还要去操作它，既然它指向的是空对象，它就不能使用这个对象的方法)。

1.4 二维数组的创建和初始化

二维数组常用于表，表中的信息以行和列的形式组织，第一个下标代表元素所在的行，第二个下标代表元素所在的列。

(1)声明二维数组

数组元素的类型 数组名字[][];

数组元素的类型 [][] 数组名字；

二维数组在声明的时候并没有分配内存空间，要使用new关键字来分配内存，然后才可以访问每个元素。

声明格式(例如)：

int a [][]=new int[2][4]

表明创建了二维数组a，a包括2个长度为4的一维数组。

(2)二维数组的初始化(静态初始化和动态初始化)

①静态初始化

是在数组声明时，对声明的数组元素赋初值的过程。

语法：

数组数据类型 数组名[][]={value1,value2,value3...valuen};

例如：int array[][] = {{3,-9,6},{8,0,1},{11,9,8}};

声明并初始化array，它有三个元素，每个元素又都是三个元素的一维数组。外层大括号对里面的元素是行数组的元素，因为型数组元素是一维数组，因此每个型数组元素也用大括号对包括起来，里面的元素是列数组的元素。

另外，用指定初值的方式对数组进行初始化时，列数组元素的个数可以不同。

例如：

int array[][] = {{3,6},{8,0,1},{11,9,8}};

此时，第一个列数组的元素个数是2，第二个和第三个列数组的元素个数是3个。

② 动态初始化

动态初始化同一维数组相同，也是先声明数组，然后通过new运算符分配内存。语法格式为：

类型说明符 数组名[][] = new 类型说明符[数组长度][];

或：

类型说明符 数组名[][] = new 类型说明符[数组长度][ 数组长度];

使用数组的最基本操作是数组元素的访问，对数组的使用最终都通过对元素的使用而实现。数组的元素通过数组下标进行访问。在Java语言中，数组下标是从0开始的，所以包含n个元素的数组下标的范围是0到n-1。

例如：前面定义的数组a，其下标范围为0到4。要访问a数组的元素，可通过a[0]、a[1]、a[2]、a[3]、a[4]访问a数组的各个元素，此时，方括号中的数字是数组的下标，表示访问数组的第几个元素。

1.5 二维数组的使用

二维数组的元素通过两个下标进行访问，分别是行数组下标和列数组下标，例如：对于二维数组a，可通过a[i][j]进行访问，其中i和j为数组a的下标。

二维数组行数组的长度可通过a.length获取，列数组的长度可通过a[i]. length获取。

遍历二维数组：public classDemo5 {public static voidmain(String[] args) {//TODO Auto-generated method stub

int a[][]= {{1},{2,3},{4,5,6},{7,8,9,10}};for(int i=0;i

System.out.print(a[i][j]);

}

System.out.println();

}

}

}

1.6 二维数组的存储结构

1.7 填充替换数组元素

数组完成定义后，可以通过Arrays类的静态方法fill()来对数组中的元素进行替换。fill方法有两种参数类型。

(1)填充元素 fill(int[]a,int value)

该方法可以将指定的int值分配给int型数组的每个元素。

public classDemo7 {public static voidmain(String[] args) {//TODO Auto-generated method stub

int arr[]=new int[5];

Arrays.fill(arr,6);for(int i=0;i

System.out.println("第"+i+"个元素是："+arr[i]);

}

}

}

(2)替换元素 fill(int[] a.int fromIndex,int toIndex,int value)

a:要进行填充的数组

fromIndex：要使用指定值填充的第一个元素的索引(包括)

toIndex：要使用指定值填充的最后一个元素的索引(不包括)

value：要储存在数组所有元素的值。

public classDemo7 {public static voidmain(String[] args) {//TODO Auto-generated method stub

int arr[]=new int[]{1,2,3,4};

Arrays.fill(arr,0,2,6);for(int i=0;i

System.out.println("第"+(i+1)+"个元素是："+arr[i]);

}

}

}

1.8 数组排序

通过Arrays类的静态sort()方法可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。

public classDemo8 {public static voidmain(String[] args) {int []a= {3,1,5,7,2};

Arrays.sort(a);

System.out.print("[");for(int i=0;i

System.out.print(a[i]+"]");

}else{System.out.print(a[i]+",");

}

}

}

}

结果：[1,2,3,5,7]

1.9 复制数组

Arrys类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定长度复制到一个新数组中。

(1)copyOf()方法

语法：copyOf(arr，newlength)

arr：要进行复制的数组

newlength：复制后新数组的长度，如果长度大于arr的长度，则用0补充；如果小于arr的长度，则从arr数组的第一个元素取起。

public static voidmain(String[] args) {//复制数组

int a[]= {1,2,3,4};int b[]=Arrays.copyOf(a, 5);for(int i=0;i

System.out.println(b[i]);

}

}

(2)copyOfRange()方法

语法：

copyOfRange(arr,int formIndex,int tolndex)

arr:要进行复制的数组对象

formIndex：指定开始复制数组的索引位置

toIndex：要复制范围的最后索引位置，可大于数组arr长度，但新数组不包括索引是toIndex的元素。

public static voidmain(String[] args) {//复制数组

int a[]= {1,2,3,4};int b[]=Arrays.copyOfRange(a, 0,6);for(int i=0;i

System.out.println(b[i]);

}

}

结果：1,2,3,4,0,0

1.10 数组的排序

(1)冒泡排序

基本思想：对比相邻的元素值，如果满足条件就交换位置，小在前大在后。这样较小的元素就像气泡一样从底部上升到顶部。

语法：

binarySearch(Object[]a,Object key)

a:要搜索的数组

key：要搜索的值

如果key包含在数组中，则返回搜索值的索引；否则返回-1或“-”(插入点)。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引。

public static voidmain(String[] args) {//冒泡排序

int a[]= {11,33,22,55,44};for(int i=0;ia[j+1]) {int temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

}

}

}

System.out.println(Arrays.toString(a));

}

}

(2)选择排序

思想：将指定位置元素与其他数组元素做对比，满足条件交换位置。即从第一个位置开始与后面数字逐个对比，并按照从小到大排序。

图解：

此图可以清晰的明白，外循环就是数组的起点位置，数组里有6个元素就有5个起点，外循环控制的是箭头的到达位位置，如果外循环起点为i，那么内循环的起点就为i+1。外循环的元素不断和内循环里的元素进行对比并按着从小到大的顺序排列。

public static voidmain(String[] args) {//选择排序

int arr[]= {34,19,11,109,3,56};for(int i=0;iarr[j]) {int temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

}

System.out.println(Arrays.toString(arr));

}

(3)数组的逆序原理

思想：

对已经排序好的数组，把数组的最后一个元素与第一个元素替换，倒数第二个与第二个元素替换，以此类推。

针对此法我们需要两个指针，一个小指针和一个大指针，小指针=0索引，大指针=最大索引(其实就是小指针min++，大指针max--)；数组换位需要引入第三方变量实现。

public static voidmain(String[] args) {//逆序排列

int arr[]= {1,3,8,9,14,23,24,30,33,34,35};

set(arr);

print(arr);

}//引入三方变量进行指针交换方法

public static void set(intarr[]) {for(int min=0,max=arr.length-1;min

arr[min]=arr[max];

arr[max]=temp;

}

}//定义方法遍历数组

public static void print(intarr[]) {

System.out.print("[");for(int i=0;i

System.out.print(arr[i]+"]");

}else{

System.out.print(arr[i]+",");

}

}

}

}

(4)反向遍历

public static voidmain(String[] args) {int arr[]= {1,3,8,9,14,23,24,30,33,34,35};for(int i=arr.length-1;i>=0;i--) {

System.out.println(arr[i]);

}

}

反向遍历和逆序排列的区别：

反向遍历与逆序的区别在于，反向遍历的索引对应元素不会随着位置的改变而改变，即确定了一个数组，它的索引值就确定了。而逆序位置改变，索引值也发生改变，相同点是都是反向排序。

1.11  随机点名器小案例

思路：

(1)创建一个字符串数组并进行初始化

(2)遍历数组

(3)引入随机数，通过随机数找到指定的索引

public static voidmain(String[] args) {

String name[]= {"张三","李四","王五","田六","王七","朱八"};for(int i=0;i

}//通过Random对象引入随机数

Random ran=newRandom();int j=ran.nextInt(name.length); //通过随机数找到数组的索引

System.out.println(name[j]); //打印指定索引对象

System.out.println(j); //打印索引的位置

}

}