Java第六项——数组

public class shuZu {
    public static void main(String[] args) {
        int[]a;
        //1、
        // 声明了一个数组变量[]表示该变量是一个数组
        //int 表示数组里的每一个元素都是一个整数
        //a 是变量名
        // 但是，仅仅是这一句声明，不会创建数组
        int a1[];//这也可以，无所谓。两者是一样的。


        //2、
        // 创建数组
        // 创建数组的时候，要指明数组的长度。
        //new int[5]
        //引用概念：
        //如果变量代表一个数组，比如a,我们把a叫做引用
        //与基本类型不同
        //int c = 5; 这叫给c赋值为5
        //声明一个引用 int[] a;
        //a = new int[5];
        //让a这个引用，指向数组

        //创建一个长度是5的数组，并且使用引用a指向该数组
        a = new int[5];

        int b[]  = new int[5]; //声明的同时，指向一个数组
        //3、访问数组
        a[0]= 1;  //下标0，代表数组里的第一个数
        a[1]= 2;
        a[2]= 3;
        a[3]= 4;
        a[4]= 5;




        //3、数组长度
        //.length
        // .length属性用于访问一个数组的长度
        //数组访问下标范围是0到长度-1
        //一旦超过这个范围,就会产生数组下标越界异常

        //练习
        int[] c =new int[5];
        for (int i=0;i<c.length;i++){
            c[i] = (int)(Math.random()*100); //会得到一个0-1之间的随机浮点数，*100，强转为整型
            System.out.println("第"+i+"个的随机数为:"+c[i]);
        }

    }
}

二、数组的赋值

public class shuZu {
    public static void main(String[] args) {
        int[] a = new int[5];
             //分配了长度是5的数组，但是没有赋值
             //没有赋值，那么就会使用默认值
             //作为int类型的数组，默认值是0
        System.out.println(a[0]);
        //进行赋值
        a[0]=105;
        a[1]=104;
        a[2]=103;
        a[3]=102;
        a[4]=101;

        //分配空间的同时 赋值给数组。
        //写法一
        int[] a1 = new int[]{100,125,316,4826};
        //写法二
        int[] a2 = {100,125,316,4826};
        //写法三：同时分配空间，和指定内容
        //在这个例子里，长度是3，内容是5个，产生矛盾了
        //所以如果指定了数组的内容，就不能同时设置数组的长度
        int[] c = new int[3]{100,102,444,836,3236};
        int[] c1 = new int[4]{100,125,316,4826};
        //就算同大小，也不可以。要么设置长度，要么设置内容，不可以同步进行。
    }
}

三、增强型for循环

增强型for循环在遍历一个数组的时候会更加快捷

增强型for循环只能用来取值，却不能用来修改数组里的值

public class shuZu {
    public static void main(String[] args) {
    //增强型for循环
        int values [] = new int[]{19,62,68,54,36,9};
        for (int each : values){
            System.out.println(each);
        }
    }
}

values 数组名

定义不变，主要在for的括号里改变了。写出  int each：values 对每一个值values遍历，存储在each里

练习：用增强型for循环找最大值

public class shuZu {
    public static void main(String[] args) {
    //增强型for循环
        int values [] = new int[]{19,62,68,54,36,9};
        int present = 0;
        for (int each : values){
            if (each > present)
                present = each;

        } System.out.println(present);
    }
}

四、复制数组

数组的长度是不可变的，一旦分配好空间，是多长，就多长，不能增加也不能减少

把一个数组的值，复制到另一个数组中

System.arraycopy(src, srcPos, dest, destPos, length)
        src: 源数组
        srcPos: 从源数组复制数据的起始位置
        dest: 目标数组
        destPos: 复制到目标数组的起始位置
        length: 复制的长度

public class shuZu {
    public static void main(String[] args) {

        int values [] = new int[]{19,62,68,54,36,9};
        int copyShuZu [] = new int[3];
//普通
        for(int i = 0 ; i < copyShuZu.length; i++)
        {
            copyShuZu[i] = values[i];
            System.out.println(copyShuZu[i]);
        }
//复制数组 arraycopy()
        System.arraycopy(values,0,copyShuZu,0,3);
        for(int i = 0 ; i < copyShuZu.length; i++){
            System.out.println(copyShuZu[i]);
        }

        }
}

 练习：

首先准备两个数组，他俩的长度是5-10之间的随机数，并使用随机数初始化这两个数组
(向数组填充随机数的办法，参考这里)

然后准备第三个数组，第三个数组的长度是前两个的和
通过System.arraycopy 把前两个数组合并到第三个数组中

import java.util.Random;
public class shuZu {
    public static void main(String[] args) {
        int arr[] = new int[(int)(Math.random()*5+5)];
        int brr[] = new int[(int)(Math.random()*5+5)];
        //因为Math.random（）是随机0~1之间的。乘以五就变成了0~5，再+5就是5~10了
        for (int i= 0; i < arr.length; i++){
            arr[i] = (int)(Math.random()*10);
            System.out.println(arr[i]);

        }
        System.out.println("数组brr：");
         for (int j= 0; j < brr.length; j++){
            brr[j] = (int)(Math.random()*10);
             System.out.println(brr[j]);
        }
        System.out.println("数组crr：");
         int sumLength = arr.length + brr.length;
         int crr[] = new int[sumLength];
         System.arraycopy(arr, 0, crr, 0, arr.length);
         System.arraycopy(brr, 0, crr, arr.length, brr.length);
        for (int i = 0; i<crr.length; i++){
         System.out.println(crr[i]);}




        }
}

