java的第4章总结

遇見即是上上籤

已于 2022-04-17 15:54:12 修改

阅读量330

点赞数

文章标签：数据结构 java

于 2022-03-20 21:51:19 首次发布

本文链接：https://blog.csdn.net/weixin_66935612/article/details/123471095

版权

4.5.3Arrays. Sort()方法

4.6总结

4.1数组的概述

数组是相同数据类型的一组数据集合

4.2一维数组

4.2.1创建一维数组

4.2.2初始化一维数组

数组可以与基本数据类型一样进行初始化操作，也就是赋初值。数组的初始化可分别初始化数
组中的每个元素。数组的初始化有以下3种方式:
int a[]={1, 2，3} ;//第一种方式
int b[] = new int[] { 4, 5，6}; //第二种方式
int c[] = new int[3] ;//第三种方式
C[0] = 7;//给第一一个元素赋值
c[1] = 8;//给第二个元素赋值
C[2] = 9;//给第三个元素赋值
注意:
Java中的数组第一一个元素，索引是以0开始的

4.2.3获取数组长度

我们初始化一维数组的时候都会在内存中分配内存空间，内存空间的大小决定了-维数组能够
扫一扫。看视想
存储多少个元素，也就是数组长度。如果我们不知道数组是如何分配内存空间的，该如何获取数组
长度呢?我们可以使用数组对象自带的length属性。语法如下:
arr. length

例题4.1使用length获取数组长度

4.2.4使用一维数组

在Java中，一维数组是最常见的一种数据结构。下面的实例是使用一维数组将1~12月份各月
的天数输出。
例4.2
在项目中创建类GetDay,在主方法中创建int型数组，并实现将各月的天数输出。数组超过长度会报错ayyayindexoutofboundsexception

4.3二维数组

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

4.3.1创建二维数组

一维数组可以看作是特殊的一维数组，因此，二维数组有两种声明方式，
爱祖元素类型数组名字[][];
数机元素类型[][[]数组名字;
声明二维数组。代码如下:
int tdarr1 [][];
char[][] tdarr2;
同维数组一样，二维数组在声明时也没有分配内存空间，同样要使用关键字new来分配内存，
然后才可以访问每个元素。
为二维数组分配内存有两种方式:
int a [][];
a= new int[2][4];
//直接分配行列
int b =[][];
b= new int[2][];
/ /先分配行，不分配列
b[0] = new int[2];//给第一行分配列
b[1l = new int[2];//给第二行分配列
注意:
创建二维数组的时候，可以只声明“行”的长度，而不声明“列”的长度，例如:
int a[][]= new int[2][];//可省略“列”的长度
但如果不声明“行”数量的话，就是错误的写法，例如
int b[][]= new int[][];// 错误写法!
int c[][] = new int[][2];//错误写法!

4.3.2初始化二维数组

二维数组的初始化方法与一维数组类似，也有3种方式。但不同的是，二维数组有两个索引(团
”下标)，构成由行列组成的一个矩阵，如图4.8所示。

例题4.3 用三种方法初始化二维数组

4.3.3 使用二维数组

二维数组在实际应用中非常广泛。下
下面就是休用一维数组输出古诗《春晓》的例子。

例题4.4 将古诗《春晓》的内容赋值于维数组，然后分别用横版和竖版输出

package four.four;

public class four {

   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 four.five;

public class four {

   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};//第一行分配5个元素
       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++){
       System. out.print("a["+i+ "]中有"+ a[i].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 four.six;
public class four {

   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类的静态方法fill0来对数组中的元素进行分配，可以
起到填充和替换的效果。fill0方法有两种参数类型，下面以int型数组为例介绍fill()方法的使用。
1. fll(int[] a，int value)
该方法可将指定的int值分配给int 型数组的每个元素。
语法如下:
Arrays.fill(int[] a，int value)
a: 要进行元素分配的数组。
Value:要存储数组中所有元素的值。

例题4.7 通过fill方法填充数组

若要替换中间如下例题

例题4.8填充数组

package four.eight;
import java.util.Arrays;//导入java .util .Arrays类
public class four {

   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);
       //使用fill ()方法对数组进行填充
       for(int i=0; i< arr. length; i++) {
       //循环遍历数组中的元素
       //将数组中的每个元素输出
       System. out .println("第" + i + "个元素是:"+ arr[i]);
       }
       }
}

4.4.3复制数组

Arrarys类的copyOfRange()方法与copyOfO方法河实现对数组的复制。copyOf方法是复俐数组
至指定长度，copyORangeO方法则将指定数组的指定长度复制到一个新数组中。
1. copyOf()方法
该方法提供了多种使用方式，用于满足不同类型数组的复制。语法如下:
Arrays. copyOf (arr, int newlength)
arr: 要进行复制的数组。
newlength: int 型常量，指复制后的新数组的长度。如果新数组的长度大于数组arr的长度，
则用0填充(根据复制数组的类型来决定填充的值，整型数组用0填充，char型数组则使用null来填充);如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元
素开始截取至满足新数组长度为止。

例题4.9复制一个长度为5的新数组

package four.nine;
import java.util.Arrays; //导入java. util.Arrays类
public class four {

   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++) { //1循环变量复制后的新数组
       System. out.println("第" + i + "个元素:"+ newarr[i]); //将新数组输出

}

}
}

2. copyOfRange()方法
该方法提供了多种使用方式。其常用语法如下:
Arrays . copyOfRange (arr, int formIndex, int toIndex)
arr:要进行复制的数组对象，

formIndex: 指定开始复制数组的索引位置。formIndex 必须在0至整个数组的长度之间。新
数组包括索引是formIndex的元素。
toIndex: 要复制范围的最后索引位置。可大于数组arr的长度。新数组不包括索引是toIndex
的元素。

例题4.10输出索引位置维0-3的元素并复制到新数组中

package four.ten;
import java.util.Arrays; //导入java.util.Arrays
public class four {
   public static void main(String[] args) {//主方法
       // TODO Auto-generated method stub
   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
次，因为最后-次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内层循
环主要用于对比数组中每个临近元素的大小，以确定是否交换位置，对比和交换次数以排序轮数
而减少。例如，一个拥有6个元素的数组，在排序过程中每一次循环的排序过程和结果如图4.18
所示。
第一轮外层循环时把最大的元素值63移动到了最后面(相应的比63小的元索向前移动，类似
气泡上升)，第二轮外层循环不再对比最后一个元素值63,因为它已经确认为最大(不需要上升)，
应该放在最后，需要对比和移动的是其他剩余元素，这次将元素24移动到了63的前一一个位置。其
他循环将依此类推，继续完成排序任务。

例题4.11 冒泡算法

package four.oneone;
/**
* 直接选择排序法
* @author 86158
*要排序的数组
*/
public class four {
   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);//输出冒泡排序后的数组元素
}
   /**
   * 显示数组中所有元素
   * @author 86158
   *要显示的数组
   */
   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);//输出语句
   }

}

