Java第四章总结数组

刺棱.cian.

已于 2022-03-27 19:58:41 修改

阅读量480

点赞数

文章标签： java

于 2022-03-26 23:20:31 首次发布

本文链接：https://blog.csdn.net/m0_62194704/article/details/123765627

版权

本文介绍了数组的概念、一维与二维数组的创建、初始化及使用方法，并详细讲解了数组的基本操作，如遍历、填充和复制等。此外，还介绍了几种常见的数组排序算法，包括冒泡排序、选择排序以及使用Arrays.sort()方法进行排序。

摘要由CSDN通过智能技术生成

4.5.3 Arrays.Sort （）方法

数组是具有相同数据类型的一组数据的集合，在程序设计中，可以将这些集合称为数组，数组中的每个元素具有相同的数据类型，在JAVA中同样将数组看作一个对象，虽然基本数据类型不是对象，但是由基本数据类型组成的数组则是对象，在程序设计中引入数组可以有效地管理和处理数据。我们经常使用数组，包括一维数组和二维数组等

4.2 一维数组

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

4.2.1 创建一维数组

数组元素类型决定了数组的数据类型。它可以是Iva中任意的数据关型包括基本数据类型和其他引用类型。数组名字为一个合法的标识符，符号“[]”指明该变量是一个数组类型变量。单个“[]”表示要创建的数组是一个一维组。

4.2.2 初始化一维数组

数组可以与基本数据类型一样进行初始化操作，也就是赋初值。数组的初始化可分别初始化数组中的每个元素

4.2.3 获取数组长度

4.1

package fzz;
public class fo {    //创建主类
	public static void main(String[] args) {   //主方法
		// TODO Auto-generated method stub
char a[]= {'A','B','C','D'};   //创建一维数组
System.out.println("数组a的长度为"+a.length);  //输出a的长度
char b[]=a;  //创建一维数组b，直接等于数组a
System.out.println("数组b的长度为"+b.length);  //输出b的长度
	}
}

4.2.4 使用一维数组

4.2

package fzz;
public class fo {    //创建主类
		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};   //输出一年12月中每月的天数
	for (int i=0;i<12;i++) {   //利用循环将信息输出
		System.out.println((i+1)+"月有"+day[i]+"天");   //输出的信息
	}
		}
	}

4.3二维数组

比如快捷酒店，每-个楼层都有很多房问，这些房问都可以构成维数组，如果这个酒店有500个房间，并且所有房间都在同一个楼层里，那么拿到499号房钥匙的旅客可能就不高兴了，从1号房走到499号房要花好长时间，因此每个酒店都不只有一个楼层，而是很多楼层，每一个楼层都会有很多房间，形成一个立体的结构，把大量的房间均摊了下来，这种结构就是二维表结构，如图4.7所示，在计算机中，这种二维表结构可以使用二维数组来表示。如图所示，每一个楼层都是一个一维数组，楼层数本身又构成了一个数组，这样一家酒店就构成了一个二维数组。

4.3.1 创建二维数组

4.3.2 初始化二维数组

4.3


