第四章数组

最新推荐文章于 2023-08-19 16:25:25 发布

罗李文

最新推荐文章于 2023-08-19 16:25:25 发布

阅读量198

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_65556796/article/details/124238312

版权

4. 创建一维数组

4.1数组的概述

arr：数组名。length：数组长度属性，返回int值。例 4.1 使用length属性获取数组长度

例4. 初始化一维数组

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

例4.2

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

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

例4.4创建一个二维数组，《春晓》，分别用横版和竖版输出

例4.5 创建一个不规则二维数组，输出每行的元素个数及各元素的值

4.4 数组的基本操作4.4.1遍历数组

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

例4.6定义二维数组，将二维数组呈梯形输出

例4.42填充和批量替换数组元素

Array fill(数组名，值)

例4.7通过 fill0方法填充数组元素，最后将数组中的各个元素输出。

例4.8通过 fill0方法替换数组元素，最后将数组中的各个元素输出。

例4.9创建一维数组，将此数组复制得到一个长度为5的新数组，并将新数组输出

例4.10创建一维数组，并将数组中索引位置是0-3之间的元素复制到新数组中

算法：冒泡排序

基本思想

例4.11冒泡排序方法

算法：选择排序

基本思想

例4.12直接选择排序法

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

4. 创建一维数组
数组元素类型决定了数组的数据类型。它可以是Java中任意的数据类型，包括基本数据类型和其他数组类型 []”表示要创建的数组是一个一维数组

声明一维数组有两种方式

数组元素类型数组名字[]；
数组元素类型[]数组名字；

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

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

声明数组后，还不能访问它的任何元素，因为声明数组只是给出了数组名字和元素的数要想真正使用数组，还要为它分配内存空间。在为数组分配内存空间时必须指明数组的长现组分配内存空间的语法格式如下：

数组名字=new数组元素类型[数组元素的个数]；

为数组分配内存，语法如下：
arr = new int[5]; //数组长度为5

4.1数组的概述
数组是具有相同数据类型的一组数据的集合

arr：数组名。
length：数组长度属性，返回int值。
例 4.1 使用length属性获取数组长度

public class Getarray {
    public static void main(String[] args) {
        char a[]= { 'A','B','C','D'};//创建一维数组
        System.out.println("数组a的长度为"+a.length);
        char b[]=a;//创建一维数组b，直接等于数组a
        System.out.println("数组b的长度为"+b.length);
        
    }
 
}

例4. 初始化一维数组

int a[]={1,2,3};//第一种方式
int a[]=new int[] {4,5,6};//第二种方式
int a[]=new int{3};//第三种方式
c[0]=7;//给第一个元素赋值
c[1]=8;//给第二个元素赋值
c[2]=9;//给第三个元素赋值

4.2.3 获取数组长度
我们初始化一维数组的时候都会在内存中分配内存空间，内存空间的大小决定了一维数组能够存储多少个元素，也就是数组长度。如果我们不知道数组是如何分配内存空间的，该如何获取数组长度呢？我们可以使用数组对象自带的length属性。
例4.2

public class GetDay {
    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 ArrayInd {
    public static void main(String[] args) {
        int a[]=new int[3];//最大下标为2
        System.out.println(a[3]);//下标越界！
    }
 
}

二维数组

注意：

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

int bl][] =new int[][];// 错误写法！
int c[][] = new int[][2]；//错误写法！

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

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

