第五章数组

snowman_tunan

已于 2023-03-16 21:05:07 修改

阅读量60

点赞数

分类专栏： Java 文章标签： eclipse Powered by 金山文档

于 2023-03-13 19:23:21 首次发布

本文链接：https://blog.csdn.net/snowman_tunan/article/details/129484828

版权

Java 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

1.数组概述

数组是具有相同数据类型的一组数据的集合。例如，球类的集合----足球、篮球、羽毛球等；在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在java 中同样将数组看作一个对象，虽然基本数据类型不是对象，但由基本数据类型数据组成的数组却是对象。

2.一维数组

一维数组实质，上是一组相同类型数据的线性集合，当在程序中需要处理一组数据，或者传递一组数据时，可以应用这种类型的数组。

（1）创建一维数组代码：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        char[] a;//更常用
        int b[];//声明一个数组
        a = new char[] {'a','b'};//数组的内存分配并且初始化
        b = new int[6];//数组的内存分配
        b[0] =1;//给零号元素赋值，数组元素赋值
        b[1] =2;
        b[2] =3;
        b[3] =4;
        b[4] =5;
        b[5] =6;

        //数组的遍历指从数组的零到最后一个元素的输出，你可以拿到数组里面所有的元素
        for(int i = 0;i<b.length;i++) {
            int temp = b[i];
            //以下操作与遍历无关
            System.out.println(temp);
        }
        for(int temp:b) {//相当于上面的两行代码
            System.out.println(temp);
        }
        for(int i = 0;i<a.length;i++) {
            char temp = a[i];
            //以下操作与遍历无关
            System.out.println(temp);// java.lang.ArrayIndexOutOfBoundsException数组下标越界（多了或少了元素）
            
        }
        for(char temp:a) {//相当于上面的两行代码
            System.out.println(temp);
        }foreach循环
        
    }

例题代码：

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++) {//利用循环将信息输出
            System.out.println((i+1)+"月有"+day[i]+"天");//输出每月的天数
        }
        int i=0;
        for(int temp :day) {
            System.out.println((i+1)+"月有"+temp+"天");
        }
    }

}

结果：

3.二维数组

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

（1）创建二维数组

public static void main(String[] args) {
        // TODO Auto-generated method stub
        char[][] a;//更常用
        int b[][];//声明一个数组
        a = new char[][]{{'a','b'},{'c','d','e'}};//数组的内存分配并且初始化
        b = new int[3][3];//数组的内存分配
        //给零号元素赋值，数组元素赋值(下)
        b[0] =new int[] {1,2,3};
        b[1] =new int[]{4,5,6};
        b[2] =new int[] {7,8,9};
        //数组的遍历指从数组的零到最后一个元素的输出，你可以拿到数组里面所有的元素
        for(int i = 0;i<b.length;i++) {
            int temp = b[i];
            //以下操作与遍历无关
            System.out.println(temp);
        }
        for(int temp:b) {//相当于上面的两行代码
            System.out.println(temp);
        }
        for(int i = 0;i<a.length;i++) {
            char temp = a[i];
            //以下操作与遍历无关
            System.out.println(temp);// java.lang.ArrayIndexOutOfBoundsException数组下标越界（多了或少了元素）
            
        }
        for(char temp:a) {//相当于上面的两行代码
            System.out.println(temp);
        }
        
    }

}

例题代码：

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

}

结果：

4.数组的基本操作

遍历数组：遍历数组就是获取数组中的每个元素，通常遍历数组都是使用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（）来对数组中的元素进行替换。

例题代码：

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

        }
        
    }

结果：

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

        }
        
    }

结果：

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

例题代码：

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("第"+i+"个元素是:"+arr[i]);//将数组中的元素依次输出
         }

        }
        
    }

结果：

复制数组：空位补0，溢出去掉，Arrys类copyOF（）方法与copyOFRange()方法可以实现对数组的复制

copyof()方法：该方法提供了多种重载形式，用于满足不同类型数组的复制；copyOFRange()方法：也同样提供了多种重载形式

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

        }
        
    }

结果：

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

        }
        
    }

结果：

查询数组：Arrys类的binarySearch（）方法，可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回搜索元素的索引值，binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要，一定要先排序在排查，前含后不含

例题代码：

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

        }

结果：

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.数组排序算法

冒泡排序：排序数组排序元素的过程总是将较小的数往前放，较大的数往后放，类似水中气泡往上升的动作

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

例题代码：

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

结果：

直接选择排序

代码例题：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array= {63,4,24,1,3,15};//创建一个数组，元素是乱序的
        three sorter=new three();//创建冒泡排序类的对象
        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;
                }
            }
            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);
        }
        System.out.println();
    }

}

结果：

反转排序：反转排序就是以相反的顺序把原有的数组的内容重新排序

基本思想：最后一个元素和第一个元素替换，倒数第二个和第二个元素替换，依次类推，直到把所有数组元素反转替换

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 shouArray(int[]array) {
  for(int i:array) {//遍历数组
   System.out.print("\t"+i);//输出每个数组元素值
  }
  System.out.println();
 }
}

结果：

snowman_tunan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第五章数组

数组是具有相同数据类型的一组数据的集合。例如，球类的集合----足球、篮球、羽毛球等；在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在java 中同样将数组看作一个对象，虽然基本数据类型不是对象，但由基本数据类型数据组成的数组却是对象。
复制链接

扫一扫