自定义类封装数组

该页主要使用面向对象的编程方式，自定义类来封装数组

首先介绍一下面向对象和面向过程的基本概念：

面向对象：

把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。

面向过程：

自顶向下顺序执行，逐步求精；其程序结构是按功能划分为若干个基本模块，这些模块形成一个树状结构；各模块之间的关系尽可能简单，在功能上相对独立；每一模块内部均是由顺序、选择和循环三种基本结构组成；其模块化实现的具体方法是使用子程序。程序流程在写程序时就已决定。

第一部分：自定义无序数组

 1  public class MyArray{
 2      private long[] arr;
 3      //表示有效数据的长度
 4      private int elements;
 5      
 6      public MyArray(){
 7          arr = new long[50];
 8      }
 9      
10      public MyArray(int maxsize){
11          arr = new long(maxsize);
12      }
13      
14      /**
15       * 添加数据，无序插入
16       */
17       public void insert(long value){
18           arr[elements] = value;
19           elements ++;
20       }
21       
22       /**
23       * 显示数据
24       */
25       public void display(){
26           System.out.print("[");
27           for(int i = 0; i < elements; i++){
28               System.out.print(arr[i] + " ")
29           }
30           System.out.print("]");
31       }
32       
33      /**
34       * 查找数据
35       */
36       public int search(long value){
37           int i;
38           for(i = 0; i < elements; i++){
39               if(value == arr[i]){
40                   break;
41               }
42           }
43           if(i == elements){
44               return -1;
45           }else{
46               return i;
47           }
48       }
49       
50       /**
51       * 查找数据，根据索引查数据
52       */
53       public long get(long index){
54           if(index >= elements || index < 0){
55               throw new ArrayIndexOutOfBoundsException();
56           } else{
57               return arr[index];
58           }
59       }
60       
61       public static void main(String[] args){
62           MyArray arr = new MyArray();
63           arr.insert(15);
64           arr.insert(37);
65           arr.insert(89);
66           
67           arr.display();
68           System.out.println(arr.search(190));
69           
70           System.out.println(arr.get(0));
71       }
72  }
73  
74 结果：
75  {15 37 89}

第二部分：自定义有序数组，添加二分法查找数据

  1 public class MyOrderArray{
  2      private long[] arr;
  3      //表示有效数据的长度
  4      private int elements;
  5      
  6      public MyOrderArray(){
  7          arr = new long[50];
  8      }
  9      
 10      public MyOrderArray(int maxsize){
 11          arr = new long(maxsize);
 12      }
 13      
 14          /**
 15       * 添加数据，无序插入
 16       */
 17       public void insert(long value){
 18           arr[elements] = value;
 19           elements ++;
 20       }
 21       
 22       /**
 23       * 添加数据，有序插入
 24       */
 25       public void insert(long value){
 26           int i;
 27           for(i = 0; i < elements; i++){
 28               if(arr[i] > value){
 29                   break;
 30               }
 31           }
 32           
 33           for(int j = elements; j > i; j --){
 34               arr[j] = arr[j - 1];
 35           }
 36           arr[i] = value;
 37           elements++;
 38       }
 39       
 40      /**
 41       * 显示数据
 42       */
 43       public void display(){
 44           System.out.print("[");
 45           for(int i = 0; i < elements; i++){
 46               System.out.print(arr[i] + " ")
 47           }
 48           System.out.print("]");
 49       }
 50       
 51      /**
 52       * 查找数据
 53       */
 54       public int search(long value){
 55           int i;
 56           for(i = 0; i < elements; i++){
 57               if(value == arr[i]){
 58                   break;
 59               }
 60           }
 61           if(i == elements){
 62               return -1;
 63           }else{
 64               return i;
 65           }
 66       }
 67       
 68      /**
 69       * 二分法查找数据
 70       */
 71       public int binarySearch(long value){
 72           int middle = 0;
 73           int low = 0;
 74           int pow = elements;
 75           
 76           while(true){
 77               middle = (pow + low) / 2;
 78               if(arr(middle) == value){
 79                   return middle;
 80               }else if(low > pow){
 81                   return -1;
 82               }else{
 83                   if(arr[middle] > value){
 84                       pow = middle - 1;
 85                   }else{
 86                       low = middle + 1;
 87                   }
 88               }
 89           }
 90       }
 91       
 92       /**
 93        * 查找数据，根据索引查数据
 94        */
 95       public long get(long index){
 96           if(index >= elements || index < 0){
 97               throw new ArrayIndexOutOfBoundsException();
 98           } else{
 99               return arr[index];
100           }
101       }
102       
103       public static void main(String[] args){
104           MyOrderArray arr = new MyOrderArray();
105           arr.insert(15);
106           arr.insert(57);
107           arr.insert(49);
108           
109           arr.display();
110       }
111  }
112  
113 结果：
114 {15 49 57}