数组

基本概念

概念

同一种数据类型的多个固定数量的数据放到一个容器里~

创建方式

	int[] arr1={1,2,3,4,5};
	char[] arr2=new char[2];
	boolean[] arr3=new boolean[]{false,ture,false,false,true,true,false};

常用功能

• arr1[下标]——获取元素；

• arr1.length——获取长度；

• arr1[下标]=对应数据类型的值——给数组某个元素赋值；

    char[] c1=new char[2];
    c1[0]='q';
    c1[1]='q';
    System.out.println(c1);
    //结果：qq
  

• 自动类型转换存在于数组，即 long[] arr1中可以放 int short long类型的数据

    int a =1;
    byte b =2;
    short c=3;
    long[] arr1={a,b,c};
    //结果：不会报错，arr1中存放的是已经转换为long型的 a和b和c的值；（但a  b  c本身的值和类型都没有变，不会变成long）
  

• 默认值

    char[] c1=new char[2];
    System.out.println(c1[0]);//默认空字符
    //空字符也有数据，数据内容就是空字符，占内存的）
    
    int[] i=new int[2];
    System.out.println(i[0]);//默认0
    
    boolean[] b=new boolean[2];
    System.out.println(b[0]);//默认False
    
    String[] s=new String[2];
    System.out.println(s[0]);//默认null
  
    Random r[]=new Random[2];
    System.out.println(r[0]);//默认null
    //默认null，代表空，所有引用数据类型的默认值都是空（无数据，不存在于内存）；
    //random此时是个类型，不是个数值，没有调用random方法，只是个引用类型
    
    byte[] b1=new byte[2];
    System.out.println(b1[0]);//默认0
    
    float[] f=new float[2];
    System.out.println(f[0]);//默认0.0
    
    double[] d=new double[2];
    System.out.println(d[0]);//默认0.0
  

排序

选择排序

找最大/小值放在最前；在剩余数字中继续重复该动作；

public static void main(String[] args) {
		int[] arr={122,13,24,2,21,3157,468,986};
		System.out.println(Arrays.toString(s(arr)));
	}
	
	public static int[] s(int[] arr) {
		for(int i=0;i<arr.length-1;i++){
			int min=i;
			for(int j=i+1;j<=arr.length-1;j++){
				if(arr[j]<arr[min])
					min=j;
				}
			int t=arr[i];
			arr[i]=arr[min];
			arr[min]=t;
		}
		return arr;
	}

• 必须使用下标，不能直接交换元素！
• 注意内层循环的起始位置（j=i+1），否则每次都与最前面的交换，最前面在第一次循环后就是已经计算出来的最小值了，结果会出错！！！

冒泡排序

两两比较，将较大/较小的值向后移动，直到移动到最后；在剩下的数字中重复以上动作；

public static void main(String[] args) {
		int[] arr={1,2,4,1,34,2};
		System.out.println(Arrays.toString(f2(arr)));
	}
	public static int[] f2(int[] arr) {
		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 t=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=t;
				}
			}
		}
		return arr;
	}

• 注意内层循环的起始位置（j=i+1），否则造成冗余的循环过程！！！

二维数组

概念

以（一维）数组为元素的数组（嵌套的概念）~

创建方式

*数据类型[][] 数组名=new 数据类型[m][n];

*数据类型[][] 数组名={{元素1}，{元素1，元素2}，{元素1，元素2，元素3...}，{}，{元素1，元素2...}...};

*数据类型[][] 数组名=new 数据类型[m][];   
//不推荐！！！这种方式可以创建但不能使用，必须对其中每一个一维数组再进行单独创建才能使用；
如： 
int[][] crr=new int[3][];
crr[0]=new int[3];   //不能使用crr[0]={1,2,3}的形式，必须使用new关键字！
crr[1]=new int[2];
crr[2]=new int[5];

常用功能

• arr[下标]——获取一维数组；
• arr[下标][下标]——获取一维数组中的具体元素；
• arr.length——获取二维数组长度；
• arr[下标].length——获取内部的一维数组长度；
• • arr1[下标][下标]=对应数据类型的值——给二维数组中的一维数组中的某个元素赋值；

可变参数

• 写法int… a（写在参数列表里）

• 实际传的参数个数可变

• 可变参数必须写在参数列表最后一位，其前面可以有其他类型的其他形参；（如果出现在前面或中间，由于其可以接收任意量的参数值，会导致后面的形参接收不到参数！）

• 传的参数本质上会被打包成一个该数据类型的数组（即便没有参数也可以，数组长度为0）

    public static void main(String[] args) {
    	f1(1,2,3,4,5);
    	f1(1,2);
    	f1();
    	//以上都可以
    }
    public static void f1(int... a) {
    }
  

待学习：
数组的地址
空指针异常

for each

• 没有下标的概念

• 只能遍历容器(数组、集合等）

• 自动查找对应数据类型的，从前到后遍历完毕，每读到一个，执行一次内部语句。

    for(数据类型 变量：容器){
    	语句
    }
    for(int a:arr){
    	System.out.println(a);
    }
  

• 遍历二维数组

    	int[][] arr=new int[2][3];
    	for(int[] brr:arr){
    		for(int b:brr){
    			System.out.println(b);
    		}
    	}
  

Arrays 工具类

“容器s”即容器的工具类：如arrays是数组的工具类；collections是集合的工具类；

toString

sort

可以按字典顺序排序字母
可以排序数字

binarySearch 二分搜索法

只能对不重复且升序排列的数组查找，查到后返回其下标

binarySearch(数组名,要查找的值）

*如果要查找的值不存在，会返回 其 如果能出现，其按顺序应该出

copyOfRange

copyOfRange (数组名,起始下标，结束下标）
//包含开始下标，不含结束下标

• 结束下标如果超过数组长度，将会用默认值 0自动补位：

	int[] arr={1,2,3,4,5,6}
	brr=copyOfRange(arr,4,10)
	System.out.ptint(Arrays.toString(brr));
	//结果是 [5,6,0,0,0,0,0]