Java第四章总结_大道至简java第四章-优快云博客

在计算机语言中数组是非常重要的集合类型，大部分计算机语言中数组具有如下三个基本特性：
一致性：数组只能保存相同数据类型元素，元素的数据类型可以是任何相同的数据类型。
有序性：数组中的元素是有序的，通过下标访问。
不可变性：数组一旦初始化，则长度（数组中元素的个数）不可变。
总的来说，数组具有以下特点：
数组可以是一维数组、二维数组或多维数组。
数值数组元素的默认值为 0，而引用元素的默认值为 null。
数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。
数组元素可以是任何类型，包括数组类型。
数组类型是从抽象基类 Array 派生的引用类型。

4.2 一维数组

数组名字为一个合法的标识符，符号“[ ]”指明该变量是一个数组类型变量。单个“[ ]”表示要创建的数组是一个一维数组。

4.2.1 创建一维数组

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

int [ ] a ; //数组元素类型[ ] 数组名字

int a [ ] ; //数组元素类型数组名字

声明一维数组，语法如下：

int arr [ ]；//声明int型数组，数组中的每个元素都是int型数值

double[ ] dou；//声明double型数组，数组中的每个元素都是double型数组

数据类型[ ] 数组名 = new 数据类型[数组长度]；

int[ ] a = new int [ 5 ]；

4.2.2初始化一维数组

数组的初始化可分别初始化数组中的每个元素。数组的初始化有以下3种方式：

int a [ ] = { 1,2,3 } ; //第一种方式

int b [ ] = new int [ ] { 4,5,6 } ；//第二种方式

int c [ ] = new int [ ] ； //第三种方式

c [ 0 ] = 7 ； //给第一个元素赋值

c [ 1 ] = 8 ; //给第一个元素赋值

c [ 2 ] = 9； //给第一个元素赋值

注意：Java中的数组第一个元素，索引是以0开始的。

4.2.3 获取数组长度

arr . length

arr :数组名。

length:数组长度属性，返回int值

4.2.4 使用一维数组

在Java中，一维数组是最常见的一种数据结构。

public class test2 {//创建类
 
	public static void main(String[] args) {//主方法
		int day[]=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
		for(int i=0;i<12;i++){//利用循环将信息输出
			System.out.println((i+1)+"月有"+day[i]+"天");//输出的信息
		}
				
 
	}
 }

数组越界

public class test3 {//创建类
 
	public static void main(String[] args) {//主方法
		int a[]=new int[3];//最大下标为2
		System.out.println(a[3]);//下标越界！
		
		
	}
 
}

4.3 二维数组

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

4.3.1 创建二维数组

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

int a [ ] [ ] ；// 数组元素类型数组名字[ ] [ ]；

int [ ] [ ] a ；// 数组元素类型 [ ] [ ] 数组名字；

声明二维数组。代码如下：

int tdarr1 [ ][ ] ；

char [ ][ ] tdarr2；

为二维数组分配内存有两种方式：

int a [ ][ ]；

a = new int [ 4 ] [ 2 ] ； // 直接分配行列

int b [ ][ ]；

b = new int [ 2 ] [ ] ； //先分配行，不分配列

b [ 0 ] = new int [ 2 ] ； //给第一行分配列

b [ 1 ] = new int [ 2 ] ； ///给第二行分配列

4.2.3 初始化二维数组

初始化二维数组有三种方式：

type[ ][ ] arrayName = new type[ ][ ] {值 1,值 2,值 3,…,值 n}; // 在定义时初始化
type[ ][ ] arrayName = new type[ size1 ][ size2 ]; // 给定空间，在赋值
type[ ][ ] arrayName = new type[ size ][ ]; // 数组第二维长度为空，可变化

public class test4 {
 
	public static void main(String[] args) {
	int tdarr1[][]={{1,3,5},{5,9,10}};//定义一个二维数组并初始化
	int tdarr2[][]=new int[][]{{65,55,12},{92,7,22}};//定义一个二维数组并初始化
	int tdarr3[][]=new int[2][3];//先给数组分配内存空间
	tdarr3[0]=new int[]{6,54,71};//给第一行分配一个一维数组
	tdarr3[1][0]=63;//给第二行第一列赋值为63
	tdarr3[1][1]=10;//给第二行第二列赋值为10
	tdarr3[1][2]=7;//给第二行第三列赋值为7
	
 
	}
 }

