jdk1.8 對數組及arrays類對數組的操作與增強

數組的初始化有兩種方式

• 靜態初始化： 初始化時由程序員顯示置頂每個數組的初始值，由系統決定數組長度。如：

int[] a1 = new int[] {1,2,3,4};

• 動態初始化：初始化時由程序員只指定數組長度，由系統為數組元素分配初始值。如：

 int[] a = new int[5];

 

寫一個類測試一下

package chenlizhi;

import java.util.Arrays;

public class TestArrays {
    public static void main(String[] args) {
        int[] a1 = new int[] {4,3,2,1};
        
        int[] a2 = new int[] {6,5,7,8};
        
        //排序  升序
        Arrays.sort(a1);
        System.out.println("對a1數組進行排序結果為：" + Arrays.toString(a1));
        
        //Arrays.binarySearch(a1, 4) 查找數組中值得下標  前提是必須排序不然不確定  如果有重復的返回第一個 如果沒有這個值得話返回負數
        System.out.println("查找a1數組當中4的值下標為："+Arrays.binarySearch(a1, 4));
        
        
        //Arrays.binarySearch(a1, 1, 4, 4) 查找數組中從1到4下標中有沒有值為3的   如果有返回下標  如果沒有返回負數  前提必須排序
        System.out.println("查找a1數組從下標1開始到下標3結束,查看是否有為3的值" + Arrays.binarySearch(a1, 1, 3, 3));
        
        
        //Arrays.copyOf(a1, 5) 復制數組  a1為被復制的數組  5為新數組的長度 
        int[] a3 = Arrays.copyOf(a1, 5);
        System.out.println("a3數組的值為：" + Arrays.toString(a3));
        
        
        //和上面一樣  a1位被復制的數組  2為a1數組開始下標  3a1為數組結束下標  
        int[] a4 = Arrays.copyOfRange(a1, 2, 3);
        System.out.println("a4數組值為：" + Arrays.toString(a4));
        
        
        //查看兩個數組的length和數組元素是否相同  如果都相同返回true 否則返回false
        System.out.println("查看a1數組和a2數組是否相同 ：" + Arrays.equals(a1, a2));
        
        
        //把a1數組中的值全部換為 1
        Arrays.fill(a1, 1);
        System.out.println("輸出a1數組的值為：" + Arrays.toString(a1));
        
        
        //把a2數組中下標1到下標3的值換為1
        Arrays.fill(a2, 1, 3, 1);
        System.out.println("輸出a2數組的值為:"+ Arrays.toString(a2));
        
        
    }
}

輸出結果為：

對a1數組進行排序結果為：[1, 2, 3, 4]
查找a1數組當中4的值下標為：3
查找a1數組從下標1開始到下標3結束,查看是否有為3的值2
a3數組的值為：[1, 2, 3, 4, 0]
a4數組值為：[3]
查看a1數組和a2數組是否相同 ：false
輸出a1數組的值為：[1, 1, 1, 1]
輸出a2數組的值為:[6, 1, 1, 8]

 還有cpu並行來提供性能  基於jdk 1.8

package platform.county.jiange.web.security;

import java.util.Arrays;
import java.util.function.IntBinaryOperator;
import java.util.function.IntUnaryOperator;
/**
 * jdk8增強arrays類  cpu並行
 * @author Administrator
 *
 */
public class ArraysTest {
    public static void main(String[] args) {
        //cpu並行排序
        int [] a = new int [] {98 , 78 , 67 , 564 , 49 , 34};
        Arrays.parallelSort(a);
        System.out.println(Arrays.toString(a));
        
        //指定數組新的計算結果
        int [] a1 = new int [] {98 , 78 , 67 , 564 , 49 , 34};
        Arrays.parallelPrefix(a1, new IntBinaryOperator() {
            
            @Override
            public int applyAsInt(int left, int right) {
                //left 代表前一個索引  right代表現在的索引
                //類似 98 * 78 , 78 * 67  然后把值重新賦值給數組
                return left * right;
            }
        });
        System.out.println(Arrays.toString(a1));
        
        //給a3數組賦值  使用表達式
        int [] a3 = new int [10] ;
        Arrays.parallelSetAll(a3, new IntUnaryOperator() {
            
            @Override
            public int applyAsInt(int operand) {
                //operand 代表現在正在計算的索引  索引位置 * 5
                return operand * 5;
            }
        });
        System.out.println(Arrays.toString(a3));
    }
}

輸出

[34, 49, 67, 78, 98, 564]
[98, 7644, 512148, 288851472, 1268820240, 190215200]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]