4.5.2算法:选择排序

直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序
算法，是初学者应该掌握的。
1.基本思想
直接选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元
素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交
换(如从最后一个元素开始排序)，这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的
格式。
这就好比有一一个小学生，从包含数字1~10 的乱序的数字堆中分别选择合适的数字，组成一个
从1~10的排序，而这个学生首先从数字堆中选出1, 放在第一-位，然后选出2 ( 注意这时数字堆中
已经没有1了)，放在第二位，依此类推，直到找到数字9，放到8的后面，最后剩下10,就不用
选择了，直接放到最后就可以了。
与冒泡排序相比，直接选择排序的交换次数要少很多，所以速度会快些。
2.计算过程
每一趟从待排序的数据元素中选出最小(或最大)的一个元素，顺序放在已排好序的数列的地
后，直到全部待排序的数据元素排完。

例题4.12 选择排序

package four.onetwo;

public class four {

   public void sort (int[] array) {
       // TODO Auto-generated method stub
       int index;//定义int型index
       for (int i=1;i<array.length;i++) {//循环遍历数组
           index=0;//定义index为0
           for(int j=1;j<=array.length-i;j++) {//比较相邻的两个元素，较大的往后冒泡
               if(array[j]>array[index]) {//比较大小
               index=j;   //存放给index
               }
           }
       int temp=array[array.length-i];//把一个元素值保存到临时变量里
       array[array.length-i]=array[index];//将变量放在第二个元素中
       array[index]=temp;//把临时变量保存在第二发元素中
   }
   showArray(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};//定义遍历数组
   SelectSort sorter=new SelectSort();//调用排序将数组排序
   sorter.sort(array);
}

}

4.5.3Arrays. Sort()方法

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

语法如下：Arrays.sort(object)

object:被排序的数组

例题4.13创建一维数组，并排序输出

package four.onethree;

import java.util.Arrays;//导入类
public class four {

   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.println(arr[i]+" ");//将排序后的数组中的各个元素输出

}

}
}

4.6总结

本章介绍了数组的创建及使用方法，重点是创建数组，数组赋值以及读取数组中的元素的值，Arrays类还是提供了其他操作

数组的方法。

遇見即是上上籤

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
java的第4章总结

4.1数组的概述数组是相同数据类型的一组数据集合4.2一维数组4.2.1创建一维数组4.2.2初始化一维数组数组可以与基本数据类型一样进行初始化操作，也就是赋初值。数组的初始化可分别初始化数组中的每个元素。数组的初始化有以下3种方式:int a[]={1, 2，3} ;//第一种方式int b[] = new int[] { 4, 5，6}; //第二种方式int c[] = new int[3] ;//第三种方式C[0] = 7;//给第一一个元素赋值c[1] = 8;//
复制链接

扫一扫