java-数组

1）数组的初始化

 1.一维数组.三种

int[] array={1,2,3,4,5};

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

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

2.二维数组.三种

int[][] array=new int[][]{{1,2},{1,2},{1,2}}; 

int[][] array1=new int[3][];
        array1[0]=new int[]{1,2};
        array1[1]=new int[]{1,2};
        array1[2]=new int[]{1,2};

int[][] array3=new int[3][2];

3)数组的克隆

 1.int[] array1=new int[]{1,2};
   int[] array2=array1.clone;
   //java中的浅拷贝，只拷贝了引用
 2.int[] array3=Arrays.copyOf(array1,array.length);
   //调用的其实是方法3的函数对其中的参数进min(source.length,                             用户要拷贝的长度)
 3.int[] array4=new int[array1.length];
 System.arraycopy(array1,0,array4,0,array1.length);
 //参数1是source数组，参2是source的起始点，参3是dest数组，参4是dest数组的起始点，参5是用户指定要拷贝的长度，这个方法可用于数组的缩容可扩容

4.数组的相关操作

    1.比较数组
       System.out.println(array1==array2);//ture/false
       System.out.ptintln(Array.equal(array1,array2));
    2.排序
       Array.sort(array2);//默认由小到大
    3.找元素下标
       int index=Arrays.brinarySearch(array2,12);
    4.数组填充
       Array.fill(array,100);//把array中的元素都换成100
    5.数组的遍历输出
    一维数组
    for(int val:array1)
    {
        System.out.println(val);
    }
    二维数组
    for(int [] arr:array2)
        for(int val:arr)
        {
           System.out.println(val); 
        }

5.数组大小的计算（ 8字节对齐）

      //数组的长度都统一为4字节存储
      以int[] array={1,2,3}为例
      类的大小：  8字节
      数组的长度：4字节  第一个元素：4字节
      第二个元素：4字节  第三个字节：4字节        toll:24字节

      以long[] array={1,2,3}为例
      类的大小： 8字节
      数组的长度：4字节 ******（不够第一个元素补空位）
      第二个元素：8字节 
      第三个字节：8字节                       toll:40字节

1：删除数组中的56

int[] array5=new int[]{12,4,56,7,56,21,56,56,89,62,41};
System.out.println("前："+Arrays.toString(array5));
    int count=0;//用count来记录删除的个数
    for(int i=0;i<array5.length;i++)
    {

        if(56==array5[i])
        {
            count++;
            System.arraycopy(array5, i+1, array5, i, array5.length-i-count);//将56后的元素复制到array并覆盖56
            i--;
        }

    }
    array5=Arrays.copyOf(array5,array5.length-count);
    System.out.println("删除后："+Arrays.toString(array5));//删除后给数组缩容

2.构造一个随机数组，并去重


int[] array1=new int[100];//构造随机数组
        for(int k=0;k<array1.length;k++)
        {   
            Random r=new Random();
            int  data=r.nextInt(100);
            array1[k]=data;
        }
        System.out.println("去重前："+Arrays.toString(array1));
        int count=0,i=0,j=1;
        for( i=0;i<array1.length;i++)
        {
           for( j=i+1;j<array1.length;j++)
           {
               if(array1[i]==array1[j])
               {
                   count++;
                   System.arraycopy(array1, j+1, array1, j, array1.length-j-1);
                   array1=Arrays.copyOf(array1,array1.length-1);//给数组的长度减一
                   //System.out.println("去重后："+Arrays.toString(array1));
                   j--;//每次删除完之后要从当前位置开始比较
               }

           }

        }
        System.out.println(Arrays.toString(array1));

3：能被5整除的数前加0

int[] array=new int[100];
        for(int i=0;i<array.length;i++)
        {

             Random r=new Random();
             int data=r.nextInt(100);
             array[i]=data;
        }
        System.out.println("加0前："+Arrays.toString(array));
        int count=0;
        for(int i=0;i<array.length;i++)
        {
            if(array[i]%5==0)
            {
                int j;
                count++;
                array=Arrays.copyOf(array, array.length+1);
                System.arraycopy(array, i, array, i+1, array.length-1-i);
                array[i]=0;
                i=i+1;
            }
        }

        System.out.println("加0后："+Arrays.toString(array));

猜你喜欢