第五章数组

小白编译

已于 2023-03-18 13:00:16 修改

阅读量66

点赞数

文章标签： java 算法 jvm Powered by 金山文档

于 2023-03-14 15:36:33 首次发布

本文链接：https://blog.csdn.net/2201_75845637/article/details/129527536

版权

本文详细介绍了Java中数组的声明、初始化、内存分配，包括一维数组和二维数组的使用。同时，展示了如何遍历、替换数组元素，以及使用Arrays工具类进行复制和排序。还探讨了冒泡排序、直接选择排序和反转排序等基础排序算法的应用。

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

数组

数组可以存储多个变量

一维数组

数组的声明有两种方法

1，数组元素的类型[] 数组名

2，数组元素的类型数组名[]

分配内存

数组名=new 数组元素的类型[数组长度]

分配内存的同时设置初始值

数组名=new 数组元素的类型[]{值1，值2，......值n}

数组元素赋值

数组名[索引] = 值；

5.1


public class Opq { //创建类

    public static void main(String[] args) {  //主方法
        // TODO Auto-generated method stub
        int day [] = new int[] {31,28,31,30,31,31,30,31,30,31,30,31}; //创建并初始化一维数组
        for (int i =0; i<12; i++) {  //利用循环将信息输入
            System.out.println((i+1)+"月有"+day[i]+"天");  //输入每月的输入
        }
    }

}

结果

day.length：固定值避免下标越界问题

二维数组

格子里面存地址指向另一个数组

二维数组被看作数组的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组

二维数组的声明

1，数组元素的类型[] []数组名

2，数组元素的类型数组名[][]

二维数组分配内存

数组名=new 数组元素的类型[行数][列数]

二维数组分配内存的同时设置初始值

数组名=new 数组元素的类型[][]{{值1...}，{值1...}，......{值1...}}；

二维数组的元素赋值

数组名[行号] = {值1，值2...}；

数组名[行号] [列号] = 值；

5.2


public class Matrix {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a [][] =new int[3][4];  //定义二维数组
        for(int i =0;i<a[i].length;i++) {
            for(int j =0;j<a[i].length;j++) {  //循环遍历数组中的每个元素
            System.out.print(a[i][j]);  //将数组中的元素输出
        }
        System.out.println();  //输出空格
        }
    }

}

结果

遍历数组

遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。

5.3


public class Trap {

    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();  // //输出空格
            }
        }

}

结果

使用foreach语句遍历二维数组

5.4


public class Matrix {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr2 [][] = {{4,3},{1,2}};  //定义二维数组
        System.out.println("数组中的元素是：");  //提示信息
        int i=0;  //外层循环计算器变量
        for(int x[]:arr2) {  //外层循环变量为一维数组
            i++;  //外层计数器递增
            int j =0;  //内层循环计数器变量
            for(int e: x) {  //循环遍历每一个数组元素
                j++;  //内层计数器递增
                if(i==arr2.length&&j== x.length) {  //判断变量是二维数组中的最后一个元素
                    System.out.print(e);  //输出二维数组的最后一个元素
                }else  //如果不是二维数组中的最后一个元素
                    System.out.print(e+"、");  //输出信息
            
        }
        
        
        }
    }

}

结果

替换数组

Arrays,fill(数组名,值)；

5.5

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

public class Swap {

    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]);  //将数组中的元素依次输出
        }
        
    }

}

结果

替换数组部分元素：前改后不改

Arrays,fill(数组名,前索引，后索引，值)；

5.6

import java.util.Arrays;

public class Displace {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[]=new int[] {45,12,2,10};  //定义并初始化int型数组arr
        Arrays.fill(arr, 1,2,8);  //使用fill（）方法替换数组指定范围内的元素
        for(int i = 0;i<arr.length;i++) {  //循环遍历数组中的元素
            System.out.println("第"+i+"个元素是:"+arr[i]);  //将数组中的每个元素输出
        }
    }

}

结果

复制数组元素：空位补0溢出去掉

新数组名=Arrays，copyOf（旧数据名，新数组长度）；

5.7

import 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]);   //将排序后数组中的各个元素输出
        }
    }

}

结果

5.8

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

}

结果

复制数组部分元素：前在后不在

新数组名=Arrays，copyOfRange（旧数据名，前索引，后索引）；

5.9

import 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.sort（数组名）；

查询数组元素：先排序再查询

索引=Arrays.binarySearch（数组名，元素）；

5.10

import 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);  //将索引输出
        }

    }

结果

查询数组元素：先排序再查询前含后不含

索引=Arrays.binarySearch（数组名，前索引，后索引，元素）；

5.11

import 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);  //将索引输出
    }

}

结果

冒泡排序

重第一个数字和后面数字比较大小数字大的排在最后依次比较最后排序和最初排序成为冒泡形状

5.12


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);  //输出冒泡排序后的数组元素
}
public void showArray (int []array){
    for(int i:array) {  //遍历数组
        System.out.print(">"+i);  //输出每个元素数组值
    }
    System.out.println();
    }
}

结果

直接冒泡排序

将一排数字中最大的数字排出来将最大的数字挑出来固定位子依次排序

5.13


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);  //调用排序方法，对数组排序
        
    }
    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);  //输出直接选择排序后的数组元素
    }
    public void showArray(int[]array) {
        for(int i:array) {  //遍历数组
            System.out.print(">"+i);  //输出每个元素数组值
            
        }
          
    }
}

结果

反转排序

数组第一个元素和最后一个替换的第二个和倒数第二个替换依次替换

5.14


public class ReverseSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[]array = {10,20,30,40,50,60};  //创建一个数组
         ReverseSort sorter =new  ReverseSort();  //创建反转排序类的对象
        sorter.sort(array);   //调用排序对象方法，将数组反转
        
    }
    public void sort(int []array) {
        System.out.println("数组原有内容：");
        showArray(array);  //输出排序前的数组元素
        int temp;
        int len=array.length;
        for(int i =0;i<len/2;i++) {
            temp=array[i];
            array[i]=array[len-1-i];
            array[len-1-i]=temp;
        }
        System.out.println("整数反转后内容：");
        showArray(array);  //输出排序后的数组元素
}
    public void showArray(int[]array) {
        for(int i:array) {  //遍历数组
            System.out.print("\t"+i);  //输出每个元素数组值
        }
        System.out.println("");
    }
}

结果