java数组二

1.数组做形参

          public class test {

/*
 * 1：基本类型作为形参
 *     基本类型作为形参，在被调用方法中改变形参的值，不会影响调用方法中实参的值
 * 
 * 2：数组类型作为形参
 *    基本类型作为形参，在被调用方法中改变数组元素的值，会影响调用方法中实参的值
 */

public static void show(int a){
	
	a = 20;
	System.out.println("show中a是:"+a);
}

public static void show2(int[] arr){
	System.out.println(arr);
	
	arr[0] = 100;
	System.out.println("show中第一个下标值:"+arr[0]);
}
public static void main(String[] args) {
	/*int a = 10;
	show(a);
	System.out.println("main中的a是:"+a);*/
	
	int[] arr = {10,20,30};
	System.out.println(arr);
	show2(arr);
	System.out.println("main中第一个下标值:"+arr[0]);
	
} }

运行结果:
[I@15db9742
[I@15db9742
show中第一个下标值:100
main中第一个下标值:100

2 理解main函数

public class test {
	/*
	 * 理解main中形参的由来
	 * 
	 * 1:main还是JVM自动调用的 当JVM启动之后，JVM会自动开启一个线程，主线程，也就是我们的main线程，由这个去执行这个main方法
	 * 
	 * 2:给main方法传参 2.1 ：通过eclipse的可视化界面传值 2.2：通过cmd命令传值 javac 文件名.java java 类名
	 * 参数1 参数2 ... 传值
	 * 
	 * java运行的原理 1：编译 2：运行
	 * 
	 */
	public static void a() {
		// String[] str = {"a","b","c"};
		// main(str);
	}

	public static void main(String[] args) {

		for (String s : args) {
			System.out.println(s);
		}
		System.out.println(args.length);

	}

}

3.可变的参数(用数组实现)

public class Demo2 {
	
	/*
	 * 可变参数
	 * 
	 * 需求1：求2个数的和
	 * 需求2：求3个数的和
	 * 需求3：求多个数的和
	 * 
	 * 问题：如果每一个数字都要求和，需要些太多方法，太繁琐了，怎么解决？
	 *     可变参数来解决
	 *     
	 * 可变参数：底层其实就是一个数组，实参传几个值，那么这个可变参数就是有几个元素的数组
	 * 格式 public static void 方法名(数据类型...  形参名)  
	 * 
	 *  数据类型...  形参名
	 *  参数的个数可以是：0个,1个,多个 
	 *  注意：参数的类型必须是同一个类型，除过Object类型
	 *  注意：可变参数是方法形参中最后一个参数，后面不可以出现任何参数
	 *      但是可变参数的前面可以出现其他多个参数,但是不能出现其他可变参数
	 */
	//需求1：求2个数的和
	/*public static int sum(int a,int b){
		
		return a+b;
	}
	//需求2：求3个数的和
	public static int sum(int a,int b,int c){
		
		return a+b+c;
	}
	//需求3：求多个数的和
	public static int sum(int[] arr){
		int sum = 0;
		for (int i : arr) {
			sum+=i;
		}
		return sum;
		
	}*/
	
	
	//可变参数的方法
	public static int sum(int... args){
		//The variable argument type int of the method 
		//sum must be the last parameter
		int sum = 0;
		for (int i : args) {
			sum+=i;
		}
		
		return sum;
	}
	
	
	
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int c = 30;
		int d = 40;
		
		/*sum();
		sum(a);*/
		System.out.println("2个数的和:"+sum(a,b));
		System.out.println("3个数的和:"+sum(a,b,c));
		System.out.println("4个数的和:"+sum(a,b,c,d));
		
		/*
		int[] arr = {a,b,c,d};
		int sum = sum(a,b);
		System.out.println("2个数的和是:"+sum);
		int sum1 = sum(a, b, c);
		System.out.println("3个数的和是:"+sum1);
		int sum2 = sum(arr);
		System.out.println("多个数的和是:"+sum2);*/
	}

}

4冒泡排序

public class Demo {
	
	/*
	 * 需求：数组中存储多个学生分数，按照分数从低到高的顺序排序
	 * 
	 * 冒泡排序：
	 * 步骤：1:两两做大于比较，大的往后移，小的往前移,把最大的值找出来，放在倒数第1位
	 *       这个时候，我们数组划分为2部分，排好序是一部分，未排序的是一部分  
	 *     2:两两做大于比较，大的往后移，小的往前移,把第二大的值找出来，放在倒数第2位
	 *       这个时候，我们数组划分为2部分，排好序是一部分，未排序的是一部分 
	 *     3：依次类推，直到把所有的数字都按照从小到大的顺序，排列
	 *     
	 *  冒泡优化
	 *    1：把中间变量从小循环的里面，拿出来放在最大循环的外面声明，可以减少声明次数：    
	 *    2：每排序出一个元素后，后面的排序，就可以减少一次  
	 *       第1大的数 排序7 次
	 *       第2大的数 排序6 次
	 *       第3大的数 排序5次
	 *       以此类推
	 *       第8大数    排序0次
	 *    3:   
	 *  
	 * 
	 */
	public static void main(String[] args) {
		
		int[] s = {100,56,88,99,47,65,12,10} ;//原数组 乱序
		
		int count = 0;
		int temp = 0; //中间变量，存放需要交换元素的变量
		
		for(int j=1;j<=7;j++){
			
			for(int i = 0;i<s.length-j;i++){
				count++;
				if(s[i]>s[i+1]){
					
					//如果第一个元素比第二个元素大，交换位置
					temp = s[i];
					s[i] = s[i+1];
					s[i+1] = temp;
					
				}
			}
			
		}
		System.out.println(count);
		System.out.println(Arrays.toString(s));
		
		
		
		/*//两两做比较
		if(s[0]>s[1]){
			//如果第一个元素比第二个元素大，交换位置
			int temp = 0;
			temp = s[0];
			s[0] = s[1];
			s[1] = temp;
		}
		if(s[1]>s[2]){
			//如果第一个元素比第二个元素大，交换位置
			int temp = 0;
			temp = s[1];
			s[1] = s[2];
			s[2] = temp;
		}
		if(s[2]>s[3]){
			//如果第一个元素比第二个元素大，交换位置
			int temp = 0;
			temp = s[2];
			s[2] = s[3];
			s[3] = temp;
		}*/
		
		
	}}

5.掌握Arrays 常用的方法

    import java.util.Arrays;
    
    public class Demo {
	
	/*
	 * 功能：掌握Arrays类的常用方法
	 * 
	 * 
	 * Arrays:此类包含用来操作数组（比如排序和搜索）的各种方法。
	 * 从以下版本开始： 1.2 
	 * 
	 * 常见的5个方法
	 * 1：binarySearch()二分搜索法
	 * 2：sort()  数组排序
	 * 3：fill()  数组填充
	 * 4：copyOf()  数组拷贝
	 *    int[] newArr = Arrays.copyOf(arr, arr.length);
	 *     在堆中又开辟了一块新的空间，2个数组
		  int[] newArr = arr; //数组的地址符赋值  两个变量同时指向一块堆内存空间  1个数组
	 * 5：toString()  字符串拼接数组

	 */
	public static void main(String[] args) {
		
		int[] arr = {10,-100,45,88,99,22,14};
		//1 调用Arrays提供的sort方法
	/*	Arrays.sort(arr);
		
		System.out.println("最小值:"+arr[0]);
		System.out.println("最大值:"+arr[arr.length-1]);
		//打印数组
		System.out.println(Arrays.toString(arr));*/
		
		//2 调用toString方法  这个不是遍历数组，这个是把数组中每个元素用字符串拼接起来，打印在控制台
		/*System.out.println(arr);
		System.out.println(Arrays.toString(arr));*/
		
		//3:数组填充  调用Arrays的fill方法 ，恢复出厂设置
		//Arrays.fill(arr, 0);
		//System.out.println(Arrays.toString(arr));
		
		//4:数组拷贝 调用Arrays的copyOf方法
		//int[] newArr = Arrays.copyOf(arr, arr.length*2);
		
		//int[] newArr = arr; //数组的地址符赋值  两个边路同时指向一块堆内存空间
		
		//System.out.println("新数组:"+Arrays.toString(newArr));
	}	
}		

6二分法

public class Demo2 {


/*
 * 二分搜索法（折半查找）  前提是这个数组必须是有序的
 * Arrays.binarySearch()
 * 
 * 注意：二份搜索法：根据元素查找下标
 *   找到返回当前元素的下标，没有找到返回负数
 */


public static void myBinarySearch(int[] arr,int ele){
	//确保数组有序
	Arrays.sort(arr);
	
	//int[] arr = {-10,1,10,20,45,56,88}; 
	//定义开始和结尾的2个下标
	int start = 0;
	int end = arr.length;
	
	int index =-1;
	//保证开头下标不能超过结尾下标，否则数组就会越界
	int count = 0;
	while(start<=end){
		count++;
		int  mid = (start+end)>>>1; //折半点
		//如果目标元素和中间元素相等
		if(arr[mid]==ele){
			//把中间元素的下标赋值给index，代表找到这个元素的下标
			index = mid;
			//后面就不用比较了
			break;
			//如果目标元素比中间元素的值大
		}else if(ele>arr[mid]){
			//去数组的右边来找 并且，start变成mid+1的值，end值不变
			start = mid+1;
			//如果目标元素比中间元素的值小
		}else{
			//去数组的右边来找 并且，end变成mid-1的值，start值不变
			end = mid-1;
		}
		
	}
	
	System.out.println(count);
	if(index!=-1){
		System.out.println("元素:"+ele+"的下标是:"+index);
	}else{
		System.out.println("不存在此元素");
	}
	
	
}


public static void main(String[] args) {
	
	int[] arr = {10,20,45,-10,56,1,88}; //乱序数组
	myBinarySearch(arr,56);
	
	Arrays.sort(arr); //排好序的数组
	//{-10,1,10,20,45,56,88,100}
	
	int index = Arrays.binarySearch(arr, 500);
	System.out.println(index);
}

}

**

7.二维数组

**

public class Demo {
	
	/*
	 * 二维数组
	 *   1：定义，初始化
	 *   int[][] arr2 = new int[3][3];
	 *   第1个3代表这个二维数组是由3个一维数组构成的
	 *   第2个3代表每个一维数组的元素的个数有3个
	 *   
	 *   二维数组分类
	 *     1：规则二维数组：每个一维数组的元素个数相同
	 *     2：不规则二维数组：每个一维数组的元素个数不相同
	 *   2：遍历
	 *     普通for循环
	 *     for---each
	 *   3：内存分配
	 *   4：二维数组的转置
	 *   原二维数组
	 *     a   b    c   d
	 *     00  01   02  03
	 *     e f g h
	 *     j j k l
	 *     
	 *   新二维数组
	 *     a   e j
	 *     00
	 *     b f j
	 *     10
	 *     c g k
	 *     20
	 *     d h l
	 *     30  
	 *     
	 *   
	 *   
	 *   
	 *   二维数组的使用场合
	 *   1:2D游戏地图
	 *   2:省市联动
	 * 
	 */
	
	public static void main(String[] args) {
		
		String[][] pro = {
				{"武汉市","黄冈市","黄石市"},
				{"西安市","咸阳市","宝鸡市","延安市"}
		};
		
		//1：定义，初始化  动态初始化  根据数组的长度，确定数组的元素的个数
		/*int[][] arr3 = new int[3][3];
		arr[0][0] = 10;
		arr[0][1] = 20;
		arr[0][2] = 30;
		arr[1][0] = 40;
		arr[1][1] = 50;
		arr[1][2] = 60;
		arr[2][0] = 70;
		arr[2][1] = 80;
		arr[2][2] = 90;*/
		//2:静态初始化   根据元素的个数，确定数组的长度
		int[][] arr2 = new int[][]{{10,20,30},{40,50,60},{70,80,90}};
		//静态初始化  根据元素的个数，确定数组的长度
		int[][] arr = {
				        {10,20,30,100},
					    {40,50,60,110},
					    {70,80,90,120}
					    };
		//外层循环的次数是二维数组中一维数组的的个数  普通for循环
		for(int j = 0;j<arr.length;j++){
			//里层循环的次数是每一个一维数组元素的个数
			for(int i = 0;i<arr[j].length;i++){
				System.out.println(arr[j][i]);
			}
		}
	
		//双层   for-each
		System.out.println("---------------------");
		for (int[] is : arr) {
			for (int i : is) {
				System.out.println(i);
			}
		}
		
		
		//不规则二维数组  先确定一维数组的个数  ，动态初始化
		String[][] str = new String[3][];
		//分别给每个一维数组，赋予长度
		str[0] = new String[3];
		str[1] = new String[4];
		str[2] = new String[5];
		//静态初始化
		String[][] str2 = new String[][]{{"a"},{"b","c"},{"d","e","f"}};
		
		String[][]  str3 = {
				            {"a"},
							{"b","c"},
							{"d","e","f"}
							};
		
	
	}

}