数组

跟着尚硅谷老师视频写的笔记# 数组

数组,是多个相同类型按一定顺序排列的集合,并使用一个名字命名,并通过编号的方式对这些数据进行统一管理.

* 数组的特点:
* 1.数组是有序排列的
* 2.数组是引用类型变量,数组的元素既可以是基本数据类型,也可以引用数据类型
* 3.创建对象会在内存中开辟一整块连续空间
* 4.数组的长度一旦确定,就不能修改*

数组的分类
    按照维数:一维 二维
    按照类型:基本数据类型元素的数组、引用数据类型元素的数组

• 一维数组的使用
  1. 一维数组的声明和初始化
  2. 如何调用数组的指定位置元素
  3. 如何获取数组的长度
  4. 如何遍历数组
  5. 数组元素的默认初始化值
  6. 数组的内存解析

 public static void main(String[] args) {
        //1.一维数组的声明和初始化
        int[] ids; //声明
        //1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行
        ids=new int[]{1001,1002}; //初始化

        //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names= new String[5];

        //错误的写法
//        int[] arr1=new int[];
//        int [5] arr2=new int[5];
//        int[] arr3=new int[3]{1,2,3};

        //总结:数组一旦初始化完成,其长度就确定了

        //2.如何调用数组指定位置的元素:通过角标的方式调用
        //角标(索引)从0开始到数组长度-1;
        names[0]="你啊1";
        names[1]="你啊2";
        names[2]="你啊3";
        names[3]="你啊4";
        names[4]="你啊51";
//        names[4]="你啊5";//数组越界异常
        System.out.println(names[4].length());  //4
        System.out.println(names[4].charAt(3));  //1
        //3.如何获取数组的长度
        //属性:length
        System.out.println(names.length); //5

        //4.如何遍历数组
//        System.out.println(names[0]);
//        System.out.println(names[1]);
//        System.out.println(names[2]);
//        System.out.println(names[3]);
//        System.out.println(names[4]);
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }

    }

/*
* 数组元素默认初始化值
*   >数组元素是整形:0
*   >数组元素是浮点型:0.0
*   >数组元素是char型:0    这个0不是'0'  是0的Acalll的0
*   >数组元素是boolean型:false
*   >数组元素是引用数据类型:null      是null不是"null"   可以加if区分
* */
public class ArrayTest {
    public static void main(String[] args) {
     //5.数组元素的默认初始化值  (类里面属性初默认始化值和这里面是一样的)
//        int[] arr=new int[4];
//        for (int i = 0; i < arr.length; i++) {
//            System.out.println(arr[i]); //0
//        }
//        long[] arr1=new long[4];
//        for (int i = 0; i < arr1.length; i++) {
//            System.out.println(arr[i]); //0
//        }
//        boolean[] arr2=new boolean[2];
//        System.out.println(arr2[0]);  //false        
        char[] arr3=new char[4];
        for (int i = 0; i < arr3.length; i++) {
            System.out.println("---"+arr3[i]);//---
        }
        if(arr3[0]==0){
            System.out.println("你好");  //打印你好了
        }

    }
}

--- 
--- 
--- 
--- 
你好

一维数组的内存解析

要知道的知识:

1. 局部变量:方法中定义的变量都是局部变量
2. 方法区:还可以存和类加载器有关的东西

注意:其实刘德华这些字符串不是直接在堆中的(后面学到字符串的时候)

当堆中的对象没有引用的时候,会在一个时间内被自动垃圾回收

多维数组的使用

1.理解:

对于二维数组的理解,我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在的,其实,从数组底层的运行来看,其实没有多维数组

