JDK core API-Manipulate arrays in java

If you have done a lot of java programs, you may be familiar with java Collection classes, such as Vector and ArrayList. You can create a set and add elements to it:

2. List lst =NewArrayList ();
4. Lst. add (New Integer(37 ));

In this special example, an Integer value 37 is used to construct an Integer encapsulation class object, which is then added to the List.

This simple example shows the basics of a set-they are used to manipulate a column of objects, each of which is a class or interface type. Therefore, an ArrayList can contain objects of the Object, String, Float, and Runnable types. The Collection class cannot be used for a list of original data types, such as an integer array.

If you use arrays of the original type in your program, how do you manipulate them? This tip shows you some of the technologies you can use.

The first technology is sorting. The java. util. Arrays class contains a set of class methods for sorting and searching Arrays. For example:

2. ImportJava. util.Arrays;
4. Public ClassArrayDemo1 {
5. Public Static VoidMain (StringArgs []) {
6. IntVec [] = {37, 47, 23,-5, 19, 56 };
7. Arrays. sort (vec );
8. For(IntI = 0; I <vec.Length; I ++ ){
9. System. Out. println (vec [I]);
10. }
11. }
12. }

This demo initializes an integer array and then calls Arrays. sort to sort the array in ascending order.

Similarly, you can perform a binary search on the sorted array:

2. ImportJava. util.Arrays;
4. Public ClassArrayDemo2 {
5. Public Static VoidMain (StringArgs []) {
6. IntVec [] = {-5, 19, 23, 37, 47, 56 };
7. IntSlot = Arrays. binarySearch (vec, 35 );
8. Slot =-(slot + 1 );
9. System. Out. println ("insertion point =" + slot );
10. }
11. }

This program has a subtle concept. If the binary search fails, it will return:

-(Insertion point)-1

This demo calls the search method with parameter 35, and the parameter does not exist in the array. the return value of the method is-4. If this value is added and its negative number is obtained, 3 is obtained, this is the position where 35 should be inserted into the array. In other words, values-5, 19, and 23 occupy 0, 1, and 2 in the array. Therefore, the value 35 should be at the index 3 position, while the values 37, 47, and 56 are postponed. The search method does not actually insert data, but just specifies where to insert data.

In addition to sorting and searching, what can we do for the original array? Another useful technique is to convert an original array to an equivalent array of object types. Each corresponding element uses their encapsulate class. For example, in an encapsulated array, 37 becomes Integer (37 ).

2. ImportJava. util.Arrays;
3. ImportJava. lang. reflect.Array;
5. Public ClassArrayDemo3 {
7. // If input is a single-dimension primitive array,
8. // Return a new array consisting of wrapped elements,
9. // Else just return input argument
11. Public Static ObjectToArray (ObjectVec ){
13. // If null, return
15. If(Vec =Null){
16. ReturnVec;
17. }
19. // If not an array or elements not primitive, return
21. ClassCls = vec. getClass ();
22. If(! Cls. isArray ()){
23. ReturnVec;
24. }
25. If(! Cls. getComponentType (). isPrimitive ()){
26. ReturnVec;
27. }
29. & Nbs