java入门笔记03之数组、数组的排序与复制+扩容

数组==是最简单的数据结构，属于引用数据类型；
  数组的概述
数组是相同类型数据的有序集合，每一个数据称作数组元素，通过使用下标取得。
数组声明创建
  一种：int[] arr=new int[6];
  第二种：int[] arr={1,2,2,3,3,4};
  第三种:int[] arr =new int[]{1,2,5,3,5,};
     类型 [ ] 参数名 ；
     int[ ] a; ---->首选
或者
    类型 参数名[ ]；
     int a[ ];
java中使用new创建
类型[ ] 参数名 = new 类型[ 长度];
int [] a;这是声明了一个数组，但是还没有真实的空间
a=new int[10]; 这里才是创建了数组，有真实的10的空间 ；
组合就是 int[ ] a= new int[10];
获取数组长度 a.length
java内存分析：

数组一旦被创建，他的大小是不变的。
其元素必须是同类型。
数组中元素可以是任何类型，包括基本与引用类型；
数组对象本身是在堆中的；
数组使用
for-each循环
数组作方法入参
数组作返回值

int [] a = {10,20,50,30,54,202};
for (int i = 0; i < a.length; i++) {
    System.out.println(a[i]);
}
int sum=0;
for (int i = 0; i < a.length; i++) {
    sum+=a[i];
}
System.out.println(sum);
int max=0;
for (int i = 0; i < a.length; i++) {
    if (max<a[i]){
        max=a[i];
    }
}
System.out.println(max);

数组参数反转；

public static int[] fZ(int[] args){
    int[] sh=new int[args.length];
    for (int i = 0,j=sh.length-1; i <args.length ; i++,j--) {
        sh[j]=args[i];
    }

多维数组
二维数组：
int a[][]= new int[10][20];
数组a可以看成是10行20列的数组；
多维数组：
  
int a[][] = {new int[5],new int[5],new int[5],};
  
Arrays类
数组的工具类：java.util.Arrays;;
是封装的数组类，可直接通过类名.使用
打印数组：

int[] aa={20,25,26,35,78,50};
System.out.println(Arrays.toString(aa));

数组的复制与排序：

int[] a={1，2,5,8,68，5}；
​	int[] b=new int[4];
​	System.arraycopy(a,1,b,0,4);

a：源数组
1：源数组第几个元素（第a[1]个元素，即第二个元素，开始
b:到目标数组
0：从目标数组第几个数开始存储，（第b[0]开始
4：从原数组中，要复制元素的个数；（从第a[1]开始，复制后边的4个元素；

	//@1 数组的复制
int[] a={12,5,8,46,9,65,54};
         int[] b= new int[6];
         System.arraycopy(a,2,b,1,4);
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }
     //@2 数组的复制
      int[] a={10,20,30,40,50,60,70,80,90,100};
        int[] b = Arrays.copyOf(a, 6);// 10,20,30,40,50,60
  		int[] c = Arrays.copyOf(a, 12);// 10,20,30,40,50,60,70,80,90,100,0,0
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }	
         b = Arrays.copyOf(b, 10);//(b,b.length+6)等同
		//数组的扩容（创建 一个新的 更大的 ，并将原数组的数据复制进去了

a:源数组
b：目标数组
6：目标数组长度（a.length>b.length，则将a末尾的元素截掉，
​ -------------a.length<b.length,则a元素全部复制过去，不足的默认填充0
数组扩容： b = Arrays.copyOf(b, 10);//(b,b.length+6)

 //@4 把数组最大值赋值给数组最后一位的下一位，扩容，
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=(int) (Math.random()*100);
        }
        int MAX=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]>MAX){
                MAX=arr[i];
            }
        }
        arr = Arrays.copyOf(arr, arr.length + 1);//扩容一位！
        arr[arr.length-1]=MAX;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

数组排序:Araays.sort(b);升序

//@5 排序
        int[] arr = new int[10];

        for (int i = 0; i < arr.length; i++) {
             arr[i]=(int)(Math.random()*100);
        }
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
        for (int i = arr.length-1; i >= 0; i--) {
            System.out.print(arr[i]+"\t");
        }

降序：（包装类，Integer--------> Arrays.sort(arr,o1+.选择copareTo方法，选择由O2指向O1);

 Integer[] d={12,45,430,42,44,4,46,47,49};
        Arrays.sort(d,(o1, o2) -> o2.compareTo(o1));
        for (int i = 0; i < d.length; i++) {
            System.out.print(d[i]+"\t");
        }

稀疏数组===》是一种数据结构
生成随机数: 2种
​ Math类：

int x=(int)(Math.random()*1000+1);（1~1000）
Math.random=====>（0~0.99999999）

Random类：

 Random random = new Random();创建随机对象；
        int ra = random.nextInt(1000);(1~1000)