4.3.3使用二维数组

public class test5 {
public static void main(String[]args){
	char arr[][]=new char[4][];//创建一个4行的二维数组
	arr[0]=new char[]{'春','眠','不','觉','晓'};//为每一行赋值
	arr[1]=new char[]{'处','处','闻','啼','鸟'};
	arr[2]=new char[]{'夜','来','风','语','声'};
	arr[3]=new char[]{'花','落','知','多','少'};
	System.out.println("-----横版-----");//输出信息
for(int i=0;i<4;i++){//循环4行
	for(int j=0;j<5;j++){//循环5列
		System.out.print(arr[i][j]);//输出数组中的元素
	
	}
	if(i%2==0)//判断i是否为偶数
	{	System.out.println(",");//如果是一、三句，输出逗号
		
	}else{System.out.println("。");//如果是二、四句，输出句号
		
	}
}
	
	System.out.println("\n-----竖版-----");//输出信息
	for(int j=0;j<5;j++){//列变行
		for(int i=3;i>=0;i--){//行变列，反序输出
			System.out.print(arr[i][j]);//输出数组中的元素
			
		}
		System.out.println();//换行
	}
	System.out.println("。 ， 。 ，");//输出信息
}
}

4.4 数组的基本操作

4.4.1 遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现的。遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。

public class test8 {//主方法
 
	public static void main(String[] args) {//创建类
		int b[][]=new int[][]{{1},{2,3},{4,5,6}};//定义二维数组
		for(int k=0;k<b.length;k++){//for循环
			for(int c=0;c<b[k].length;c++){//循环遍历二维数组中的每一个元素
				System.out.print(b[k][c]);//将数组中元素输出
			}
			System.out.println();//输出信息
		}
 
	}
 }

for ( int i =0;i< 数组名.length;i++ ) {

数据类型 a =数组名[ i ];

}

4.4.2 填充和批量替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行分配，可以起到填充和替换的效果。

1.fill(int[] a,int value)

语法如下：

Arrays.fill (int [ ] a , int value)

a : 要进行元素分配的数组。

value : 要存储数组中所有的元素的值。

2.fill(int[] a ,int fromlndex ,int tolndex, int value)

语法如下：

Arrays.fill (int [ ] a , int fromIndex , int toIndex , int value )

value : 要使用指定值填充的第一个元素的索引（包括）。

toIndex : 要使用指定值填充的最后一个元素的索引（包括）

4.4.3 复制数组

在 Java 中实现数组复制分别有以下 4 种方法：

Arrays 类的 copyOf() 方法

Arrays 类的 copyOfRange() 方法

System 类的 arraycopy() 方法

Object 类的 clone() 方法

1.copyOf()方法

Arrays.copyOf(arr,int newlength)

数据类型[ ] 新数组名 = Arrays.copyOf(旧数组名，新数组长度)

2.copyOfRange()方法

Arrays.copyOfRange ( arr , int formIndex , int toIndex , int toIndex)

数据类型[]新数组名 = Arrays.copyOfRange(旧数组名，数组前序号，数组后序号)；

4.5 数组的排序

程序常用的排序方法有冒泡排序、选择排序等。

4.5.1 算法：冒泡排序

冒泡排序（Bubble Sort）是常用的数组排序算法之一，它以简洁的思想与实现方法而备受青睐，也是广大学习者最先接触的一种排序算法。

冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

冒泡排序的算法比较简单，排序的结果稳定，但时间效率不太高。Java 中的冒泡排序在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

public class BubbleSort {
	/**
	 * 冒泡排序方法
	 * 
	 * @param 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;
				}
			}
		}
	
	showArray(array);
}
/**
 * 显示数组中的所有元素
 * 
 * @param array
 * 要显示的数组
 */
 
public void showArray(int[]array){
	System.out.println("冒泡排序的结果：");
	for(int i:array){
		System.out.print(i+" ");//输出每个数组元素
		
		
	}System.out.println();//输出每个数组元素
	
}
public static void main(String[]args){//主方法
//创建一个数组，这个数组元素是乱序的
	int[]array={63,4,24,1,3,15};//创建冒泡排序类的对象
	BubbleSort sorter=new BubbleSort();//调用排序方法将数组排序
	sorter.sort(array);
	
}}