java基础笔记四

数组

数组的定义

数组指的是相同数据类型按照一定的顺序排列的集合，并使用一个名字命名，并且通过统一编号堆这些数据进行操作和统一管理。

数据类型：基本数据类型 引用数据类型

数组内容

• 数组名
• 元素：确定是哪个数组，找到数据的关键
• 元素：具体数组的所有数据
• 下标：角标，索引（index）,最大下标比元素个数少1的数据位置，从0开始算起
• 数组长度：元素个数

特点：

• 数组是有序排列的
• 数组是引用类型的，数组元素可以是基本数据类型，也可以是引用数据类型。
• 数组的长度一般确定不能修改
• 创建数组会在内存中开辟一整块连续空间

数组元素的访问

1.通过获取数组长度（.length属性）
2.通过遍历下标访问每一个元素

数组的使用：

1.int []a = new int[5];//新建5个长度空间的数组，每个元素的类型都是int,数组的内存空间存储到变量a。
2.int[] a = {1,2,3,4,5};//已经存在的数组变量，保存在一个新的数组地址中，并且直接初始化新数组中的元素。
3.int[]a = new int[]{1,2,3,4};//新建数组长度是3的数组，并且每个数组类型都是int，还初始化了数组元素。

元素的默认值问题

整数类型：0；
浮点型：0.0；
char型：0或者\u0000;这里的0不是‘0’，而是数字0；直接输出时不可见
boolean型：数组元素是boolean,默认值是false;
引用数据类型的元素默认值：数据元素是引用类型，默认值都是null，数组相关操作的工具类是Arrays工具类，他提供了所有数组相关方法。

package cn.tedu.array;

/**
 * 
 * 数组中元素的默认值：
 * 
 * 基本数据类型
 * 
 * 
 * 引用数据类型
 * 
 * @author ui-cgb
 *
 */
public class Test02 {
	public static void main(String[] args) {
		//数组元素的默认初始化
		//int类型的数组元素默认值是0
		int[] arr = new int[4];
		// 遍历数组arr
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+",");
			
		}
		System.out.println("*********************************");
		//short类型的数组元素默认值
		short [] arr1 = new short [4];
		for(int  j = 0;j<arr1.length;j++ ) {
		System.out.print(arr1[j]+",");	
		}
		System.out.println("*********************************");
		//声明一个float类型的元素默认值
		float [] arr2 = new float [4];
		for(int  j = 0;j<arr2.length;j++ ) {
		System.out.print(arr2[j]+",");	
		}
		System.out.println("*********************************");
		//声明一个char 类型
		char [] arr3 = new char [4];
		for(int  j = 0;j<arr3.length;j++ ) {
		System.out.print(arr3[j]+",");	
		}
		if(arr3[3]==0) {
			System.out.println("今天是星期一");
			
		}
		//声明一个boolean 类型
				boolean [] arr4 = new boolean [4];
				for(int  j = 0;j<arr4.length;j++ ) {
				System.out.print(arr4[j]+",");	
				}
		//引用数据类型的元素默认值
				String [] arr5 = new String [4];
				for(int  j = 0;j<arr5.length;j++ ) {
				System.out.print(arr5[j]+",");	
				}
	}
}

数组的相关操作

package cn.tedu.array;

import java.util.Arrays;

/**
 * 
 * 此类是数组的相关操作
 * 
 * Array工具类
 * binarySearch();
 *  内存使用空间的堆栈图 
 *  
 * @author ui-cgb
 *  
 */
public class Test03 {

	public static void main(String[] args) {
		// 数组的等值判断 equals（）
		// 数组的等值判断
		// boolean:true 或者false
		int[] arr = new int[] { 1, 2, 3, 4 };
		int[] arr1 = new int[] { 1, 2, 3, 4 };
		System.out.println(Arrays.equals(arr, arr1));
		// 输出数组信息（元素内容）toString();
		System.out.println(Arrays.toString(arr));
		// 数组填充问题：将指定数值填充修改给指定数组的问题
		Arrays.fill(arr1, 99);
		System.out.println(Arrays.toString(arr1));
		//数组排序问题
		int[] arr2 = new int[] { 12, 4545, 232, 54, 54 };
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		//查找元素

		int[] arr3 = new int[] { 2, -87, 209, 89, 89, 67, 90, 4, 0 };
        int index = Arrays.binarySearch(arr3, 0);
        if(index>=0) {
        System.out.println(index);
        }else if(index ==  8) {
        	System.out.println("未找到");
        }
        //数组的复制 arraycopy()  ArrayCopy of()
       int[] a = new int[10];//声明int类型a数组，长度是10
       int[] b = new int[a.length];//声明int 类型b数组，长度是10
       for(int i = 0;i<a.length;i++) {//遍历数组元素
    	   a[i] = i+1;//给每一个a里面的元素赋值
    	   System.arraycopy(a, 3, b, 3,5 );//arraycopy()复制数组方法
    	   /**
    	    * arraycopy()复制数组方法
    	    * src源数组  srcPos 源数组的起始下标
    	    * dest目标数组 destPos目标数组的起始下标
    	    * length   复制的长度问题   original 源数组
    	    * 复制过程中目标数组的复制起始下标等于或者大于源数组的起始下标
    	    * 
    	    * 
    	    */
    	   System.out.print(b[i]+",");
    	   
       }
        int [] c = new int[] {8,4,9,6,9,2,1} ;
        //数组的缩容
        int [] d = Arrays.copyOf(c, 5);
        System.out.println(Arrays.toString (d));
        //数组的扩容
        int [] e = Arrays.copyOf(c, 12);
        System.out.println(Arrays.toString (e));
        
	}

}