• 二维数组的使用:

  1. 二维数组的声明和初始化
  2. 如何调用数组的指定位置元素
  3. 如何获取数组的长度
  4. 如何遍历数组
  5. 数组元素的默认初始化值
  6. 数组的内存解析

  public static void main(String[] args) {
        //二维数组的声明和初始化
        int []arr=new int[]{1,2,3};//一维数组
        //静态初始化
        int [][] arr1=new int[][]{{1,2,3},{4,5},{6,7,8}};
        //动态初始化1
        int [][] arr2=new int[3][2];
        //动态初始化2
        int [][] arr3=new int[3][];

        //错误情况
//        String[][] arr4=new String[][4];
//        String[4][3] arr5=new String[][4];
//        String[][] arr6=new String[4][3]{{1,2,3},{4,5,6},{1,2,3},{4,5,6}};

        //也是正确
        int[] arr7[]=new int[3][];
        int [][] arr8={{1,2,3,1},{4,5},{6,7,8}};
        //如何调用数组的指定位置元素
        System.out.println(arr1[0][1]);  //2
        arr3[1]=new int[5];
        System.out.println(arr3[1][4]);  //0
        //获取数组的长度
        System.out.println(arr8.length);  //3
        System.out.println(arr8[0].length); //4

        //4.遍历二维数组
        for (int i = 0; i < arr8.length; i++) {
            for (int j = 0; j <arr8[i].length ; j++) {
                System.out.println(arr8[i][j]);
            }
        }
    }

二维数组的初始化值
	规定:二维数组分为外层元素,内层数组元素
	int[][] arr=new int[4][3];
	外层元素:arr[0],arr[1]等
	内层元素:arr[0][0],arr[1][2]等;

 public static void main(String[] args) {
        int [][]arr=new int[4][3];
        System.out.println(arr[0]);  //地址 [I@1b6d3586
        System.out.println(arr[0][0]);  //0
        System.out.println(arr); //[[I@4554617c
        System.out.println("**********");
        float [][]arr1=new float[4][3];
        System.out.println(arr1[0]);  //地址 [F@74a14482
        System.out.println(arr1[0][0]);  //0.0
        System.out.println(arr1); //[[F@1540e19d
        System.out.println("***************");
        String [][]arr2=new String[4][3];
        System.out.println(arr2[0]);  //地址 [Ljava.lang.String;@677327b6
        System.out.println(arr2[0][0]);  //null
        System.out.println(arr2); //[[Ljava.lang.String;@14ae5a5
        System.out.println("**********************");
        String [][]arr3=new String[4][];
        System.out.println(arr3[2]); //null
//        System.out.println(arr3[2][0]); //NullPointerException

        String [][]arr4=new String[4][0];
        System.out.println(arr4[2]); //[Ljava.lang.String;@7f31245a
        System.out.println(arr4[2][0]); //ArrayIndexOutOfBoundsException
    }

• int[] x,y[]; x是一维数组 y是二维数组

看是否是同一类型,或者满足类型提升

x 是一维的,y是二维的,x[0]是值,y[0]是一维的,y[0][0]是值

数组中涉及的常见算法

1. 数组元素的赋值

拓展之笔试题
常见一个长度为6的int型数组,要求数组元素的值都在1-30之间,且是随机赋值,同时要求元素的值个不相同

2. 求数值型数组元素中的最值、平均数、总和等
3. 数组的复制、反转、查找

   public static void main(String[] args) {
        int []a={1,2,3};

        //这个不叫数组的复制
        int []a1=a;

        //每个元素都取出来赋值给a1了可以实现

        //数组的复制(区别于数组变量的赋值:arr1=arr)
        String[] arr=new String[]{"JJ","DD"};
        String[] arr1=new String[arr.length];
        //复制
        for (int i = 0; i < arr.length; i++) {
            arr1[i]=arr[i];
        }
        //数组的反转  >>1 或者/2
        for (int i = 0; i < arr1.length>>1; i++) {
            String t=arr[i];
            arr[i]=arr[arr.length-i-1];
            arr[arr.length-i-1]=t;
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+"\t");
        }

    }

• 注意在字符串(引用类型)中找的时候不要用==去判断是否相等,用equals(可以看我另一篇博客)

   public static void main(String[] args) {
        String a="aa";
        String b=new String("aa");
        System.out.println(a==b);
        Integer c=1;
        Integer d=new Integer(1);
        System.out.println(c==d);
        System.out.println(c.equals(d));

    }
false
false
true

4. 数组元素的排序算法

