001 package com.croftsoft.core.util;
002
003 import java.util.Arrays;
004
005 import com.croftsoft.core.lang.NullArgumentException;
006
007 /*********************************************************************
008 * Array manipulation for Java 1.2+.
009 *
010 * <p>
011 * Java 1.2 compatible.
012 * </p>
013 *
014 * @see
015 * ArrayLib
016 *
017 * @version
018 * 2001-05-25
019 * @since
020 * 2001-05-25
021 * @author
022 * <a href="https://www.croftsoft.com/">David W. Croft</a>
023 *********************************************************************/
024
025 public final class ArrayLib2
026 //////////////////////////////////////////////////////////////////////
027 //////////////////////////////////////////////////////////////////////
028 {
029
030 public static void main ( String [ ] args )
031 //////////////////////////////////////////////////////////////////////
032 {
033 System.out.println ( test ( args ) );
034 }
035
036 public static boolean test ( String [ ] args )
037 //////////////////////////////////////////////////////////////////////
038 {
039 try
040 {
041 String [ ] ARRAY_ABC = new String [ ] { "a", "b", "c" };
042
043 if ( !Arrays.equals ( ARRAY_ABC,
044 insertSorted ( new String [ ] { "a", "c" }, "b", false ) ) )
045 {
046 return false;
047 }
048
049 if ( !Arrays.equals ( new String [ ] { "a", "b", "b", "c" },
050 insertSorted ( ARRAY_ABC, "b", true ) ) )
051 {
052 return false;
053 }
054
055 if ( !Arrays.equals ( ARRAY_ABC,
056 insertSorted ( ARRAY_ABC, "b", false ) ) )
057 {
058 return false;
059 }
060
061 //
062
063 int [ ] ARRAY_123 = new int [ ] { 1, 2, 3 };
064
065 if ( !Arrays.equals ( ARRAY_123,
066 insertSorted ( new int [ ] { 1, 3 }, 2, false ) ) )
067 {
068 return false;
069 }
070
071 if ( !Arrays.equals ( new int [ ] { 1, 2, 2, 3 },
072 insertSorted ( ARRAY_123, 2, true ) ) )
073 {
074 return false;
075 }
076
077 if ( !Arrays.equals ( ARRAY_123,
078 insertSorted ( ARRAY_123, 2, false ) ) )
079 {
080 return false;
081 }
082
083 return true;
084 }
085 catch ( Exception ex )
086 {
087 ex.printStackTrace ( );
088
089 return false;
090 }
091 }
092
093 //////////////////////////////////////////////////////////////////////
094 //////////////////////////////////////////////////////////////////////
095
096 /*********************************************************************
097 * Inserts, in sort order, an integer into a presorted integer array.
098 *
099 * <p>
100 * As this function uses Arrays.binarySearch() and ArrayLib.insert(),
101 * it should be more efficient than growing a sorted array by
102 * appending an element and calling Arrays.sort() each time, especially
103 * as the array grows larger.
104 * </p>
105 *
106 * @see
107 * java.util.Arrays#binarySearch(int[],int)
108 *
109 * @param sortedIntArray
110 *
111 * The array argument must be presorted. If the array was built up
112 * one element at a time using this method, the array will always be
113 * in a sorted state.
114 *
115 * If this parameter is null, a new integer array will be created.
116 *
117 * @param comparable
118 *
119 * The int value to be inserted.
120 *
121 * @param allowDuplicates
122 *
123 * If false, the original array argument may be returned unchanged.
124 *
125 * @return
126 *
127 * Returns a new sorted integer array with integer argument inserted.
128 *********************************************************************/
129 public static int [ ] insertSorted (
130 int [ ] sortedIntArray,
131 int i,
132 boolean allowDuplicates )
133 //////////////////////////////////////////////////////////////////////
134 {
135 if ( sortedIntArray == null )
136 {
137 return new int [ ] { i };
138 }
139
140 int index = Arrays.binarySearch ( sortedIntArray, i );
141
142 if ( index >= 0 )
143 {
144 if ( allowDuplicates )
145 {
146 return ArrayLib.insert ( sortedIntArray, i, index );
147 }
148 else
149 {
150 return sortedIntArray;
151 }
152 }
153
154 return ArrayLib.insert ( sortedIntArray, i, -index - 1 );
155 }
156
157 /*********************************************************************
158 * Inserts, in sort order, a Comparable into a presorted array.
159 *
160 * <p>
161 * As this function uses Arrays.binarySearch(), it should be more
162 * efficient than growing a sorted array by appending an element and
163 * calling Arrays.sort() each time, especially as the array grows
164 * larger.
165 * </p>
166 *
167 * @see
168 * java.util.Arrays#binarySearch(java.lang.Object[],java.lang.Object)
169 *
170 * @param sortedComparableArray
171 *
172 * The array argument must be presorted. If the array was built up
173 * one element at a time using this method, the array will always be
174 * in a sorted state.
175 *
176 * @param comparable
177 *
178 * The Comparable object to be inserted.
179 *
180 * @param allowDuplicates
181 *
182 * If false, the original array argument may be returned unchanged.
183 *
184 * @throws NullArgumentException
185 *
186 * If sortedComparableArray or comparable is null.
187 *
188 * @return
189 *
190 * Returns an array with the same component type as the old array.
191 *********************************************************************/
192 public static Comparable [ ] insertSorted (
193 Comparable [ ] sortedComparableArray,
194 Comparable comparable,
195 boolean allowDuplicates )
196 //////////////////////////////////////////////////////////////////////
197 {
198 NullArgumentException.check ( sortedComparableArray );
199
200 NullArgumentException.check ( comparable );
201
202 int index
203 = Arrays.binarySearch ( sortedComparableArray, comparable );
204
205 if ( index >= 0 )
206 {
207 if ( allowDuplicates )
208 {
209 return ( Comparable [ ] )
210 ArrayLib.insert ( sortedComparableArray, comparable, index );
211 }
212 else
213 {
214 return sortedComparableArray;
215 }
216 }
217
218 return ( Comparable [ ] )
219 ArrayLib.insert ( sortedComparableArray, comparable, -index - 1 );
220 }
221
222 //////////////////////////////////////////////////////////////////////
223 //////////////////////////////////////////////////////////////////////
224
225 private ArrayLib2 ( ) { }
226
227 //////////////////////////////////////////////////////////////////////
228 //////////////////////////////////////////////////////////////////////
229 }