1. class ArrayTools
   
2. {
   
3.         //遍历打印数组中所有元素
   
4.         public static void arrayPrint(int[] arr)
   
5.         {
   
6.                 System.out.print("[");
   
7.                 for(int i=0;i<arr.length;i++)
   
8.                 {
   
9.                         if(i!=arr.length-1)
   
10.                                 System.out.print(arr[i]+",");
    
11.                         else
    
12.                                 System.out.println(arr[i]+"]");
    
13.                 }
    
14.         }
    
15. 
    
16.    //数组两元素值进行交换
    
17.     private static void exchange(int[] arr,int a,int b)
    
18.         {
    
19.                 int temp;
    
20.                 temp=arr[a];
    
21.                 arr[a]=arr[b];
    
22.                 arr[b]=temp;
    
23.         }
    
24.    //获取数组的最大值
    
25.    public static int getMax(int[] arr)
    
26.    {
    
27.            int max=0;
    
28.            for(int i=1;i<arr.length;i++)
    
29.            {
    
30.                    if(arr[max]<arr[i])
    
31.                            exchange(arr,max,i);
    
32.            }
    
33.            return arr[max];
    
34.    }
    
35. 
    
36.    //获取数组的最小值
    
37.     public static int getMin(int[] arr)
    
38.    {
    
39.            int min=0;
    
40.            for(int i=1;i<arr.length;i++)
    
41.            {
    
42.                    if(arr[min]>arr[i])
    
43.                            exchange(arr,min,i);
    
44.            }
    
45.            return arr[min];
    
46.    }
    
47. 
    
48.    //选择排序法，简单来说就是先找出最小值（或最大值），
    
49.    //放在角标为0（或最大角标）的元素下，再找出第二小（或大）的值放在角标为1的元素下，
    
50.    //以此类推，直到找出最大值
    
51.    public static void sort_1(int[] arr)
    
52.    {
    
53.        for(int i=0;i<arr.length-1;i++)
    
54.            {          
    
55.                    for(int j=i+1;j<arr.length;j++)
    
56.                {
    
57.                            if(arr[i]>arr[j])
    
58.                                    exchange(arr,i,j);
    
59.                    }
    
60.            }
    
61.    }
    
62. 
    
63.    //冒泡排序，已知一个数组，如果升序排列，比较相邻两个元素，如果角标小的元素值大，则两者交换，
    
64.    //这样就把最大值放在最末尾，然后再重复上一过程，直到所有元素都排列好。
    
65.    public static void sort_2(int[] arr)
    
66.    {
    
67.            for(int i=0;i<arr.length-1;i++)
    
68.            {
    
69.                    for(int j=0;j<arr.length-i-1;j++)
    
70.                    {
    
71.                            if(arr[j]>arr[j+1])
    
72.                                    exchange(arr,j,j+1);
    
73.                    }
    
74.            }
    
75.    }
    
76. 
    
77.    
    
78.    //折半查找,第一种方法,必须保证数组是有序的
    
79.    public static int halfSearch_1(int[] arr,int key)
    
80.    {
    
81.         int min,max,mid;
    
82.                 min=0;
    
83.                 max=arr.length-1;
    
84.                 mid=(min+max)/2;
    
85. 
    
86.                 while(arr[mid]!=key)
    
87.            {
    
88.            if(key>arr[mid])
    
89.                            min=mid+1;
    
90.                    else if(key<arr[mid])
    
91.                            max=mid-1;
    
92.            mid=(max+min)/2;
    
93.                    if(min>max)
    
94.                            return -1;
    
95.            }
    
96.            return mid;
    
97.    }
    
98. 
    
99.   //折半查找第二种方法，必须保证数组时有序的。
    
100.   public static int halfSearch_2(int[] arr,int key)
     
101.    {
     
102.         int min,max,mid;
     
103.                 min=0;
     
104.                 max=arr.length-1;
     
105. 
     
106.                 while(min<=max)
     
107.            {
     
108.            mid=(min+max)/2;
     
109.                    if(key>arr[mid])
     
110.                            min=mid+1;
     
111.                    else if(key<arr[mid])
     
112.                            max=mid-1;
     
113.                    else
     
114.                            return mid;
     
115.            }
     
116.            return -1;
     
117.    }
     
118. 
     
119.    //在一个有序数组中利用折半查找法，插入元素
     
120.    public static int[] insert(int[] arr,int el)
     
121.         {
     
122.                
     
123.                 int index=halfSearch_1(arr,el);
     
124.                 if(index!=-1)
     
125.                         return insert(arr,index,el);
     
126.                 else
     
127.                 {
     
128.                         int min,max,mid;
     
129.                         min=0;
     
130.                         max=arr.length-1;
     
131.             
     
132.                     while(min<=max)
     
133.                 {
     
134.                mid=(min+max)/2;
     
135.                        if(el>arr[mid])
     
136.                                min=mid+1;
     
137.                        else if(el<arr[mid])
     
138.                                max=mid-1;
     
139.                 }
     
140. 
     
141.             return insert(arr,min,el);
     
142.                 }
     
143. 
     
144.         }
     
145. 
     
146.    //在一个数组中的指定位置插入一个元素，
     
147.         private static int[] insert(int[] arr,int index,int el)
     
148.         {
     
149.           int[] arr2=new int[arr.length+1];
     
150.                   for(int i=0;i<arr2.length;i++)
     
151.                     {
     
152.                            if(i<index)
     
153.                                    arr2[i]=arr[i];
     
154.                            else if(i==index)
     
155.                                    arr2[i]=el;
     
156.                            else
     
157.                                    arr2[i]=arr[i-1];
     
158.                     }
     
159.                         return arr2;
     
160.         }
     
161. }

复制代码

不知代码是否有错，或者有更简体的代码，请各位指正。