JAVA基础语法-数组

跳转控制语句

break（在switch语句里用于结束语句 在循环里使用结束当前循环）
coutinue（跳过当次循环）
return（方法时讲）

/*
	跳转控制语句
	标号  名称:循环
*/
class JavaDemo{
    public static void main(String[] args) {
    	//打印5行7列星星
    	wc:for(int i=1;i<=5;i++){//外层---行数
	    	nc:for(int j=1;j<=7;j++){//内层---列数
	    		if(j==2)
	    		    break wc;   
		    	System.out.print("*");
	    	}
	    	//换行
	    	System.out.println();
    	}
    }
}

数组：

可以存储多个相同数据类型元素的容器

定义格式
1.数据类型 []数组名=new 数组类型[元素个数/数组长度];
int[] arr=new int[3];//指定长度
数据类型 名称=初始化;//定义变量
变量定义分为声明和初始化两个过程
可以分为声明和初始化两个过程
通过唯一的内存地址值（数组名）来确定数组，java自动给数组
元素进行编号（下标），从0开始。由内存地址值和下标就能唯一
确定数组里的元素—数组名[下标]

图一 数组内存地址图
2.数据类型[] 数组名=new 数组类型[]{元素值1，元素值2，……}；
int[] arr=new int[]{1,2,3};//给定数组元素值来确定长度不用
给定长度值
可以分为声明和初始化两个过程

3.数据类型[] 数组名={元素值1，元素值2，……}；
int[] arr={1,2,3};//给定元素值长度确定

