Java 数组学习之练题篇

                

 

 

目录

1.改变原有数组元素的值

2.创建的数组，并且赋初始值

3.两数之和

4.冒泡排序

5.数组是否有序

6.二分查找 

7.数组的拷贝

8.数组转字符串 

---

1.改变原有数组元素的值

实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6} 

有两种方法，实际上就是遍历数组的两种方法。

public class TestDemo01 {

    public static void transform(int array1[]) {
        for(int x : array1){
            System.out.print(2*x + " ");
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,3};
        transform(array);
    }
}

public class TestDemo01 {
    public static void transform(int array1[]){
        for (int i = 0; i < array1.length; i++) {
            array1[i]=2*array1[i];
            System.out.print(array1[i]+" ");
        }
    }

    public static void main(String[] args) {
        int[] array = {1,2,3};
        transform(array);
    }
}

---

2.创建的数组，并且赋初始值

创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100

定义一个数组，然后用for循环来控制输出 

public class TestDemo01 {
public static void main(String[] args) {
    int [] array1 = new int[100];
    for (int i = 1; i <= array1.length; i++) {
        System.out.print(i+" ");
    }
}
}

---

 

3.两数之和

这道题是这样要求的 示例1是这样的

我刚开始想的是这样的

在我看了别人写的代码后，发现我没有考虑的一种情况是，如果需要输出的这两个数组元素不是连续的呢，这样就会出错

 下面看一下正确的

 

import java.util.Arrays;


public class TestDemo01 {

    public static int[] TwoSum(int[] nums,int target){
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {
                if((i != j)&&(nums[i]+nums[j] == target)){
                    return new int[] {i,j};
                }

            }
        }
        return new int[] {0,0};
    }
public static void main(String[] args) {
    int[] arr1 = {7,1,2,15};
    int target = 9;
    System.out.println(Arrays.toString(TwoSum(arr1, target)));
}
}

---

 

4.冒泡排序

给定一个整型数组, 实现冒泡排序(升序排序)

 先看一下冒泡排序的原理（就是两两比较，大的放后面）

import java.util.Arrays;
public class TestDemo01 {
public static void ArraySorting(int[] array1){
    //i控制趟数
    for (int i = 0; i < array1.length-1; i++) {
        //j每一趟都从0开始
        for (int j = 0; j < array1.length-1-i; j++) {
            if(array1[j]>array1[j+1]){
                int tmp = array1[j+1];
                array1[j+1] = array1[j];
                array1[j] = tmp;
            }
        }
    }
}
public static void main(String[] args) {
    //冒泡排序
    int [] arr = {3,5,10,7,6};
    ArraySorting(arr);
    System.out.println(Arrays.toString(arr));
}
}

---

 

 5.数组是否有序

给定一个整型数组, 判定数组是否有序（递增）

这个题比较简单，判断一下数组相邻两位大小关系就可以了，

import java.util.Arrays;

public class TestDemo01 {

    public static boolean order(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            if(array[i]>array[i+1]) {
                return false;
            }
            }
        return true;
    }

public static void main(String[] args) {
    int[] array = {1,9,4,2,6};

    System.out.println(order(array));
}
}

---

 

 6.二分查找 

给定一个有序整型数组, 实现二分查找

 这里注意循环结束的条件，如果left比right大了，就要结束循环

import java.util.Arrays;


public class TestDemo01 {
    public static int binarySearch(int[] array,int key){
        int left = 0;
        int right = array.length-1;
        while(left <= right){
            int mid = (left+right)/2;
            if(array[mid] == key){
                return mid;
            }else if(array[mid] < key){
                left = mid+1;
            }else {
                right = mid-1;
            }
        }
        return -1;
    }
public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
    int index = binarySearch(array,3);
    System.out.println(index);
}
}

这样就可以把要找的数字下标找到，但是在java中为我们提供了一个非常简单方法，那就是Arrays.binarySearch的类，可以很方便的找到，这个数字然后返回下标

import java.util.Arrays;

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

---

 

 7.数组的拷贝

实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组.

 这个题比较简单，在循环里面 把目标数组赋值给要拷贝的数组，然后返回这个拷贝好的数组就可以了

import java.util.Arrays;

public class TestDemo01 {
public static int[] copyOf(int[] array1,int[] array2) {
    for (int i = 0; i < array1.length; i++) {
            array2[i] = array1[i];
        }
    return array2;
}
public static void main(String[] args) {
    int[] array1 = {4,5,6,7,2,3};
    int[] array2 = new int[array1.length];
    System.out.println("拷贝前");
    System.out.println(Arrays.toString(array1));
    System.out.println(Arrays.toString(array2));
    System.out.println("拷贝后");
    System.out.println(Arrays.toString(array1));
    System.out.println(Arrays.toString(copyOf(array1,array2)));
}
}

在java中，也提供了一个拷贝数组的类，叫做 Arrays.copyof 

接收的数组 =  Arrays.copyof(要拷贝的数组，要拷贝数组的长度) 

import java.util.Arrays;


public class TestDemo01 {
    public static void main(String[] args) {
        int[] array1 = {4,5,6,7,2,3};
       int[] array2 = Arrays.copyOf(array1,array1.length);
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}

---

8.数组转字符串 

实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.

这个题没啥分析的，直接按格式输出，注意那个逗号的位置。

import java.util.Arrays;

public class TestDemo01 {
    public static String toString(int[] array1){
        String ret = "[";
        for (int i = 0; i < array1.length; i++) {
            ret += array1[i];
            if(i != array1.length-1){
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }
public static void main(String[] args) {
    //实现一个方法 toString, 把一个整型数组转换成字符串.
    //例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.
    int[] array1 = {1,2,3};

    System.out.println( toString(array1));
}
}

---