第五章总结

数组概述：数组是具有同一种数据类型的集合，可根据数组的维数将数组分为一维数组、二维数组

一维数组的定义：

int []a;

int a[];

以上为两种定义方式，第一种更加常见

数组遍历：

for（元素类型 x:数组名）{
}

下标越界：

package fifth;

public class 例题5_1 {
public static void main(String[] args) {
// TODO Auto-generated method stub

int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};

int i=0;

for(int temp:day) {//length拿到数组长度

System.out.println((i+1)+"月有"+temp+"天");

i++;

}

}

}

 

 

二维数组：

声明二维数组的语法如下：

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

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

声明二位数组代码如下：

int a[][];

int[][] a;

二维数组声明时也没有分配空间，同样要使用new关键字来分配内存，然后才可以访问每个元素。对于高维数组，有两种为数组分配内存的方式。

第一种内存分配方式是直接为每一维分配内存空间，代码如下：

a=new int[2][4];

第二种内存分配方式是分别为每一维分配内存空间，代码如下：

a=new int[2][];

a[0]=new int[2];

a[1]=new int[3];

初始化二维数组，语法如下：

type arrayname[][]={value1,value2,……valuen）;

type:数组数据类型

arrayname：数组名称，一个合法的标识符。

value：二维数组中各元素，都代表一个一维数组。

初始化二维数组代码如下：

int myarr[][]={{12,0},{45,10}};

使用二维数组：

例题5.2代码如下：

package fifth;

public class Examples5_2 {
public static void main(String[] args) {
// TODO Auto-generated method stub

int a[][]=new int[3][4];//定义二维数组

for(int i=0;i<a.length;i++) {
for(int j=0;j<a[i].length;j++) {
System.out.print(a[i][j]);

}

System.out.println();

}

}

}

输出如下：

 

 

数组的基本操作：

遍历数组：遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现，遍历一维数组很简单，下面遍历二维数组：

例题5.3：

代码

package fifth;

public class Examples5_3 {
public static void main(String[] args) {
// TODO Auto-generated method stub

int b[][]=new int[][] {{1},{2,3},{4,5,6}};//定义二维数组

for(int i=0;i<b.length;i++) {
for(int j=0;j<b[i].length;j++) {//循环遍历二维数组中的每个元素

System.out.print(b[i][j]);//将数组中的元素输出

}

System.out.println();//输出空格

}

}

}

输出：

 

 

例题5.4：

package fifth;

public class Examples5_2 {
public static void main(String[] args) {
// TODO Auto-generated method stub

int arr2[][]= {{4,3},{1,2}};//定义二维数组

System.out.println("数组中的元素是:");//提示信息

int i=0;//外层循环计数器变量为一维数组

for(int x[]:arr2) {//外层循环计数器递增

i++;//内层循环计数器变量

int j=0;//内层循环计数器变量

for(int e:x) {//循环遍历每一个元素

j++;//内层计数器递增

if(i==arr2.length&&j==x.length) {//判断变量是二维数组中的最后一个元素

System.out.print(e);//输出二维数组的最后一个元素

}else//如果不是二维数组中的最后一个元素

System.out.print(e+"、");//输出信息D

}

}

}

}

输出：

 

 

替换数组元素

Arrays.fill(数组名，值)；

例题5.5代码：

填充替换数组元素：

 

数组中的元素定义后，可通过Arrays类的静态

Arrays.fill(数组名，前索引，后索引，值）

索引：为数组的下标

替换部分数组元素：前改后不改（前索引更改，后所以不变）

数组元素排序：

例题5.6

对数组进行排序：

 

Array.sort(数组名）；

练习例题5.7代码

复制数组：空位补零，溢出去掉

 

新数组名=Arrays.copyof(旧数组名，新数组的长度）

例题5.8

复制部分数组元素：前在后不在

 

新数组名=Arrays.copyofRange(旧数组名，前索引，后索引）

例题5.9

旧数组：23 42 12 84 10

 

前索引：0

后索引：3

新数组：23 42 12

查询数组：一定要先排序再查询

例题5.10

package fifth;

import java.util.Arrays;

public class 例题5_10 {
public static void main(String[] args) {
// TODO Auto-generated method stub

int ia[]=new int[] {1,8,9,4,5};

Arrays.sort(ia);

int index=Arrays.binarySearch(ia,4);

System.out.println("4的索引位置是："+index);

}

}

输出：

 

 

索引=Arrays.binarySearch(数组名，要搜索的值）；

查询部分数组：前含后不含

索引=Arrays.binarySearch(数组名，前索引，后索引，要搜索的值）；

例题5.11：

代码：

package fifth;

import java.util.Arrays;

public class 例题5_5 {
public static void main(String[] args) {
// TODO Auto-generated method stub

String str[]=new String[] {"ab","cd","ef","yz"};

Arrays.sort(str);//将数组进行排序

int index=Arrays.binarySearch(str,0,2,"cd");//指定范围内搜索元素cd的索引

System.out.println("cd的索引位置是"+index);

}

}

冒泡排序：

 

基本思想：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（就是交换两个数组值）（记得使用中间变量）这样较小的元素就像气泡一样从底部上升到顶部。

例题5.12：

代码：

package fifth;

public class BubbleSort {
public static void main(String[] args) {
// TODO Auto-generated method stub

int[]array= {63,4,24,1,3,15};

BubbleSort sorter=new BubbleSort();

sorter.sort(array);

}

public void sort(int[] array) {
for(int i=1;i<array.length;i++) {
for(int j=0;j<array.length-i;j++) {
if(array[j]>array[j+1]) {
int temp=array[j];

array[j]=array[j+1];

array[j+1]=temp;

}

}

//System.out.print(">"+i);

}

showArray(array);

}

public void showArray(int[]array) {
for(int i:array) {
System.out.print(">"+i);

}

System.out.println();

}

}

直接选择排序法

基本思想：将指定排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值。

注意：与冒泡排序的区别，不是交换相邻元素，而是把满足条件的元素与指定的排序位置元素交换

算法实现：

例题5.13：

代码：

package fifth;

public class SelectSort {
public static void main(String[] args) {
// TODO Auto-generated method stub

int[]array= {63,4,24,1,3,15};

SelectSort sorter=new SelectSort();

sorter.sort(array);

}

public void sort(int[] array) {
int index;

for(int i=1;i<array.length;i++) {
index=0;

for(int j=1;j<array.length-i;j++) {
if(array[j]>array[index]) {
index=j;

}

}

int temp=array[array.length-i];

array[array.length-i]=array[index];

array[index]=temp;

}

showArray(array);

}

public void showArray(int[]array) {
for(int i:array) {
System.out.print(">"+i);

}

System.out.println();

}

}

输出：

 

 

反转排序：

就是将原有的数组的内柔以相反的方式重新排序。

package fifth;

public class ReverseSort {
public static void main(String[] args) {
// TODO Auto-generated method stub

int[]array= {10,20,30,40,50,60};//创建一个数组

ReverseSort sorter=new ReverseSort();//创建反转排序类的对象

sorter.sort(array);//调用排序对象方法，将数组反转

}

public void sort(int[] array) {
System.out.print("数组原有内容:");

showArray(array);//输出排序前的数组元素

int temp;

int len=array.length;

for(int i=0;i<len/2;i++) {
temp=array[i];

array[i]=array[len-1-i];

array[len-1-i]=temp;

}

//System.out.print(">"+i);

System.out.println("数组反转后内容：");

showArray(array);//输出排序后的数组元素

}

public void showArray(int[]array) {
for(int i:array) {//遍历数组

System.out.print("\t"+i);//输出每个数组元素

}

System.out.println();

}

}

输出：