数组算术的考察

package cn.tedu.array;

import java.util.Arrays;

/**
 * 
 * 
 * @author ui-cgb 数组算术的考察 最大值 最小值 和值 平均数 总和等
 *
 *
 *
 *
 */
public class Test04 {
	public static void main(String[] args) {
		// 定义一个int类型的数组,包含10个整数，分别赋一些随机整数
		int[] arr = new int[10];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * 100);
		}
		System.out.println(Arrays.toString(arr));
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "*");
		}
		// 求数组中的最大值
		System.out.println();
		int maxValue = arr[0];
		// 遍历访问每个元素，
		for (int i = 0; i < arr.length; i++) {
			// 访问到的元素最大值依次比较
			if (maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		System.out.println(maxValue);

		// 求数组中的最小值
		int minValue = arr[0];
		for (int i = 0; i < arr.length; i++) {
		// 访问到的元素最大值依次比较
			if (minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		System.out.println(minValue);

		//求数组元素的综合
		int sum = 0;
		for(int i = 0;i<arr.length;i++){
			sum += arr[i];
		}
		System.out.println(sum);
		//求数组元素的平均数
		
		int avg = 0;
		for(int i = 0;i<arr.length;i++){			
			avg = sum/(arr.length) ; 
		}
		System.out.println(avg);
		
	}
}

二维数组的使用

package cn.tedu.array;
/*
 * 二维数组的使用
 * 
 */
public class Test05 {
public static void main(String[] args) {
	//定义一个数组
	int arr[] = new int[] {1,2,3};
	//定义一个二维数组
	//二维数组的元素是数组类型
	//静态初始化过程==声明的同时赋值
	int arr1[][] = new int [][] {{1,2,3},{4,5,6},{7},{6,8,9}};
	//动态初始化
	String  [][] arr2= new String[3][2] ;//arr2数组中有3个数组元素，分别有两个元素
	
	String  [][] arr4= new String[3][] ;//有三个数组且不确定每个数组的内容
	//错误情况：
	//String [][] arr3= new String[][2] ;//数组元素不能为空
	// int 3[][2]a = new int[][];不能在前面表示数组长度
	 
	
	//通过调用数组指定下标获取元素
	System.out.println(arr1[0][1]);//2 第一个数组元素中的第二个元素
	//System.out.println(arr1[2][3]);//下标越界异常
	//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
	System.out.println(arr2[0][0]);//null
	
	//获取数组长度的问题
	
	System.out.println(arr2.length);//3
	//遍历数组
	for(int i = 0;i<arr2.length;i++) {//外层循环执行一次获取数组
	 for (int j = 0;j<arr2[i].length;j++) {//里层循环执行所有次获取单个元素
		 System.out.print(arr2[i][j]+",");  //将获取到的元素输出
		 
	 }	
	 System.out.println();
		
	}
	
}
}

典型案例： 杨辉三角

package cn.tedu.array;

public class yanghui {
/**
 * 
 * 杨辉三角练习
 * @param args
 */

	public static void main(String[] args) {
		//声明并初始化二维数组
		int [][] yanghui = new int [10][];	
		//给数组的元素赋值
		for (int i = 0;i<yanghui.length;i++) {
			yanghui[i] = new int[i+1];
			//给首末元素赋值
			yanghui [i][0] = 1;
			yanghui [i][i] = 1;
			//给每行的非首末元素赋值
				for(int j = 1;j<yanghui[i].length-1;j++) {
					yanghui[i][j] = yanghui [i-1][j-1]+yanghui[i-1][j];		
			}
			
		}		
		//遍历数组
		for(int i = 0;i<yanghui.length;i++) {
			for(int j =0;j<yanghui[i].length;j++) {
				System.out.print(yanghui[i][j]+" ");
				
			}
			System.out.println();
			
		}
		
	}

}