Java第五章总结

已于 2023-03-18 20:10:37 修改
阅读量90 收藏
点赞数
分类专栏： java 文章标签： 数据结构 Powered by 金山文档
于 2023-03-18 19:19:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_76549100/article/details/129636635
版权

数组概述

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

在Java中同样将数组看作一个对象，虽然基本数据类型不是对象，但由于基本数据类型组成的数组却是对象。在程序设计中引入数组可以更有效的管理和处理数据。可根据数组的维数将数组分为一维数组，二维数组……

一维数组

  1. 创建一维数组

数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。一维数组的创建有两种形势。

  1. 先声明，在用new关键字进行内存分配

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

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

数组元素类型决定了数据类型，数组名字为一个合法的标识符，符号"[]"指明该变量是一个数组类型变量。单个"[]"表示要创建的数组是一个一维数组

  1. 声明的同时为数组分配内存

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

2.初始化一维数组

数组与基本数据类型一样可以进行初始化操作。数组的初始化可以分别初始化数组中的每个元素。

数组的初始化有两种方式：

int arr[]=new int[]{1,2,3,5,25};

int arr2[]={34,12,6};

3.使用一维数组

例题1

public class GetDay {//创建类

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

输出结果：


public class GetDay {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
        for (int i=0;i<day .length;i++) {//输入i<day.length可以防止出现数组下标越界错误
            System.out.println((i+1)+"月有"+day[i]+"天");//输出每月天数
        }
        //foreach循环遍历数组
        for(int temp:day) {
            System.out.println(temp);    
        }    
    }

}

二维数组

如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组。二维数组常用于表示表，表中的信息以行和列的形式组织，第一个下标代表元素所在的行，第二个下标代表元素所在的列。

  1. 创建二维数组

  1. 先声明，再用new关键字进行内存分配

声明二维数组语法如下：

数组元素的类型 数组名字[] [];

数组元素的类型[] [] 数组名字;

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

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

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

二维数组元素赋值

数组名[行号]={值1 ，值2……};

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

  1. 初始化二维数祖

二维数组的初始化与一维数组初始化类似，同样可以使用大括号完成。

type arrayme[][]={value1,value2……,valuen};

type:数组数据类型

arrayname:数组名称，一个合法的标识符

value:二维数组中各元素，都代表一个一维数组

  1. 使用二维数祖

使用二维数组输出一个3行4列且所有元素都是0的矩形


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.length;i++) {
            for (int j=0;j<a[i].length;j++) {//循环遍历数组中的每个元素
                System.out.print(a[i][j]);//将数组中的每个元素输出
            }
            System.out.println();//输出空格
        }
    }

}

输出结果：

数组的基本操作

  1. 遍历数组

遍历数祖就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。

在遍历数组时，使用foreach语句可能会更简单例题：


public class Tautog {

    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+",");//输出信息
                }
            }
        }
        
    }

输出结果：

  1. 填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。fill()方法有两种参数类型。

替换数组

Arrays.fill(数组名，值)；

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

Arrays.fill(数组名，前索引，后索引，值)；索引=下标

  1. fill(int[] a,aint value)

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

}

结果：

  1. fill(int[] a,int fromlndex,int tolndex,int value)

import java.util.Arrays;//导入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]);//将数组中的每个元素输出
        }
    }
}

结果：

  1. 对数组进行排序

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

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

    }

结果：

Java中的string类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面。

  1. 复制数组

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

新数组名=Arrays.copyof(旧数组名，新数组长度）；

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

}

结果：

  1. copyOFRange方法

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

  }
}

结果：

  1. 查询数组

查询数组：先排序再查询

索引=Arrays.binarys search(数组名，前索引，后索引，元素）；

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

索引=Arrays.binarys search(数组名，前索引，后索引，元素）；

1.binarySearch(Object[] a,Object 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);//将索引输出
        }
    }

结果：

2.binarySearch(Object[] a,int fromlndex,Object key)


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

public class Rake {//创建类

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

}

结果：

数组排序算法

  1. 冒泡排序

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

  1. 基本思想

冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部

  1. 算法演示

冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，而内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置

  1. 算法实现

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();
    }
 
}

结果：

  1. 直接排序

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

  1. 基本思想

直接排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值。与冒泡排序的区别，不是交换元素，而是满足条件的元素与指定的排序位置元素交换，这样排序好的位置逐渐扩大，直至整个数组都变成已排序好的格式

  1. 算法示例

每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序的放在已排好的数列的最后，直到全部待排序的数据元素排完

  1. 算法实现

 
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();
    }
 
}

结果：

  1. 反转排序

顾名思义，反转排序就是以相反的顺序把原有数据的内容重新排序。反转排序算法在程序开发中也经常用到。

  1. 基本思想

反转排序的基本思想比较简单，就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换。

  1. 算法示例

反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半数次，如数组长度为7，那么for循环只需要循环3次

三月
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值