JAVA第四章总结

救赎~

已于 2022-04-20 11:55:16 修改

阅读量706

点赞数

文章标签： java p2p 蓝桥杯

于 2022-03-16 10:32:39 首次发布

本文链接：https://blog.csdn.net/weixin_62148534/article/details/123470364

版权

本文详细介绍了Java中数组的概念、声明与初始化，包括一维数组和二维数组的使用。通过实例展示了如何获取数组长度、遍历数组，以及如何进行数组的填充和复制。还探讨了数组的排序，如冒泡排序和选择排序的算法实现。

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

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

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

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

4.1public 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.2int 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]+"天"); //输出的信息
}
}
}

二维数组可以看作是特殊的一维数组，因此，二维数组有两种声明方式：

数组元素类型数组名字[ ] [ ];
数组元素类型 [ ][ ]数组名字; 声明二维数组。代码如下:

int tdarr1[ ] [ ];
char[ ] [ ] tdarr2;

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

int a[ ][ ];
a = new int[2][4]; //直接分配行列
int b[ ][ ];
b = new int[2][ ]; //先分配行，不分配列
创建二维数组的时候，可以只声明“行”的长度，而不声明“列”的长度，例如:
int a[ ][ ] = new int[2][ ];// 可省略“列”的长度
但如果不声明“行”数量的话，就是错误的写法，例如:
int b[ ][ ] = new int[ ] [ ];//错误写法!
int c[ ][ ] = new int[ ] [2];//错误写法!

public class InitTDArray { //创建主类
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.4 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("。，。，");//输出最后的标点
       }

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++) {
               System.out.print("a["+i+"]中有"+a[i].length+"个元素，分别是:");
               for (int tmp:a[i]) { //foreach循环输出数组中元素
               System.out.print(tmp+" ");
               }
               System.out.println();
               }
               }
               }

4.4.1 遍历数组

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

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(); //输出换行

           }
           }
           }

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

1. fill(int[ ] a，int value)
该方法可将指定的int值分配给int型数组的每个元素。
语法如下:

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

a: 要进行元素分配的数组。
value:要存储数组中所有元素的值。
public class shizhu {
   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]);//输出数组中的元素
   }
   }

}

fill(int[ ]a, int fromIndex，int tolndex，int value)
该方法将指定的int值分配给int 型数组指定范围中的每个元素。填充的范围从索引fromIndex(包括)一直到索引 toIndex (不包括)。如果fromIndex = = toIndex,则填充范围为空。
语法如下:

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

a:要进行分配的数组。

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

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

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

注意：如果指定的索引位置大于或等于要进行分配的数组的长度，则会报出ArrayIndexOutOf-BoundsException(数组越界异常)异常。

import java.util.Arrays; //导入java.util.Arrays类
public class lerdwu {
       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]); //输出数组中的元素
       }
       }
       }

Arrarys类的copyOf0方法与copyOfRangeO方法可实现对数组的复制。copyOf0方法是复制数组至指定长度，copyOfRangeO方法则将指定数组的指定长度复制到一个新数组中。
1. copyOf( )方法
该方法提供了多种使用方式，用于满足不同类型数组的复制。语法如下:

Arrays. copyOf (arr, int newlength)

arr: 要进行复制的数组。
newlength: int型常量，指复制后的新数组的长度。如果新数组的长度大于数组 arr的长度，则用0填充(根据复制数组的类型来决定填充的值，整型数组用0填充，char型数组则使用null来填充);如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止。

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]); //将新数组输出
}
}

}

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次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内层循环主要用于对比数组中每个临近元素的大小，以确定是否交换位置，对比和交换次数以排序轮数而减少。

   /**
   * 冒泡排序法
   * @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);}//输出冒泡排序后的数组元素
   /**
   * 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 };
   BubbleSort sorter=new BubbleSort();
   sorter.sort(array);//调用排序方法数组排序

   }
   }

4.12/**
* 直接选择排序法
* @param 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;
}
}
// 换在置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 };
//创建直接排序类的对象
SelectSort sorter = new SelectSort();
//调用排序对象的方法将数组排序
sorter.sort(array);
}
}

4.13import java.util.Arrays;
public class shizhu {
   public static void main(String[] args) { //主方法
       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]+" ");//将排序后数组中各个元素输出
       }
       }
       }

救赎~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA第四章总结

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

扫一扫