public class InitTDA {
    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.4创建一个二维数组，《春晓》，分别用横版和竖版输出

public class Poetry {
    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) {
        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 创建一个不规则二维数组，输出每行的元素个数及各元素的值

public class Irregular {
    public static void main(String[] args) {
    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 数组的基本操作
4.4.1遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现的遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。
二维数组 a[][],a.length返回的是数组的行数，a[0].length返回的是第一行的列数量，a[1].length返回的是第二行的列数量……

同理，a[n]返回的是第n-1行的列数量，由于二维数组可能是不规则数组，所以每一行的列数量可以不相同，所以在循环遍历二维数组的时候，最好使用数组的length属性控制循序次数，而不是用其他变量。

例4.6定义二维数组，将二维数组呈梯形输出

public class Trap {
    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(int c=0; c<b[k].length;c++);{//循环遍历二维数组中的每个元素 
            System.out.print(b[k][c]);//将数组中的元素输出
        }
        System.out.println();//输出换行
    }
    }
}

例4.42填充和批量替换数组元素
数组元素定义完成后，通过Arrays类的静态方法fill()来对数组进行分配，

可以起到填充合体换的效果

Array fill(数组名，值)
Array fill(数组名，数组前序列号的值，数组后序列号的值)

// 数组前序列号的值从0开始前变后不变

复制数组

数据类型

例4.7通过 fill0方法填充数组元素，最后将数组中的各个元素输出。

import java.util.Arrays;
public class Swap {
    public static void main(String[] args) {
        int arr[]=new int[5];//创建int型数组
        Arrays.fill(arr,8);//使用同一个值对数组进行填充
        for(int i=0;i<arr.length;i++) {//循环遍历数组中的元素
            //将数组中的元素依次输出
            System.out.println("第"+i+"个元素是；"+arr[i]);
        }
    }
 
}

例4.8通过 fill0方法替换数组元素，最后将数组中的各个元素输出。

import java.util.Arrays;
public class Displace {
 
    public static void main(String[] args) {
        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.9创建一维数组，将此数组复制得到一个长度为5的新数组，并将新数组输出

import java.util.Arrays;
public class Cope {
    public static void main(String[] args) {//主方法
        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创建一维数组，并将数组中索引位置是0-3之间的元素复制到新数组中

import java.util.Arrays;
public class Repeat {
    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.11冒泡排序方法

public class BubbleSort {
    public static void main(String[] args) {
        int[] array= {63,4,24,1,3,15};//创建一个数组
        BubbleSort sorter= new BubbleSort();//创建冒泡排序类的对象
        sorter.sort(array);//调用排序方法将数组排序
    }
 
    private void showArray(int[] array) {
        System.out.println("冒泡排序的结果；");
        for(int i: array) {//遍历数组
            System.out.print(i+" ");//输出每个元素的值            
        }
      System.out.println();
    }
    public void sort(int[] array) {
        for (int i=1;i<array.length; i++){
            for(int j=0;j<array.length -1;j++) {//比较相邻两个元素，较大的数往后冒泡
                if(array[j]>array[j+1]) {//如果前一个元素比后一个元素大，则两元素互换
                    int temp=array[j];//把第一个元素值保存到临时变量中
                    array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中
                    array[j+1]=temp;//把临时变量(也就是第一个元素原值)保存到第二个元素中
                    
                }
            }
        }
            showArray(array);}}//输出冒泡排序后的数组元素

算法：选择排序
基本思想

直接选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换(如从最后一个元素开始排序)，这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。

例4.12直接选择排序法

public class SelectSort {
 
    public static void main(String[] args) {
        int[] array= {63,4,24,1,3,15};//创建一个数组
        SelectSort sorter=new SelectSort();//创建直接排序类的对象
      sorter.sort(array);//调用排序对象的方法将数组排序
    }/*
    *直接选择排序法
    *    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);//输出直接选择排序后的数组值
}/*
*显示数组中的所有元素
*   显示的数组
*
*/
    private void showArray(int[] array) {
        System.out.println("选择排序结果为：");
        for(int i:array) {//遍历数组
            System.out.print(i+" ");//输出每个数组元素值
        }
        System.out.println();
    }}

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

import java.util.Arrays;
public class Repeat {
    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]);//将新数组中每个元素输出
 
    }
    }
}

本章小结
一、数组3个特点：
1、数组是一种引用数据类型
2、数组当中的多个数据，类型必须统一
3、数组的长度，在运行期间不可改变
数组的初始化，在内存中新建一个数组，并向其赋予一些默认值
二、常见的两种初始化方式：
1、动态初始化（指定长度）
2、静态初始化（指定内容）
数组初始化格式
数据类型 [] 数组名 = new 数据类型[数组长度];

三、概念
数组：内存中一片连续的内存空间，可以存储多个类型相同的数据，方便统一进行处理.
元素：就是数组中的每个数据
下标：就是为每个元素分配的一个编号0----数组的长度-1
数组的长度：就是数组的容量，可以进行动态的获取数组名.length
四、数组的定义
数组定义的步骤：
1.数组的声明：意义在于确定了数组中存放的数据类型以及数组名
2.为数组分配空间/为数组元素直接赋值为数组分配空间：

先分配内存空间，在空间中存放默认值---- 类似于用书包占座为数组的元素直接赋值：

在定义数组的时候，将数组中要存放的数据直接进行存储---- 人直接去占座

五、数组算法排序的好处
1、同时开辟多个空间，语句更加简洁，且提高效率
2、分类存储，而且数组中的空间都是连续的，所以查找比较方便
————————————————