Java复习笔记（七）数组加强

数组

一、取出一个数组的最大值

使用for()循环遍历数组

public static int getMax(int[] arr)
    {
        //定义变量记录较大的值，初始化为数组中的任意一个元素。
        int max = arr[0];
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>max)
                max = arr[x];
        }
        return max;
    }

二、对数组进行排序

1.快速排序

public static void selectSort(int[] arr)
    {
        for(int i = 0; i < arr.length - 1; i++)
        {
            for(int j = i + 1; j < arr.length; j++)
            {
                if(arr[i] > arr[j])
                {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

2.冒泡排序

public static void bubbleSort(int[] arr)
    {
        for(int i = 0; i < arr.length - 1; i++)
        {
            for(int j = 0; j < arr.length - i - 1; j++)
            {
                if(arr[j] > arr[j+1])
                {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

三、二维数组

二维数组的实质就是存储是一维数组的数组。

1.定义二维数组：

数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];

2.二维数组的初始化方式：

动态初始化:

    数据类型[][] 变量名 = new 数据类型[长度1][长度2];

静态初始化：

    数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}

示例代码：

public class Mian {
    public static void main(String[] args)
    {
        int [][] a = new int[][]{ {23,4,5},{2},{4,5,78,56,90} };
        printArr2( a );
        System.out.println();
        System.out.println("累加和是： "+getSum(a) );
        System.out.println("统计元素个数： "+getDataCount(a) );
        System.out.println("Hello World!");
    }
    // 定义一个遍历二维数组的功能函数
    public static void printArr( int [][] a ){
        for ( int i = 0 ; i < a.length ; i++ )
        {
            for ( int j = 0 ; j < a[i].length ; j++ )
            {
                System.out.print( a[i][j]+" ," );
            }
        }

    }
    // 定义一个函数计算二维数组中的元素的累加和
    public static long getSum( int [][] a ){
        long sum = 0L;//  定义一个结果变量
        for ( int i = 0 ; i < a.length ; i++ )
        {
            for ( int j = 0 ; j < a[i].length ; j++ )
            {
                sum+=a[i][j];
            }
        }
        return sum;
    }

    // 统计二维数组中元素的个数
    public static int getDataCount( int [][] a ){
        int  count = 0;// 记录元素个数
        for ( int i = 0 ; i < a.length ; i++ )
        {
            for ( int j = 0 ; j < a[i].length ; j++ )
            {
                count++;
            }
        }
        return count;
    }
}

四、Java8 增强工具类 Arrays

1.binarySearch（）:

查找数组中为 key 的 下标 ：binarySearch 二分法查找，数组必须有序，且存在此数组中，否则返回负数下标

Arrays.binarySearch(Object[] a,Object key):int
Arrays.binarySearch(Object[] a, int fromIndex, int toIndex,Object key):int

2.copyOf（）：

copyOf：
复制出新的数组，复制长度由 newLength 决定,长度可大于被复制数组的长度

copyOf(T[] original, int newLength):T[]

copyOfRange：
复制指定下标范围内的值

copyOfRange(T[] original, int from, int to):T[]

3.sort（）：

默认进行升序排序，可自定义排序

sort(Object[] a):void
sort(Object[] a, int fromIndex, int toIndex):void
sort(T[] a, Comparator<? super T> c):void
sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c):void

4.toString（）：

将数组元素转成String输出

toString(Object[] a):String

deepToString：
将二维数组元素转成String输出

deepToString(Object[] a):String

5.equals（）：

比较一维数组内容是否相等

equals(Object[] a, Object[] a2)

deepEquals：
比较二维数组内容是否相等

deepEquals(Object[] a1, Object[] a2)

6.fill（）：

将一个数组全部置为 val ，或在下标范围内将数组置为 val

fill(Object[] a, Object val):void
fill(Object[] a, int fromIndex, int toIndex, Object val):void

7.setAll（）：

一个数组全部做表达式操作

setAll(T[] array, IntFunction<? extends T> generator):void

8.stream（）：

将数组转为流式，对array进行流式处理，可用一切流式处理的方法

stream(T[] array)：Stream<T>