【Java SE】数组题目

🥰🥰🥰来都来了，不妨点个关注叭！
👉博客主页：欢迎各位大佬!👈

上期内容讲解数组的知识，本期内容讲解数组有关的题目，学会就赶紧用起来吧！将会对Java中的数组有一个更深刻的了解，一起来看看吧

1. 数组转换字符串

经过分析，应该很快就可以把代码写出来啦~

public static String myToString(int[] array) {
       if(array == null) {
        System.out.println("null");
       }
       String ret = "[";
       for(int i = 0; i < array.length;i++) {
           ret += array[i];
           if(i != array.lenth-1) {
           ret += ",";
       }
   }
   ret += "]";
   return ret;
}
public static void main(String args[]) {
  int[] array = {1,2,3};
  System.out.println(myToString(array));
}

【注意】考虑数组为空的情况
【总结】这就告诉我们，拿到一个问题，我们需要一步一步分析，发现问题，解决问题，不断调试

2. 数组的拷贝

2.1 数组拷贝

上一期内容，我们写了这个代码，array2 = array1，这个是不是就是数组的拷贝呢？

public static void main(String[] args) {
     int[] array1 = {22,43,56,77};
     int[] array2 = array1;
    
     System.out.println(Arrays.toString(array1));
     System.out.println(Arrays.toString(array2));
    }

答案：不是的，我们知道，这两个引用都指向了一个对象，如图，所以不是数组的拷贝，需要有一个数组，指向新的对象，而这个对象存储的值与需拷贝数组的值想的相同

用for循环写的将其一个个拷贝，代码如下：

public static void main(String[] args) {
     int[] array1 = {22,43,56,77};     
     int[] array2 = new int[array.length];
     for(int i = 0; i < array1.length; i++) {
       array2[i] = array1[i];
     }
     System.out.println(Arrays.toString(array1));
     System.out.println(Arrays.toString(array2));
    }

这样才是数组的拷贝

2.2 Arrays的各种函数

接下来进一步介绍Arrays的各种常用函数
例如，数组的拷贝，可以使用

2.2.1 Arrays.copyOf

功能：可进行数组的拷贝，可进行数组的扩容

Arrays.copyOf(数组名称，拷贝长度)

array2 = Arrays.copyOf(array1,array1.length)

同时这个函数还可以扩容

array = Arrays.copyOf(array,2*array.length)

2.2.2 Arrays.copyOfRange

功能：可进行数组的拷贝，有起始位置与终止位置，也可进行数组的扩容

Arrays.copyOfRange(数组名称，起始位置，终止位置)

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

当然，也可以当做扩容用~

2.2.3 Arrays.equals

功能：判断2个数组的值是否相等
Arrays.equals(数组名称1，数组名称2)

public class Test {
    public static void main(String[] args) {
        int[] array1 = {1,2,3};
        int[] array2 = {1,2,3};
        System.out.println(array1.equals(array2));
        //等价于
         System.out.println(array1 == array2);
    }
}

输出为true，这两个数组的每一个值都相等

2.2.4 equals与==的区别

【==】
==比较基本数据类型，比较的是值
==比较引用数组类型，比较的是地址
【equals】
比较地址，同时我们可以自己改写，按照自己的规则进行比较

2.2.5 Arrays.fill

功能：将数组填充为指定的值

Arrays.fill(数组名称，填充的值)

public class Test {
    public static void main(String[] args) {
        int[] array = new int[5]; //array = {0,0,0,0,0} 默认值为0
        System.out.println(Arrays.fill(array,-1));
    }
}

4. 克隆

克隆的含义：产生一个副本

4.1 函数使用

功能：数组的克隆

Arrays.clone()

public class Test {
    public static void main(String[] args) {
       int[] array1 = {1,2,3};
       int[] array2 = array1.clone();
       System.out.println(Arrays.toString(array1));
       System.out.println(Arrays.toString(array2));
       array2[0] = 33;
       System.out.println(Arrays.toString(array1)); //{1,2,3}
       System.out.println(Arrays.toString(array2)); //{33,2,3}    
    }
}

4.2 浅拷贝和深拷贝

浅拷贝和深拷贝的区别
浅拷贝：只是复制了对象的引用地址，两个对象指向同一个地址，修改任意一个值，另一个也会随之改变
深拷贝：将对象的值复制过来，两个对象修改其值，不影响另一个的值

5. 冒泡排序

将一个数组元素从小到大排序

原理：从左到右，两个相邻元素进行比较，每次比较一趟，就会找到序列中最大的一个。这个数就会从序列的最右边冒出来，经过多趟比较后完成从小到大的排序

来看看如何具体实现吧！
这是一趟的结果，以此类推

i控制趟数，j控制一趟需要来两两比较的次数

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

    }

上面代码可以优化，请看下面这张更进一步比较

可以发现，j不是非得比较array.length-1次，第一趟比较晚后，最后一个数已经确定是最大的，所以倒数第二个数不需要和最后一个数比较了，第二趟结束后，倒数第二个数已经确定是第二大的数，所以倒数第三个数不需要和倒数第二个数比较，以此类推，故比较的次数j可以小于array.length-1-i

本期内容到这里结束啦！下期见~继续加油嘿嘿