In this way, the original array will not be destroyed In addition, because the array is a reference type, When returning, only the first address of the array is returned to the function caller , The contents of the array were not copied , So as to be more efficient

Program development is not from scratch, but to stand on the shoulders of giants For example, in the process of writing many programs, we don't have to implement all the details by ourselves. There are already a large number of standard libraries (code provided by JDK) and a large number of third-party libraries (code provided by other organizations) for us to use directly These codes are put in "packages" one by one. There are thousands of "packages" we can use

(2) Java Provided in java.util.Arrays package , It contains some common methods of manipulating arrays

toString(int[] a): output the integer array of parameters as a string, and the return value is static String

toString(float[] a): output the floating-point array of parameters in the form of string, and the return value is static String

...... Arrays of other data types, and so on

import java.util.Arrays
public class Test { 
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5,6}; 
       String newArr = Arrays.toString(arr); 
       System.out.println(newArr);
    }
}

Compile and run the code, and the output is as follows:

[1,2,3,4,5,6]

In fact, we can also simulate the implementation of toString(int[] a):

public class Test{
       public static String myToString(int[] array){
        if(array == null){
            return null;
        }//Note that if a null pointer is passed
        String str = "[";
        for(int i = 0; i < array.length; i++){
            str = str + array[i];
            if(i != array.length - 1){
                str = str +",";// Except for the last element, all other elements should be followed by ","
            }
        }
        str = str + "]";
        return str;
    }
    public static void main6(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        String ret = myToString(array);
        System.out.println(ret);
    }
}

2. Copy of array

(1) Method 1:

The method copy. In the Arrays class Of (int [] original, int newlength), the return value is static int []. This method is for integer Arrays and can copy Arrays:

(arrays of other data types can be modified based on the above, such as floating-point array copy.Of(float[] original,int newlength), and the return value is static float []...)

import java.util.Arrays
public class Test{
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 5, 6};
        int[] ret = Arrays.copyOf(array,array.length*2);
  
        System.out.println(Arrays,toString(ret));
    }
}

Compile and run the program, and the output is as follows:

[1,2,3,4,5,6,0,0,0,0,0,0] 

In fact, you can also limit the copy of the range. This requires the method copyOfRange(int[] original,int from,int to)

① original: source array

② from: where to start copying

③ to: end copy location

Note that the range is [from, to], closed on the left and open on the right

import java.util.Arrays
public class Test{
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 5, 6};
        int[] ret = Arrays.copyOfRange(array,1,3);
  
        System.out.println(Arrays,toString(ret));
    }
}

Compile and run the code, and the output is as follows:

[2,3] 

(2) Method 2:

Use the for loop to copy the elements in the array one by one

import java.util.Arrays;
public class Test{
    public static int[] myCopy(int[] array,int newlength){
         int[] copy = new int[newlength];
         for(int i = 0; i < newlength; i++){
             copy[i] = array[i];
         }
         return copy;
    }
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 5};
        int newlength = 3;
        int[] ret = myCopy(array,newlength);
        System.out.println(Arrays.toString(ret));
    }
}

(3) Method 3:

The method arraycopy in the System class (object SRC, int srcpos, object DeST, int destpos, int length); The return value is static void

① src: source array

② srcPos: copy from the source array (subscript)

③ dest: target array

④ destPos: copy to this position of the target array (subscript)

⑤ Length: copy length

import java.util.Arrays
public class Test{
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 5, 6};
        int[] copy = System.arraycopy(array,0,copy,0,array.length);
  
        System.out.println(Arrays,toString(copy));
    }
}

(4) Method 4:

Using method clone():

public class Test{
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 5, 6};
        int[] copy = array.clone();//Generate a copy

        System.out.println(Arrays,toString(copy));
    }
}

All four methods are shallow copies.

Shallow copy: shallow copy only copies the reference of an object, not the object itself. The old and new objects still share the same block of memory

Deep copy: deep copy will create an identical object. The new object and the original object do not share memory. Modifying the new object will not change the original object.

3. Allocate elements for integer arrays

We need to use the method fill(int[] a,int val) in the Arrays class, and the return value is static void

fill(int[] a,int fromIndex,int toIndex,int val), the return value is static void

① a: array to allocate elements

② fromIndex: the location (subscript) at which the allocation starts

③ toIndex: end allocation position (subscript)

④ val: value to assign

Attention range: [fromIndex,toIndex)

public class Test{
    public static void main10(String[] args){
        int[] array = new int[10];
        Arrays.fill(array,2,6,66);//Fill 66 from [2,6) subscript
        System.out.println(Arrays.toString(array));
    }
}

4. Find the specified element in the integer array (binary search)

Unlike C language, java is very simple to implement binary search. It only needs to use the method binarySearch(int[] a,int key) in the Arrays class, and the return value is static int

public class Test{
public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        System.out.println(Arrays.binarySearch(array,9));
    }
}

Compile and run the code, and the output is as follows:

-7

Why -7? At this time, we will look at the source code to realize it

IV. two dimensional array

1. Basic grammar