• 冒泡排序

  public static void main(String[] args) {
        int [] arr=new int[]{43,32,76,-98,0,64,33,-21,32,99};
        //冒泡排序
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

• 快速排序

//快速排序
void quick_sort(int s[], int l, int r)
{
    if (l < r)
    {
		//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
        int i = l, j = r, x = s[l];
        while (i < j)
        {
            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
				j--;  
            if(i < j) 
				s[i++] = s[j];
			
            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
				i++;  
            if(i < j) 
				s[j--] = s[i];
        }
        s[i] = x;
        quick_sort(s, l, i - 1); // 递归调用 
        quick_sort(s, i + 1, r);
    }

————————————————
版权声明：本文为CSDN博主「MoreWindows」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/morewindows/article/details/6684558

方式可以很多,但是思想都是大差不差的.

• 各种排序性能

Arrays工具类的使用

Arrays中的equals

 int []arr1 =new int[]{1,2,3,4};
        int []arr2 =new int[]{1,3,2,4};
        boolean equals = Arrays.equals(arr1, arr2);
        System.out.println(equals);//false

• Arrays中的equals中源码

 public static boolean equals(short[] a, short a2[]) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }

Arrays中的toString

int []arr1 =new int[]{1,2,3,4};
System.out.println(Arrays.toString(arr1));
结果:[1, 2, 3, 4]

• Arrays中toString 源码

 public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

Array中的fill()

int []arr1 =new int[]{1,2,3,4};
//3.void fill(int[] a,int val):将指定值填充到数组之中
Arrays.fill(arr1,10);
ystem.out.println(Arrays.toString(arr1));
结果:[10, 10, 10, 10]

• Array中fill()源码

 public static void fill(int[] a, int val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }

Array中的sort()

//4.void sort(int[] a):对数组进行排序
        int []arr3 =new int[]{1,2,5,4};
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));
结果:[1, 2, 4, 5]

• Array中sort()源码

  public static void sort(int[] a) {
      //底层就是快拍
        DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
    }

Arrray中的binarySearch()

 //5.int binarySearch(int[] a,int key)
        int []arr4=new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int i = Arrays.binarySearch(arr4, 210);
        int d = Arrays.binarySearch(arr4, 1);
        System.out.println(i);  //8    >0说明找到了
        System.out.println(d);  //-3

• Arrray中的binarySearch()源码,想知道反的负数是几,可以看源码.

 public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }


private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

• 整体代码

package com;

import java.util.Arrays;

/*
* java.util.Arrays:操作数组的工具类,里面定义了很多操作数组的方法*/
public class ArraysTest {
    public static void main(String[] args) {
        //1.boolean equals(int[] a,int[] b) :判断两个数组是否相等
        int []arr1 =new int[]{1,2,3,4};
        int []arr2 =new int[]{1,2,3,4};
        boolean equals = Arrays.equals(arr1, arr2);
        System.out.println(equals);
        System.out.println(arr1==arr2);
        //2.String toString(int[] a): 输出数组信息
        System.out.println(Arrays.toString(arr1));
        //3.void fill(int[] a,int val):将指定值填充到数组之中
        Arrays.fill(arr1,10);
        System.out.println(Arrays.toString(arr1));
        //4.void sort(int[] a):对数组进行排序
        int []arr3 =new int[]{1,2,5,4};
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));
        //5.int binarySearch(int[] a,int key)
        int []arr4=new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int i = Arrays.binarySearch(arr4, 210);
        int d = Arrays.binarySearch(arr4, 1);
        System.out.println(i);  //8
        System.out.println(d);  //-3
    }
}

true
false
[1, 2, 3, 4]
[10, 10, 10, 10]
[1, 2, 4, 5]
8
-3

Process finished with exit code 0

数组中的常见错误

• 越界和空指针

public class ArrayExceptionTest {
    public static void main(String[] args) {
        //1.数组角标越界的异常:ArrayIndexOutOfBoundExcetion
        //arr[-1]  arr[超过最大下标]
        //2.空指针异常:NullPointerException
       //情况一
        int[] arr1=new int[]{1,2,3};
        arr1=null;
        System.out.println(arr1);//null
//        System.out.println(arr1[0]); //NullPointerException
        //情况二
        int[][] arr2=new int[4][];
        System.out.println(arr2[0]); //null
//        System.out.println(arr2[0][0]); //NullPointerException
        //情况三
        String[]arr3=new String[]{"AA","BB","CC"};
        arr3[0]=null;
        System.out.println(arr3[0].toString()); //NullPointerException
    }

}