Java基础理论之数组

容器概述

容器：是将多个数据存储到一起，每个数据称为该容器的元素。
#内存概述
内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程
序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。
Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

数组概念

数组概念： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

数组的定义

方式1：数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];（建议只记住并使用这一种就好）
方式2：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};（指定元素数组的快速定义）
方式3：数据类型[] 数组名 = {元素1,元素2,元素3…};（忘记他吧）

数组定义格式详解：

数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
[] : 表示数组。
数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
new：关键字，创建数组使用的关键字。
数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
[长度]：数组的长度，表示数组容器中可以存储多少个元素。
注意：数组有定长特性，长度一旦指定，不可更改。

数组的访问

数组名[索引]

数组从0开始排序
数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的
长度，语句为： 数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数
组的最大索引值为 数组名.length-1 。

索引访问数组中的元素：

数组名[索引]=数值，为数组中的元素赋值
变量=数组名[索引]，获取出数组中的元素

##数组原理内存图

 

打印数组地址值

public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr);//[I@5f150435
}

【：数组  I数据类型  5f150435模拟地址值

public static void main(String[] args) {
int[] arr = new int[3];
int[] arr2 = new int[2];
System.out.println(arr);
System.out.println(arr2);
}

arr2= arr 是吧 arr的地址值给了arr2

public static void main(String[] args) {
// 定义数组，存储3个元素
int[] arr = new int[3];
//数组索引进行赋值
arr[0] = 5;
arr[1] = 6;
arr[2] = 7;
//输出3个索引上的元素值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//定义数组变量arr2，将arr的地址赋值给arr2
int[] arr2 = arr;
arr2[1] = 9;
System.out.println(arr[1]);
}

数组常见异常【重点】 

数组越界异常
ArrayIndexOutOfBoundsException
空指针异常
NullPointerException

数组遍历【重点】

for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}

数组反转

 System.out.println("****************** 数组进行翻转 写法1*****************");
        int[] iArray = new int[]{1,2,3,4,5};
        int[] iArray2 = new int[iArray.length];
        for (int i = 0; i < iArray.length; i++) {
            iArray2[iArray.length-1-i] = iArray[i];
        }
        Arrays.stream(iArray2).forEach(System.out::println);
        System.out.println("*******************数组进行翻转 写法2*****************");
        List<Integer> collect = Arrays.stream(iArray).boxed().collect(Collectors.toList());
        Collections.reverse(collect);
        System.out.println("*******************数组进行翻转 写法3*****************");
        String[]  testArray  =  new String[]{"a","b"};
        Collections.reverse(Arrays.stream(testArray).collect(Collectors.toList()));
        Arrays.stream( collect.toArray()).forEach(System.out::println);


        System.out.println("*******************异或运算 + 指针对数组进行翻转 写法1*****************");
        for(int pointOne=0 ;pointOne < iArray.length-1 -pointOne ;pointOne++){
            int pointTwo = iArray.length-1-pointOne;
            iArray[pointOne]  = iArray[pointOne] ^iArray[pointTwo];
            iArray[pointTwo]  = iArray[pointOne] ^iArray[pointTwo];
            iArray[pointOne]  = iArray[pointOne] ^iArray[pointTwo];
        }
        Arrays.stream(iArray).forEach(System.out::println);
        System.out.println("*******************异或运算 + 指针对数组进行翻转 写法2*****************");
        for(int pointOne = 0 , pointTwo = iArray.length-1 ; pointOne<pointTwo ;pointOne++,pointTwo--){
            iArray[pointOne]  = iArray[pointOne] ^iArray[pointTwo];
            iArray[pointTwo]  = iArray[pointOne] ^iArray[pointTwo];
            iArray[pointOne]  = iArray[pointOne] ^iArray[pointTwo];
        }
        Arrays.stream(iArray).forEach(System.out::println);
        System.out.println("*******************异或运算 + 指针对数组进行翻转 写法3*****************");
        int pointOne = 0 , pointTwo = iArray.length-1;
        for(; pointOne<pointTwo ;pointOne++,pointTwo--){
            iArray[pointOne]  = iArray[pointOne] ^iArray[pointTwo];
            iArray[pointTwo]  = iArray[pointOne] ^iArray[pointTwo];
            iArray[pointOne]  = iArray[pointOne] ^iArray[pointTwo];
        }
        Arrays.stream(iArray).forEach(System.out::println);

数组取最大最小值

pulbic static void  coursewareOne(){
Random rd = new Random();
        Integer[] iArray = new Integer[6];
        for (int i = 0; i < iArray.length; i++) {
            iArray[i] = rd.nextInt(100);
            System.out.print("  " + iArray[i]);
        }
        System.out.println();
        //        获取最大值
        //        Optional<Integer> max = Arrays.stream(iArray).max((a, b) -> a-b );
        //        System.out.println(max.get());
        //        过滤
        //        Arrays.stream(iArray).filter((a)->a>50).collect(Collectors.toList()).forEach(System.out::println);
        //        排序
        //        Arrays.stream(iArray).sorted((a,b)->a-b).forEach((System.out::println));  a-b 升序
        //        求和
        //        Optional<Integer> reduce = Arrays.stream(iArray).reduce((a, b) -> Integer.sum(a, b));
        //        System.out.println(reduce.get());
        //        获取最大值
//        Optional<Integer> reduce = Arrays.stream(iArray).reduce((a, b) -> Integer.sum(a, b));
//        System.out.println("平均分为：" + (reduce.get() - maxNum - minNum) / 4.0);
        int maxNum = iArray[0];
        int minNum = iArray[0];
        for (int i = 1; i < iArray.length; i++) {
            maxNum = maxNum > iArray[i] ? maxNum : iArray[i];
            minNum = minNum < iArray[i] ? minNum : iArray[i];
        }
        System.out.println(maxNum);
        System.out.println(minNum);
}
 

冒泡排序：

降序     如果判断改成 大于则 升序
private static void sorting(int[] iArray) {
        for (int i = 0; i < iArray.length; i++) {
            for (int j = iArray.length-1 ; j >i ; j--) {
                if (iArray[i] < iArray[j]) {
                    iArray[i] = iArray[j]^iArray[i];
                    iArray[j] = iArray[j]^iArray[i];
                    iArray[i] = iArray[j]^iArray[i];
                }
            }
        }
    }


此方法 先确定 iArray[i]的值  即先确定iArray[0];

iArray[0] 和 所有的比较  如果小了就换走 确定了 0 是最大的

外部循环 确定了总循环的次数 

内部for 自身递减  循环次数随着i的确定 而减少    确定了内部循环每次循环的次数

二位数组：

int [] [] iPArray = {{},{},{}};

int[] [] iPArray= new int [3][2]

二分查找法：

数组是有序且升序  如果是降序则把 两个if大小符号改下    
private static Integer binarySearchIndex(int[] iArray, int value) {
        int min = 0;
        int max =iArray.length-1;
        while (min<=max){
            int point=(max+min)>>1;
            if(iArray[point]<value){
                min = point+1;
            }else if (iArray[point]>value){
                max = point-1 ;
            }else {
                return point;
            }
        }
        return -1;
    }