黑马程序员技术交流社区

标题: 将数组相关的操作方法封装成类及其调用实现 [打印本页]

作者: samge    时间: 2015-11-14 02:17
标题: 将数组相关的操作方法封装成类及其调用实现
  1. /**
  2. 思路:
  3. 1、定义一个数组操作的类,该类有求数组最大最小值、选择/冒泡排序、打印数组的功能
  4. 2、选择/冒泡排序需要进行数据的交换,将交换独立为一个方法
  5. 3、对外的方法公用化,外部用不到的方法私有化
  6. 4、一般操作数组是不需要用到数组操作类的对象,所以将方法静态化直接通过类名访问即可,
  7.         为了防止被创建对象,将空参构造函数设为私有的
  8. */
  9. class ArrayTool {
  10.         //将空参构造函数私有
  11.         private ArrayTool(){};
  12.         //遍历打印数组的方法
  13.         public static void arrayPrint(int[] arr){
  14.                 System.out.print("[");
  15.                 for(int i = 0;i < arr.length-1;i++){
  16.                         System.out.print(arr[i]+",");
  17.                 }
  18.                 System.out.println(arr[arr.length-1]+"]");
  19.         }

  20.         //实现数组中两个数的交换,这里设置为私有的
  21.         private static void arrayChange(int[] arr,int x,int y){
  22.                 int temp =arr[x];
  23.                 arr[x] = arr[y];
  24.                 arr[y] = temp;
  25.         }

  26.         //求数组中的最大值
  27.         public static int getMax(int[] arr){
  28.                 int max = arr[0];
  29.                 for(int i = 1;i < arr.length;i++){
  30.                         if(max < arr[i])
  31.                                 max = arr[i];
  32.                 }
  33.                 return max;
  34.         }

  35.         //求数组中的最小值
  36.         public static int getMin(int[] arr){
  37.                 int min = arr[0];
  38.                 for(int i = 1;i < arr.length;i++){
  39.                         if(min > arr[i])
  40.                                 min = arr[i];
  41.                 }
  42.                 return min;
  43.         }

  44.         //定义一个选择排序方法
  45.         public static void selectSort(int[] arr){
  46.                 //这里是拿前一个元素跟后面每个元素比较,发现比自己小的则置换位置
  47.                 for(int i = 0;i < arr.length;i++){
  48.                         for(int j = i+1;j<arr.length;j++){
  49.                                 if(arr[i] > arr[j])
  50.                                         arrayChange(arr,i,j);
  51.                         }
  52.                         //外循环执行完一次,打印一次过程
  53.                         arrayPrint(arr);       
  54.                 }
  55.         }

  56.         //定义一个冒泡排序方法
  57.         public static void maoPaoSort(int[] arr){
  58.                 for(int i = 0;i < arr.length-1;i++){
  59.                         for(int j = 0;j<arr.length-i-1;j++){
  60.                                 if(arr[j] > arr[j+1])
  61.                                         arrayChange(arr,j,j+1);
  62.                         }
  63.                         //外循环执行完一次,打印一次过程
  64.                         arrayPrint(arr);       
  65.                 }
  66.         }
  67.        
  68.        
  69. }
复制代码
上面的是一个数组一些方法封装在一个ArrayTool类里面,以后需要用到相关操作的话可以直接调用该类方法。其中,该类已经被设置为不能实例化,用static开放了一下方法供外部使用,可以直接以     类名.类方法名();来执行。而下面定义了一个ArrayDemo类进行相关操作的测试。测试证明一切ok。之前有写过冒泡跟选择排序方法等与数组相关的方法,现在学面向对象了,就将这些类似的方法封装在一个类里面以供以后使用方便。下面是ArrayDemo类的代码:
  1. import java.util.*;
  2. class ArrayDemo {
  3.         public static void main(String[] args) {

  4.                 //建立一个Sanner对象从键盘获取数值
  5.                 Scanner sc = new Scanner(System.in);

  6.                 //自定义数组长度
  7.                 System.out.print("请输入你要定义的数组长度:");

  8.                 int n = sc.nextInt();
  9.                 int [] arr = new int[n];

  10.                 for(int i = 0;i < n;i++){
  11.                         System.out.print("请输入数组的"+(i+1)+"个数:");
  12.                         //数组接收从键盘录入的数据
  13.                         arr[i] = sc.nextInt();               
  14.                 }

  15.                 //打印数组
  16.                 ArrayTool.arrayPrint(arr);

  17.                 //求数组的最大值
  18.                 int max = ArrayTool.getMax(arr);
  19.                 System.out.println("max = "+max);

  20.                 //求数组的最小值
  21.                 int min = ArrayTool.getMin(arr);
  22.                 System.out.println("min = "+min);

  23.                 /*

  24.                 //选择排序输出
  25.                 System.out.println("排序过程:");

  26.                 //打印原数组
  27.                 ArrayTool.arrayPrint(arr);

  28.                 //开始排序
  29.                 ArrayTool.selectSort(arr);

  30.                 System.out.println("排序后:");
  31.                 ArrayTool.arrayPrint(arr);
  32.                
  33.                 */

  34.                 System.out.println("——————————————————————————————————————");

  35.                 //选择冒泡输出
  36.                 System.out.println("排序过程:");

  37.                 //打印原数组
  38.                 ArrayTool.arrayPrint(arr);

  39.                 //开始冒泡排序
  40.                 ArrayTool.maoPaoSort(arr);

  41.                 System.out.println("排序后:");
  42.                 ArrayTool.arrayPrint(arr);

  43.         }
  44. }
复制代码



作者: samge    时间: 2015-11-14 02:20
ArrayDemo类是用Scanner对象从键盘获取数值,从而可以构建可变长度的数组再进行操作。当然,代码属于初级的,很多地方没有考虑周到。还望同学们指点,谢谢




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2