五、二维数组

这是一个一维数组, 里面的每一个元素，都是一个基本类型int

   int a[] =new int[]{9, 10, 11, 2};

这是一个二维数组，里面的每一个元素，都是一个一维数组
所以二维数组又叫数组的数组

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

import java.util.Random;
public class shuZu {
    public static void main(String[] args) {
      //一维数组
        int a[] =new int[]{9, 10, 11, 2};
        //二维数组
        //
        // 指定内容的同时，分配空间
        int b[][] = new int[][]{
                {1, 2, 3},
                {4, 5, 6}
        };
        int a1[][] = new int[2][3];
        //两行三列//有两个一维数组，每个一维数组的长度是3
        a1[0][1] = 5;//可以直接访问一维数组，因为已经分配了空间

        //只分配了二维数组
        int b1[][] = new int[2][];
        //有两行，列数不知。有两个一维数组，每个一维数组的长度暂未分配
        b1[0]  =new int[3]; //必须事先分配长度，才可以访问
        b1[0][2] = 5;
        System.out.println(b1[0][2]);

        }
}

练习：

定义一个5X5的二维数组。 然后使用随机数填充该二维数组。
找出这个二维数组里，最大的那个值，并打印出其二维坐标

import java.util.Random;
public class shuZu {
    public static void main(String[] args) {
     int a[][] = new int[5][5];//定义5*5的二维数组
        for (int i = 0; i < a.length; i++){
            for (int j = 0; j < a[i].length; j++ ){
                a[i][j]=(int)(Math.random()*100);
                System.out.println(a[i][j]  );
            }
        }//随机数赋值
        int target = 0;
        for (int i = 0; i < a.length; i++){
            for (int j = 0; j < a[i].length; j++ ){
            if (a[i][j] >= target ){
                target =a[i][j];
            }
            }
        }
        System.out.println("最大值为："+target);

        }
}

六、Array

1、copyOfRange

与使用System.arraycopy进行数组复制类似的， Arrays提供了一个copyOfRange方法进行数组复制。
不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。
除此之外，需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的（即取得元素长度）

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
 
        // copyOfRange(int[] original, int from, int to)
        // 第一个参数表示源数组
        // 第二个参数表示开始位置(取得到)
        // 第三个参数表示结束位置(取不到)
        int[] b = Arrays.copyOfRange(a, 0, 3);
 
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
 
    }
}

2、转换字符

如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印

但是Arrays提供了一个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容

import java.util.Arrays;
  
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        String content = Arrays.toString(a);
        System.out.println(content);
  
    }
}

只能用于一维数组，但可以先把数据存放在一维数组中。再操作。

3、排序

在前面章节学习了 选择法排序 和 冒泡法排序，Arrays工具类提供了一个sort方法，只需要一行代码即可完成排序功能。

import java.util.Arrays;
  
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        System.out.println("排序之前 :");
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("排序之后:");
        System.out.println(Arrays.toString(a));
  
    }
}

4、搜索

查询元素出现的位置(搜索某个元素)
需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
 
        Arrays.sort(a);
 
        System.out.println(Arrays.toString(a));
        //使用binarySearch之前，必须先使用sort进行排序
        System.out.println("数字 62出现的位置:"+Arrays.binarySearch(a, 62));
    }
}

5、判断是否相同

比较两个数组的内容是否一样
第二个数组的最后一个元素是8，和第一个数组不一样，所以比较结果是false

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        int b[] = new int[] { 18, 62, 68, 82, 65, 8 };
 
        System.out.println(Arrays.equals(a, b));
    }
}

6、填充

使用同一个值，填充整个数组

import java.util.Arrays;
  
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[10];
  
        Arrays.fill(a, 5);
  
        System.out.println(Arrays.toString(a));
  
    }
}

练习：

首先定义一个5X8的二维数组，然后使用随机数填充满。
借助Arrays的方法对二维数组进行排序。
参考思路：
先把二维数组使用System.arraycopy进行数组复制到一个一维数组
然后使用sort进行排序
最后再复制回到二维数组。

import java.util.Arrays;
public class shuZu {
    public static void main(String[] args) {
        int[][] array = new int [5][8];
        int brray[] = new int[5*8];
        for (int i = 0 ; i<array.length;i++){
            for (int j = 0 ; j<array[i].length ; j++){
                array[i][j] = (int)(Math.random()*100);
                //随机数填充满。
            }
        }
        //temp 设置出来，刚好能够卡住每列元素
        // i=0时，temp也为0，此时brray[temp+j]就是第一行的
        // i=1 时，temp=1，此时brray[temp+j]就变为第二行开头
        for (int i = 0 ; i< array.length;i++){
            int temp = i*8;
            for (int j = 0; j < array[i].length; j++){
                brray[temp + j] = array[i][j];
            }
            }
          //Arrays.sort
         Arrays.sort(brray);
    //一维复制回二维
            System.out.println("b排序后数组"+Arrays.toString(brray));
        for (int i = 0; i < 5; i++) {
            array[i]=Arrays.copyOfRange(brray,8*i,8*(i+1));
        //此处的8*i 同理上述temp
        }
        System.out.println("a排序后数组"+Arrays.deepToString(array));

}
    }