/*

	数组的定义

*/
class ArrayDemo{
	public static void main(String[] args) {
		//1.定义数组
		int[] arr=new int[3];
		//给数组元素赋值
		//给数组的第一个元素赋值为10
		arr[0]=10;
		//声明
		int[] arr1;
		//初始化
		arr1=new int[5];
		//输出数组名(数组地址值)
		System.out.println(arr);
		//输出数组元素值
		System.out.println(arr[0]);
		//系统默认初始值
		System.out.println(arr[1]);//0
		
		//2.定义数组
		/*int[] arr=new int[]{1,2,3};
		//声明
		int[] arr1;
		//初始化
		arr1=new int[]{3,4,5};*/


		//3.定义数组
		//底层会默认开辟空间
		/*int[] arr={1,2,3};
		//声明
		int[] arr1;*/
		//初始化---报错，没有开辟内存空间无法存储元素
		//arr1={3,4,5};

new—开辟堆内存空间

java的内存

栈：存储的是变量（暂且），当存储内容使用完毕之后会立即清除
堆：存储的是对象，当存储内容使用完毕之后等到某个时刻进行回收

方法区（面向对象）
本地方法栈（不讲）
寄存器（程序计数器）

系统默认初始值
（byte，short，int—0），（char—‘\u0000’ \u代表以u16进行
编码），（long—0L），（float—0.0F），（double—0.0），
（boolean—false），（引用数据类型—null）

图二 一个数组内存

图三 两个数组内存图
系统默认初始值优先于程序初始值先存在

图四 三个数组内存图

两个引用指向同一个堆内存----共享

数组的应用

1.遍历----依次把数组元素进行输出

/*
	数组遍历
*/
import java.util.Arrays;
class ArrayBianLi{
	public static void main(String[] args) {
		//定义数组
		int[] arr={2,4,1,6,9,5};
		//普通for循环实现遍历
		//数组名.length---返回数组长度值
		/*for(int i=0;i
		//增强for循环
		//(元素类型 变量名:要去遍历的数组名)
		//把数组元素拷贝赋值给新变量来输出新变量值
		/*for(int i:arr){
			System.out.println(i);
		}*/


	 	//展示数组元素内容---遍历输出
		System.out.println(Arrays.toString(arr));
	}
}

2.最值----求出数组元素的最大/小值

/*
	求最值
*/
class ArrayMaxDemo{
	public static void main(String[] args) {
		//定义数组
		int[] arr={4,2,1,7,9,5};
		//选取第一个元素当做参照物
		int max=arr[0];
		//遍历数组
		for(int i=1;i<arr.length;i++){//下标范围
			//判断大小
			if(arr[i]>max){
				max=arr[i];
			}
		}
		System.out.println(max);
	}
}

3.查找—给定查找数返回数组第一次出现下标值

/*
	数组查找
*/
class ArraySearchDemo{
	public static void main(String[] args) {
		//定义数组
		//int[] arr={1,7,3,2,5,8};//无序数组
		int[] arr={1,2,3,5,7,8};//有序数组
		//给定查找数
		int num=8;
		/*//遍历数组，依次比较(增强for实现---晚自习)
		for(int i=0;i
		//二分查找
		//提供三个下标
		int min=0;
		int max=arr.length-1;
		int mid=(min+max)/2;
		//循环范围不确定
		while(arr[mid]!=num){//中间下标对应的元素值和查找数不相等
			//如果num大于中间下标对应的元素值
			if(num>arr[mid]){
				min=mid+1;
			}
			//如果num小于中间下标对应的元素值
			if(num<arr[mid]){
				max=mid-1;
			}
			//查找数不在数组判断条件
			if(min>max){
				System.out.println("查无次数");
				//结束循环
				break;
			}
			//重新计算中间下标
			mid=(min+max)/2;
		}
		//输出
		if(max>=min)
		System.out.println(mid);	
	}
}

图五 二分查找

4.排序—给元素值排列顺序

冒泡

/*
 	冒泡排序
*/
import java.util.Arrays;
class ArrayMaoDemo{
	public static void main(String[] args) {
		//定义数组
		int[] arr={6,1,7,3,9,2};
		//通过嵌套循环实现
		for(int i=1;i<arr.length;i++){//外层循环-控制轮数
			for(int j=1;j<=arr.length-i;j++){//内存循环-控制参与比较的元素范围
				//两两比较 j j+1  j-1 j（都可以）
				//升序排序---小的在前面
				if(arr[j-1]>arr[j]){
					//交换值
					int temp=arr[j-1];
					arr[j-1]=arr[j];
					arr[j]=temp;
				}
			}
		}
		System.out.println(Arrays.toString(arr));	
	}
}

图六 冒泡排序

选择

/*
	选择排序
*/
import java.util.Arrays;
class ArrayChooseDemo{
	public static void main(String[] args) {
		//定义数组
		int[] arr={6,1,7,3,9,2};
		/*//通过嵌套循环实现
		for(int i=1;iarr[j]){
				    //交换值
				    int temp=arr[i-1];
			        arr[i-1]=arr[j];
			        arr[j]=temp;
			    }	
			}
		}*/
		//java提供的排序
		Arrays.sort(arr);
		//输出
		System.out.println(Arrays.toString(arr));
	}
}

图七 选择排序

5.扩容

扩容—数组定义完成长度无法改变—数组复制

/*
	数组扩容
*/
import java.util.Arrays;
class ArrayKuoDemo{
	public static void main(String[] args) {
		//定义原数组
		int[] arr={1,2,3,4,5};

		//根据新数组之间的复制来实现扩容

		//复制灵活（给定起始位置）但是使用麻烦
		/*//新数组
		int[] arr1=new int[2*arr.length];//确定扩容之后的长度
		//数组复制
		//(原数组，原数组的起始下标,新数组,新数组起始位置,元素个数)
		System.arraycopy(arr,0,arr1,0,arr.length);
		//新数组地址值覆盖原数组的地址值
		arr=arr1;*/

		//由上述三步实现的
		//使用简单但是只能从头（下标0）开始复制（不灵活）
		//(原数组，新数组长度)
		arr=Arrays.copyOf(arr,2*arr.length);

		//输出
		System.out.println(Arrays.toString(arr));
		
	}
}