数组

java的数组与c++的不同
java的数组需要在堆中申请内存

int[] a = new int[10];

一维数组与Arrays

Arrays是java的一个类，里面的函数能够对数组进行处理，一共有以下几个函数

toString

String toString (type[] a)
作用:把a数组中的全部元素转换成为字符串，中间用“，”隔开

代码实现

import java.util.*;
public class singlearray
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int[] a = new int[10];
        int k;
        k=in.nextInt();
        for(int i=0;i<k;i++)a[i]=in.nextInt();
        String b=Arrays.toString(a);
        System.out.printf(b);
        in.close();
    }
}

输入:
5
1 2 3 4 5
输出:
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

copyOf

type copyOf(type[] a,int lenth)
作用:拷贝a数组的前lenth个元素，创建一个新的数组
type copyOf(type[] a,int star,int end)
作用:拷贝a数组的下标为star到坐标end的元素作为新数组，返回一个数组元素。

代码实现

import java.util.*;
public class singlearray
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int[] a = new int[10];
        int k;
        k=in.nextInt();
        for(int i=0;i<k;i++)a[i]=in.nextInt();
        int[] b=Arrays.copyOf(a,4);
        String s = Arrays.toString(b);
        System.out.printf(s);
        in.close();
    }
}

输入：
5
1 2 3 4 5
输出：
[1, 2, 3, 4]

sort

void sort(type[] a)
采用快速排序对a数组进行从小到大的排序，时间复杂度为nlgn

代码实现

import java.util.*;
public class singlearray
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int[] a = new int[10];
        int k;
        k=in.nextInt();
        for(int i=0;i<k;i++)a[i]=in.nextInt();
        Arrays.sort(a);
        String s = Arrays.toString(a);
        System.out.printf(s);
        in.close();
    }
}

输入:
10
10 9 8 7 6 5 4 2 1 3
输出:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

binarySerach

int binarySerach(type[] a,int start,int end,type v)
采用二分查到的形式查询值v，通常需要先对a数组进行排序，如果存在v，则返回该下标，否则返回负数值。

代码实现

import java.util.*;
public class singlearray
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int[] a = new int[10];
        int k = in.nextInt();
        for(int i=0;i<10;i++)a[i]=10-i;
        int pos = Arrays.binarySearch(a,0,10,k);
        System.out.printf("%d",pos);
        in.close();
    }
}

输入:
6
0
输出:
4
-1

fill

void fill(type[] a,type v)
作用:将数组所有数据元素设置为v，与c++相同

代码实现

import java.util.*;
public class singlearray
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int[] a = new int[10];
        Arrays.fill(a,10);
        String s = Arrays.toString(a);
        System.out.printf(s);
        in.close();
    }
}

输出：
[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]

equals

boolean equals(type[] a,type[] b)
作用:如果两个数组的大小相同并且下标相同对应的元素相等，则返回true，否则，返回false；

代码实现

 import java.util.*;
public class singlearray
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int[] a = new int[10];
        int[] b= new int[10];
        Arrays.fill(a,10);
        Arrays.fill(b,10);
        System.out.print(Arrays.equals(a, b));
        in.close();
    }
}

输出:
true

二维数组

java的二维数组可以有不规则形式，这样避免了浪费内存的情况。

声明与初始化

声明

int[][] arr;
与一维数组一样，在未初始化之前，无法使用这个数组

初始化

arr = new int[10][10];

不规则数组

java中不存在多维数组，实际上就是一维数组中的一个元素也是一个数组。
所以每个单独的元素是一个单独的数组，这样每个元素的数组大小就能不一样了。

代码实现

import java.util.*;
public class singlearray
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int[][] arr =new int[6][];
        for(int i=0;i<6;i++)
        arr[i]=new int[i+1];
        for(int i=0;i<6;i++)
        {
            for(int j=0;j<arr[i].length;j++)
            {
                arr[i][j]=j;
            }
        }
        System.out.print(Arrays.deepToString(arr));
        in.close();
    }
}

输出:
[[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4, 5]]