【大数据】学习笔记 1 Java SE 第10章基础API与常见算法 10.4 数组工具类

秒速五厘米 2024-03-22 12:17 17阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第10章 基础API与常见算法
             *   *  10.4 数组工具类
                 *   *  10.4.1 java.util.Arrays类
                     *  10.4.2 数组的算法升华

![在这里插入图片描述][3288fbaa8e97452f8bbbed622676b11b.png_pic_center]

#### 1 Java SE ####

##### 第10章 基础API与常见算法 #####

###### 10.4 数组工具类 ######

###### 10.4.1 java.util.Arrays类 ######

java.util.Arrays数组工具类，提供了很多静态方法来对数组进行操作，而且如下每一个方法都有各种重载形式，以下只列出int\[\]和Object\[\]类型的，其他类型的数组依次类推：

*  数组元素拼接
    
     *  static String toString(int\[\] a) ：字符串表示形式由数组的元素列表组成，括在方括号（“\[\]”）中。相邻元素用字符 “, “（逗号加空格）分隔。形式为：\[元素1，元素2，元素3。。。\]  
        static String toString(Object\[\] a) ：字符串表示形式由数组的元素列表组成，括在方括号（”\[\]”）中。相邻元素用字符 ", "（逗号加空格）分隔。元素将自动调用自己从Object继承的toString方法将对象转为字符串进行拼接，如果没有重写，则返回类型@hash值，如果重写则按重写返回的字符串进行拼接。
 *  数组排序
    
     *  static void sort(int\[\] a) ：将a数组按照从小到大进行排序
     *  static void sort(int\[\] a, int fromIndex, int toIndex) ：将a数组的\[fromIndex, toIndex)部分按照升序排列
     *  static void sort(Object\[\] a) ：根据元素的自然顺序对指定对象数组按升序进行排序。
     *  static <T> void sort(T\[\] a, Comparator<? super T> c) ：根据指定比较器产生的顺序对指定对象数组进行排序。
 *  数组元素的二分查找
    
     *  static int binarySearch(int\[\] a, int key)
     *  static int binarySearch(Object\[\] a, Object key) ：要求数组有序，在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数
 *  数组的复制
    
     *  static int\[\] copyOf(int\[\] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组
     *  static <T> T\[\] copyOf(T\[\] original,int newLength)：根据original原数组复制一个长度为newLength的新数组，并返回新数组
     *  static int\[\] copyOfRange(int\[\] original, int from, int to) ：复制original原数组的\[from,to)构成新数组，并返回新数组
     *  static <T> T\[\] copyOfRange(T\[\] original,int from,int to)：复制original原数组的\[from,to)构成新数组，并返回新数组
 *  比较两耳数组是否相等
    
     *  static boolean equals(int\[\] a, int\[\] a2) ：比较两个数组的长度、元素是否完全相同
     *  static boolean equals(Object\[\] a,Object\[\] a2)：比较两个数组的长度、元素是否完全相同
 *  填充数组
    
     *  static void fill(int\[\] a, int val) ：用val值填充整个a数组
     *  static void fill(Object\[\] a,Object val)：用val对象填充整个a数组
     *  static void fill(int\[\] a, int fromIndex, int toIndex, int val)：将a数组\[fromIndex,toIndex)部分填充为val值
     *  static void fill(Object\[\] a, int fromIndex, int toIndex, Object val) ：将a数组\[fromIndex,toIndex)部分填充为val对象

package com.dingjiaxiong.arrays;
    
    import org.junit.Test;
    
    import java.text.Collator;
    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Locale;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: com.dingjiaxiong.arrays.TestArrays
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 16:59
     */
    
    public class TestArrays {
        
        @Test
        public void test01() {
        
            int[] arr = {
        1, 2, 3, 4, 5};
            System.out.println(Arrays.toString(arr));
    
            Student[] students = new Student[3];
            students[0] = new Student("张三", 96);
            students[1] = new Student("李四", 85);
            students[2] = new Student("王五", 98);
            System.out.println(Arrays.toString(students));
        }
    
        @Test
        public void test02() {
        
            int[] arr = {
        3, 2, 5, 1, 6};
            System.out.println("排序前" + Arrays.toString(arr));
            Arrays.sort(arr);
            System.out.println("排序后" + Arrays.toString(arr));
    
            Student[] students = new Student[3];
            students[0] = new Student("张三", 96);
            students[1] = new Student("李四", 85);
            students[2] = new Student("王五", 98);
    
            System.out.println(Arrays.toString(students));
            Arrays.sort(students);
            System.out.println(Arrays.toString(students));
            Arrays.sort(students, new Comparator() {
        
                @Override
                public int compare(Object o1, Object o2) {
        
                    return Collator.getInstance(Locale.CHINA).compare(((Student) o1).getName(), ((Student) o2).getName());
                }
            });
            System.out.println(Arrays.toString(students));
        }
    
        @Test
        public void test03() {
        
            int[] arr1 = {
        1, 2, 3, 4, 5};
            int[] arr2 = {
        1, 2, 3, 4, 5};
            System.out.println(Arrays.equals(arr1, arr2));
        }
    
        @Test
        public void test04() {
        
            int[] arr1 = {
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
            int[] arr2 = Arrays.copyOf(arr1, 5);
            int[] arr3 = Arrays.copyOfRange(arr1, 3, 8);
            System.out.println(Arrays.toString(arr2));
            System.out.println(Arrays.toString(arr3));
    
            Arrays.fill(arr1, 5, 9, 3);
            System.out.println(Arrays.toString(arr1));
        }
    
    }

package com.dingjiaxiong.arrays;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Student
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 16:59
     */
    
    public class Student implements Comparable {
        
        private String name;
        private int score;
    
        public Student(String name, int score) {
        
            this.name = name;
            this.score = score;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getScore() {
        
            return score;
        }
    
        public void setScore(int score) {
        
            this.score = score;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", score=" + score +
                    '}';
        }
    
        @Override
        public int compareTo(Object o) {
        
            return this.score - ((Student) o).score;
        }
    }

![在这里插入图片描述][d918c5c09a5c4334a69ccbadea717315.png_pic_center]

###### 10.4.2 数组的算法升华 ######

【1】数组的扩容

（1）至于新数组的长度定义多少合适，看实际情况，如果新增的元素个数确定，那么可以增加指定长度，如果新增元素个数不确定，那么可以扩容为原来的1.5倍、2倍等

（2）数组扩容太多会造成浪费，太少会导致频繁扩容，效率低下

package com.dingjiaxiong.arrays;
    
    import org.junit.Test;
    
    import java.util.Arrays;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestArrayExpand
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:01
     */
    
    public class TestArrayExpand {
        
        @Test
        public void test01() {
        
            int[] arr = {
        1, 2, 3, 4, 5};
            arr = Arrays.copyOf(arr, arr.length + 1);
            System.out.println(Arrays.toString(arr));
        }
    
        @Test
        public void test02() {
        
            int[] arr = {
        1, 2, 3, 4, 5};
    //        arr = Arrays.copyOf(arr, (int)(arr.length*1.5));
            arr = Arrays.copyOf(arr, arr.length + (arr.length >> 1));
            System.out.println(Arrays.toString(arr));
        }
    
        @Test
        public void test03() {
        
            int[] arr = {
        1, 2, 3, 4, 5};
            arr = Arrays.copyOf(arr, arr.length << 1);
            System.out.println(Arrays.toString(arr));
        }
    }

![在这里插入图片描述][9e4a5e0bd2c149a08b968f4405238a3e.png_pic_center]

【2】删除数组\[index\]位置的元素

package com.dingjiaxiong.arrays;
    
    import org.junit.Test;
    
    import java.util.Arrays;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestArrayRemove
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:02
     */
    
    public class TestArrayRemove {
        
        @Test
        public void test01() {
        
            String[] strings = {
        "hello", "java", "world", "atguigu", "chai"};
            int total = strings.length;
    
            //删除[0]位置元素
            int index = 0;
            System.arraycopy(strings, index + 1, strings, index, total - index - 1);
            strings[--total] = null;
            System.out.println(Arrays.toString(strings));
    
            //删除[2]位置元素
            index = 3;
            System.arraycopy(strings, index + 1, strings, index, total - index - 1);
            ;
            strings[--total] = null;
            System.out.println(Arrays.toString(strings));
        }
    }

![在这里插入图片描述][c97817c459504d3584c78f522f30d6e0.png_pic_center]

【3】数组\[index\]位置插入新元素

package com.dingjiaxiong.arrays;
    
    import org.junit.Test;
    
    import java.util.Arrays;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestArrayInsert
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:03
     */
    
    public class TestArrayInsert {
        
        @Test
        public void test01() {
        
            String[] strings = {
        "hello", "java", "world", null, null};
            int total = 3;
            //在[0]位置插入"haha"
            int index = 0;
            System.arraycopy(strings, index, strings, index + 1, total - index);
            total++;
            strings[index] = "haha";
            System.out.println(Arrays.toString(strings));
        }
    }

![在这里插入图片描述][1db5e9e7a2324076afdf5bbb8daff921.png_pic_center]

[3288fbaa8e97452f8bbbed622676b11b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9ad752d577304841be1634d7bbc6e57e.png
[d918c5c09a5c4334a69ccbadea717315.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/0fc2cea6c96c484d818437af04ad5755.png
[9e4a5e0bd2c149a08b968f4405238a3e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/615c61719bb74bdb9d1a5e5d4590cb7b.png
[c97817c459504d3584c78f522f30d6e0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/fe39c8550aa641a79ee16df6e3f463ae.png
[1db5e9e7a2324076afdf5bbb8daff921.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/dad7268d130d4c948d60af578f34f87f.png