12-数组

数组: 数组是一个变量,存储相同的数据类型的一组数据

相同的类型的若干个数据,按照一定的先后顺序排列组合而成,每个数据称为数组元素
语法:
1. 声明数组 : -->跟内存打招呼
  1. 数据类型 [] 数组名; --常用
  2. 数据类型数组名 [];
2. 分配空间
  
  数组名 = new int[数组的长度];
3. 赋值
  
  数组名[下标] = 值;
特点:
1. 数组中存储的数据类型相同
2. 长度一旦设定就不能在更改
3. 数组是引用数据类型,分为两块存储,栈中声明,堆中开空间
4. 数组是通过下标(索引)访问数据的,下标是从0开始
5. 数组的长度-1等于最大下标
6. 会产生下标越界异常

public class ArrayDemo01 {

	public static void main(String[] args) {   
		//[1]声明/定义数组
		int[] a;    
		//int b[];
		//[2]分配空间
		a = new int[5];   //在堆中开辟空间,把地址给a
		int[] b = new int [3];   //声明一个int类型的数组b长度为3;
		double [] d = new double[4];
		String [] s = new String [2];
		char [] c = new char[100];
		b= new int [10];   
		//[3]赋值
		a[0] =12;
		a[1]=11;
		b[2] = 'a';
		//a[0]
		System.out.println("b[2]="+b[2]);
	}
}

静态赋值: 在程序运行之前,这个值就已经确定了
1. 数据类型 [] 数组名 = {值1,值2,值3…};
2. 数据类型 [] 数组名 = new 数据类型 [] {值1,值2,值3,值4…};
动态赋值: 在程序运行之前,不知道什么数据,在程序运行时,由用户手动输入
1. 声明数组,设定[5]
2. Scanner 对象输入
3. for循环,循环接收与数组长度一致的整数
断点介绍

F5: 单步调试,进入方法的内部

F6: 单步调试,执行当前代码

F7: 由方法内部返回到调用

F8: 一直执行到下一个断点

public class ArrayDemo02 {

	public static void main(String[] args) {
		//静态赋值
	/*	int [] arry2 = {11,22,33,44,55};
		int [] arry1 = new int []{78,90,67,45};
		System.out.println(arry2);*/
		/**
		 * 动态赋值
		 */
		int [] arry = new int [5];
		Scanner input = new Scanner(System.in);
		for(int i =0;i<arry.length;i++){    
			System.out.println("请输入"+(i+1)+"个数:");
			arry[i] = input.nextInt();
		}
	}
}

循环遍历数组:
1. 编写一个输出数组元素的方法
2. for循环条件
3. 输出数组元素

public class ArrayDemo {

	   public static void printArray(int [] arr){  //形参
		   
		   for(int i = 0;i<arr.length;i++){
			   System.out.println(arr[i]+"\t");
		   }
		   
	   }
	   public static void main(String[] args) {
		 int [] arry = {11,22,33,44,55,66};  //静态赋值
		 int [] arr = {566363,464};
		 printArray(arry); 
		 printArray(arr);
	}
	
}

加强for循环: 好处: 不存在下表越界异常

for(数组中元素的类型 变量名 : 要遍历的数组的数组名){
    
}

public class ArrayDemo03 {
	public static void main(String[] args) {
		int [] arry ={11,22,33,44,55};
		for(int i = 0;i<arry.length;i++){
			System.out.println(arry[i]+"\t");  //容易出现下标越界
		}
		System.out.println("=============================");
		//加强for循环  -->foreach   -->1.5
		for(int a : arry){   //每次从数组中取出一个元素给a
			System.out.println(a+"\t");  //作用:只能用来遍历,不可以循环赋值
		}
	 String[] s = new String[2] ; 
	}
}

排序:
1. 升序: Arrays.sort(数组名); java.util.Arrays
2. 倒序: 如下

public class ArrayDemo04 {

	public static void main(String[] args) {
		//
		int [] arry = {1,2,512,3,567,55};
		Arrays.sort(arry);   //首字母大写:类名   ,类名点   :静态的变量
		for(int b : arry){
			System.out.print(b+"\t");
		}
		System.out.println("\n=========================");
		//倒叙:倒着输出         降序:从大到小
		for(int i = arry.length-1; i>=0;i-- ){
			System.out.print(arry[i]+"\t");
		}
	}
}

数组如何赋值

public class ArrayDemo05 {
	public static void main(String[] args) {
		int [] a = {11,22,33,44};
		int [] b = new int [5];
		System.out.println(b.length);
		System.out.println(a);
		//b=a;   //赋值内存地址
		System.out.println(b.length);
		System.out.println(a);
        
		//循环赋值
		for(int i = 0;i<a.length;i++){
			b[i]=a[i];  //对应位置上的元素赋值
		}
		System.out.println("=============================");\
            
		//遍历
		for(int i = 0;i<b.length;i++){
			System.out.print(b[i]+"\t");
		}
	//	System.out.println(b.length);	
	}
}

12-数组

12-数组

猜你喜欢