Java06_数组

数组

相同类型数据的有序集合

相同类型的若干个数据，按照一定的先后次序排列组合而成

每一个数据称为一个数组元素，通过下标访问

声明与创建

//声明数组变量
dataType[] arrayRefVar;
dataType arrayRefVar[];
//创建数组
dataType[] arrayRefVar=new dataType[arraySize];

public class Demo1 {
	public static void main(String[] args) {
		int []a;//声明
		a=new int[10];//创建
		int sum=0;
		Scanner scanner=new Scanner(System.in);
		for(int i=0;i<a.length;i++) {
			a[i]=scanner.nextInt();
			System.out.print(a[i]+" ");
		}//录入数组元素的值
		for(int j=0;j<a.length;j++) {
			sum=sum+a[j];
		}
		System.out.print("\n数组的和为："+sum);
		scanner.close();
	}
}

特点

• 长度是确定的，一旦创建大小不可改变

• 元素必须是相同类型不能是混合类型

• 数组中的元素可以是任何数据类型--基本数据类型、引用数据类型

• 数组变量属于引用类型，数组也可以看作对象，数组中的每个元素相当于该对象的成员变量

• 数组边界--下标的合法区间：[0,lengh-1]

数组的使用

1. for-each

   public class Demo2 {
   	public static void main(String[] args) {
   		int[]arrays= {1,2,3,4,5};
   		for(int array:arrays) {
   			System.out.print(array+" ");
   		}
   	}
   }
   

2. 数组做方法入参

3. 数组作返回值

   public class Demo2 {
   
   	public static void main(String[] args) {
   		int[]arrays= {1,2,3,4,5};
   		printArrays(arrays);
   		System.out.println();
   		reverseArrays(arrays);
   	}
       //打印数组元素
   	public static void printArrays(int []arrays){
   		for(int i=0;i<arrays.length;i++) {
   			System.out.print(arrays[i]+" ");
   		}
   	}
       //反转数组元素
   	public static void reverseArrays(int []arrays) {
   		for(int i=arrays.length-1;i>=0;i--) {
   			System.out.print(arrays[i]+" ");
   		}
   	}
   }
   
   

二维数组

int a[][]=new int[2][5];
//二行五列的数组

public class Demo3 {
    //打印二维数组
	public static void main(String[] args) {
		int [][]array= {{1,2},{2,3},{3,4},{4,5}};
		for(int i=0;i<array.length;i++) {
			for(int j=0;j<array[i].length;j++) {
				System.out.println(array[i][j]);
			}
		}
	}
}

Arrays类

import java.util.Arrays;

Arrays类中的方法都是static修饰的静态方法，使用时可以直接使用类名调用，而不用使用对象调用

功能

• 给数组赋值 fill方法
• 对数组排序 sort方法，升序
• 比较数组 equals方法比较数组中的元素值是否相等
• 查找数组元素 binarySearch方法能对排序好的数组用二分法查找

import java.util.Arrays;
public class ArraysDemo {
	public static void main(String[] args) {
		int []a= {1,2,3,4,567,3457,23,7,0};
		int []b=new int[6];
		System.out.println(a);
		System.out.println(Arrays.toString(a));
		//排序
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
		//赋值
		Arrays.fill(b, 0);//数组所有都被0覆盖
		System.out.println(Arrays.toString(b));
		Arrays.fill(a,2,4,0);//数组的2-4被0覆盖
		System.out.println(Arrays.toString(a));
		}
}

冒泡排序

1. 比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换位置
2. 每次比较产生出一个最大，或者最小的数字
3. 下一轮则少一次排序
4. 依次循环直到结束

import java.util.Arrays;
public class Demo4 {
	public static void main(String[] args) {
		int []a= {1,4,5,6,8,56,3,3,3,7,54};
		int []sort=sort(a);
		System.out.println(Arrays.toString(a));
	}
	//冒泡排序
	public static int[] sort(int[]array) {
		//外层循环，判断要走多少次
		int temp=0;
		for(int i=0;i<array.length-1;i++) {
			//内层循环，比较数组中两个相邻的元素，
			//如果第一个数比第二个数大，就交换位置
			for(int j=0;j<array.length-1-i;j++) {
				if(array[j+1]<array[j]) {
					temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
				}
			}
		}
		return array;	
	}
}