第五章总结

最新推荐文章于 2023-12-24 20:54:59 发布

HCF666666

最新推荐文章于 2023-12-24 20:54:59 发布

阅读量35

点赞数

文章标签： java Powered by 金山文档

本文链接：https://blog.csdn.net/HCF666666/article/details/129645913

版权

一维数组

一维数组实际上是一组相同类型数据的线性集合

1、创建

在Java中数组作为对象允许使用new关键字进行内存分配。

在创建一维数组时，需要先声明再进行内存的分配

在Java中，数组的声明有两种方式：

1、数组元素类型数组名[]; 例如；int array1[];

2、数组元素类型[] 数组名;例如；int[] array2;

在进行数组的声明后，需要为数组分配内存空间才能对数组进行操作。

例如：

2、数组的使用

使用一维数组输出1~12月每个月的天数

package yahu;
public class wuhu {
 
    public static void main(String[] args) {
         //创建并初始化一维数组，如此进行数组的初始化后，系统会自动的计算数组的长度
        int d[]=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)+"月有"+d[i]+"天");    //使用下标访问数组中的元素
        }
    }
}

运行结果

二维数组

定义，如果一维数组中的各个元素仍是一个数组，那么它就是二维数组

二维数组的使用

ackage wuhu;
public class yahu{
 
    public static void main(String[] args) {
        int a[][]=new int[3][4];//定义一个3行4列的二维数组
        
        //遍历数组
        for(int i=0;i<a.length;i++) {
            //.length是数组长度
            for(int j=0;j<a[i].length;j++) {
                System.out.print(a[i][j]);//输出
            }
            //换行
            System.out.println();
        }
    }
}

运行结果

Arrays类方法的使用

在Java中提供了多种多样的方法供使用者使用，这些方法都是Java官方提供的，已经封装好的，我们适当的使用这些提供的方法，能有效的减少代码的冗余度。

在使用Arrays类中的方法前，都需要提前包。

import java.util.Arrays;//导入类

fill(int[ ] a,int value)

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

a：要进行元素替换的数组

value：指定的数据值

例题:

package yahu;
import java.util.Arrays;//导入类
 
public class wuhu {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[]=new int [5];    //创建数组
        Arrays.fill(arr, 8);    //使用同一个值填充数组
        //遍历数组
        for (int i=0;i<arr.length;i++) {    
            System.out.println("第"+i+"个元素是"+arr[i]);
        }
    }
}

运行结果

对数组进行排序

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：

Arrays.sort(数组名）

例题

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

运行结果

复制数组

Arrays类的copyOf()方法与copyRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyRange()方法则将指定数组的指定长度复制到一个新数组中。

copyOf()方法

该方法提供了多种重载形式，用于满足不同类型数组的复制。

例题、


import java.util.Arrays;//导入java.util.Arrays类
 
public class Cope {//创建类
 
    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(newarr[i]);//将新数组输出
        }
    }
 
}

运行结果

2.copyRange()方法

该方法同样提供了多种重载形式。

例题：

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

运行结果

查询数组

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。

binarySearch(Object[] a,Objrct key)

例题：

import java.util.Arrays;//导入java.util.Arrays类
 
public class Reference {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int ia[]=new int[] {1,8,9,4,5};//定义int型数组ia
        Arrays.sort(ia);//将数组进行排序
        int index=Arrays.binarySearch(ia,4);//查找数组ia中元素4的索引位置
        System.out.println("4的索引位置是："+index);//将索引输出
    }
 
}

运行结果

binarySearch(Object[] a,int fromlndex,int tolndex,Objrct key)

例题

import java.util.Arrays;//导入java.util.Arrays类
 
public class Rakel {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        String str[]=new String[] {"ab","cd","ef","yz"};//定义String型数组str
        Arrays.sort(str);//将数组进行排序
        int index=Arrays.binarySearch(str,0,2,"cd");//在指定范围内搜索元素“cd”的索引位置
        System.out.println("cd的索引位置是："+index);//将索引输出
    }
 
}

运行结果

数组排序算法

冒泡排序

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将较小的数往前放、较大的数往后放，类似水中气泡往上升的动作，所以称为冒泡排序。

 public class BubbleSort {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array= {63,4,24,1,3,15};//创建一个数组，元素是乱序的
        BubbleSort sorter= new BubbleSort();//创建冒泡排序类的对象
        sorter.sort(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);//输出冒泡排序后的数组元素
    }
    private void showArray(int[] array) {
        // TODO Auto-generated method stub
        for(int i:array) {//遍历数组
            System.out.print(">"+i);//输出每个数组元素值
            
        }
        System.out.println();
    }
 
}

运行结果

直接选择排序

直接选择排序属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法

例题

 public class SelectSort {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[]array= {63,4,24,1,3,15};//创建一个数组，元素是乱序的
        SelectSort sorter=new SelectSort();//创建直接排序类的对象
        sorter.sort(array);//调用排序对象方法，对数组排序
    }
 
    private void sort(int[] array) {
        // TODO Auto-generated method stub
        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) {
        // TODO Auto-generated method stub
        for(int i:array) {//遍历数组
            System.out.print(">"+i);//输出每个数组元素值
        }
        System.out.println();
    }
 
}

运行结果