package fzz;
public class fo {    //创建主类
		public static void main(String[] args) {    //主方法
			// TODO Auto-generated method stub
	/*第一种方法*/
	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 使用二维数组

4.4

package fzz;
public class fo {    //创建主类
		public static void main(String[] args) {   //主方法
			// TODO Auto-generated method stub
			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) {
		      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.5

package fzz;
public class fo {    //创建主类
		public static void main(String[] args) {     //主方法
			// TODO Auto-generated method stub
	int a[][]=new int[3][];   //创建二维数组，指定行数，不指定列数
	a[0]= new int[] { 52, 64, 85, 12, 3, 64 };   //第一行分配6个元素
	a[1]= new int[] { 41, 99, 2 };   //第二行分配3个元素
	a[2]= new int[] { 285, 61, 278, 2 };   //第三行分配4个元素
	for(int i=0;i<a.length;i++) {  //循环i的元素
		System.out.print("a["+i+"]中有"+a[i].length+"个元素，分别是:");    //输出length个元素
		for (int tmp:a[i]) {   //foreach循环输出数组中元素
			System.out.print(tmp+" ");  //输出空格
		}
		System.out.println();    //输出换行
		}
	}
		}

4.4 数组的基本操作

4.4.1 遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for 循环来实现的。遍历维数组很简单，也很好理解，下面详细介绍遍历二维数组的方法。
遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。

4.6

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

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

数组中的元素定义完成后，可通过Arrays类的静态方法fll0来对数组中的元素进行分配，可以起到填充和替换的效果。fll()方法有两种参数类型，下面以int型数组为例介绍fill()方法的使用。

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

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

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

value：要存储数组中所以元素的值
4.7

package fzz;
import java.util.Arrays;    //导入java.util.Arrays类
public class fo {    //创建主类

		public static void main(String[] args) {   //主方法
			// TODO Auto-generated method stub
	int arr[]=new int[5];  //创建int型数组
	Arrays.fill(arr, 8);   //使用同一个值对数组进行填充
	for(int i=0;i<arr.length;i++) {  //循环遍历数组中的元素
		//将数组中的元素一次输出
		System.out.println("第"+i+"个元素是:"+arr[i]);//输出数组中的元素
		}
	}
	}

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

方法将指定的int值分配给int型数组指定范围中的每个元素，填充的范围从索引fromlndex一直索引toinde。如果fromindex==toindex，则填空范围为空

a：要进行元素分配的数组

fromlndex：要使用指定值填充的第一个元素的索引

toindex：要使用指定值填充的最后一个元素的索引

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

package fzz;
import java.util.Arrays;    //导入java.util.Arrays类
public class fo {    //创建主类
		public static void main(String[] args) {   //主方法
			// TODO Auto-generated method stub
	int arr[]=new int[] {45,12,2,77,31,91,10};  //定义并初始化int型数组arr
	Arrays.fill(arr,1,4,8);
	for(int i=0;i<arr.length;i++) {   //使用fill()方法对数组进行填充
		//将数组中的每个元素输出
		System.out.println("第"+i+"个元素是:"+arr[i]);  //输出数组中的元素
	}
		}
	}

4.4.3 复制数组

4.9

package fzz;
import java.util.Arrays;     //导入java.util.Arrays类
public class fo {     //创建主类
	public static void main(String[] args) {    //主方法
		// TODO Auto-generated method stub
		int arr[] = new int[] { 23, 42, 12 };// 定义数组
	    int newarr[]=Arrays.copyOf(arr, 5); //复制数组arr
	    for (int i = 0; i < newarr.length; i++) {//循环变量复制后的新数组
	     System.out.println("第" + i + "个元素是:" + newarr[i]); //将新数组输出
	   }
	 }
}

4.10

package fzz;
import java.util.Arrays;   //导入java.util.Arrays类
public class fo {     //创建主类
 public static void main(String[] args) {   //主方法
  int arr[]=new int[] {23,42,12,84,10}; // 定义数组
     int newarr[] = Arrays.copyOfRange(arr, 0, 3); // 复制数组
  for (int i =0; i < newarr.length; i++){ //循环遍历复制后的新数组
   //将数组中的每个元素输出
   System.out.println(newarr[i]);// 将新数组中的每个元素输出
  }
 }
}

4.5 数组的排序

在程序设计中，经常需要将一-组数据进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序等。本节将对常用的数据排序方法进行详细讲解。

4.5.1 算法：冒泡排序

冒泡排序是最常用的数组排序算法之-一，它以简洁的思想与实现方法备受青睐，是初学者最先接触的一个排序算法。使用冒泡排序时，排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。

1.基本思想

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

2.计算过程

冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，般是要排序的数组长度减1次，因力最后一次循环只剩下-一个数组元素，不需要对比，同时数组已经完成排序了。而内层循平主要用于对比数细中每个临近元素的大小，以确定见否交换位置，对比和交换次数以排序轮数而碗少。

第一轮外层循环时把最大的元素值63移动到了最后面(相应的比63小的元素向前移动，类似气泡上升)，第二轮外层循环不再对比最后个元素值63,因为它已经确认为最大 (不需要上升)，应该放在最后，需要对比和移动的是其他剩余元素，这次将元素24移动到了63的前一一个位置。其他循环将依此类推，继续完成排序任务。

3.算法实现

4.11

package fzz;
public class fo {   //创建主类
/**
 * 冒泡排序法
 * @param array
 *           要排序的数组
 */
 public  void sort(int[] array) {   //主方法
  //比较相邻两个元素，较大的数往后冒泡
   for (int i=1;i< array.length;i++) {    //定义i的值
    for(int j=0;j<array.length-i;j++) {   //定义j的值
    if (array[j]>array[j+1]) {
    //如果前一个元素比后一个元素大，则两元素互换
     int temp=array[j]; // 把第一个元素值保存到临时变量中
    array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中 
    array[j+1]=temp;}}}// 把临时变量(也就是第一个元素原值)保存到第二个元素中
   showArray(array);}//输出冒泡排序后的数组元素
 /**
  * x显示数组中所有的元素
  * 
  * @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 };     
  fzz sorter=new  fzz();   //输出BubbleSoort的值
  sorter.sort(array);//调用排序方法数组排序 
 
   }
  }

4.5.2 算法：选择排序

直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法，是初学者应该掌握的。

1.基本思想

直接选择川序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而尼把满足条件的元水与指定的排序位置交换(如从最后一个元水开始那序)，这样排序好的位置足渐扩大，最后格个数组都成为已排序好的格式。
这就好比有一个小学生，从包含数字1~10的乱序的数字推中分别选择合适的数字，组成一个从1~10的排序，而这个学生'先从数字地中必出1，放在第一位，然后选出2 (注意这时数字堆中已经没有1了)，放在第二位，依此类推，自到找到数字9,放到8的后面，最后剩下10,就不用选择了，直接放到最后就可以了。
与冒泡排序相比，直接选择排序的交换次数观少很多，所以速度会快些。

2.计算过程

每一趟从待排序的数据元素中必出最小（或最大)的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

3.算法实现

4.12

package fzz;
public class fo {   //创建主类
	/**
	   * 直接选择排序法
	   *  @param array 
	   *    要排序的数组
	   */
	  public void sort(int[] array) {   //主方法
	   int index;
	   for (int i = 1; i <array.length; i++) {   //定义i的值
	    index = 0;   //index为0的数
	    for (int j = 1; j <= array.length - i; j++) {  //定义j的值
	     if (array[j] > array[index]) {
	      index = j;
	     }
	    }
	    // 换在置array.length-i和index(最大值)上的两个数
	    int temp = array[array.length - i]; // 把第一个元素值保存到临时变量中
	    array[array.length - i] = array[index]; // 把第二个元素值保存到第一个元素单元中 
	    array[index] = 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 };
	    //创建直接排序类的对象 
	   fo sorter = new fo();
	   //调用排序对象的方法将数组排序
	   sorter.sort(array);
	  }
	 }

4.5.3 Arrays.Sort （）方法

通过Arrays类的静态sort（）方法可实现对数组的排序，sort（）方法提供了多种使用方式，可对任意类型数组进行升序排序。

4.13

package fzz;
import java.util.Arrays;    //导入java.util.Arrays类
public class fo {    //创建主类
    public static void main(String[] args) {   //主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12,8};//声明数组
         Arrays.sort(arr);//将数组进行排序
         System.out.println("排序后的结果为:");  //输出排序结果
         for(int i=0;i<arr.length;i++) {//循环遍历排序后的数组
          System.out.print(arr[i]+" ");//将排序后数组中各个元素输出
         }
    
    }
}