数组

• 数组是相同类型数据的有序集合。
• 其中每个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。
• 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的。
• 数组对象本身是在堆中

数组的声明和创建

1. dataType [ ] array=new dataType [size]; //首选的方法
2. dataType array[ ]=new dataType [size]; //不推荐
3. 也可以直接赋值 int[ ] arr={1,2,3};
4. 例如 int [ ] nums=new int[10]; 取值num[i]
5. array.length获取数组长度

数组的使用

public class test {
	public static void main(String[] args) {
		int[] arrays = { 1, 2, 3 };
		printf(arrays);
		System.out.println();
		//增强for循环
		/*for (int arr : arrays) {
			System.out.println(arr);
		}*/
		//反转
		printf(reserve(arrays));
	}
	//传参
	public static void printf(int[] arrays){
		for(int i=0;i<arrays.length;i++) {
			System.out.print(arrays[i]+" ");
		}
	}
	//反转
	public static int[] reserve(int[] arrays) {
		int[] result=new int[arrays.length];
		for(int i=0,j=result.length-1;i<arrays.length;i++,j--) {
			result[j]=arrays[i];
		}
		return result;
	}
}

内存分析

• 堆

• 栈

• 方法区

  静态初始化

  1. int [ ]array=null;

  2. 引用类型的 有一个类叫Men Men [ ]mans={new Man(),new Man()}; **

  动态初始化

  1. int [ ]b=new int[10 ];
  2. 默认初始化 值都是0

  ---

小结

• 下标的合法区间：【0，length-1】，如果越界就会报错，ArrayIndexOutofBounds
• 数组也是对象
• 数组是相同数据类型（数组类型可以为任意类型）的有序集合

二维数组

//定义 
int a[][]=new int[2][5];
//可以看成2行5列的数组
//创建 
int a[][]={{1,2},{2,3}};
//没定义的都是0
//取值
arr[0][1]=2

代码演示

public class test {
	public static void main(String[] args) {
		int a[][] = { { 1, 2 }, { 2, 3 }, { 3, 4 }, { 4, 5 } };
		System.out.println(a.length);// 4
		System.out.println(a[0].length);// 2
        //遍历
		for(int i=0;i<a.length;i++) {
			for(int j=0;j<a[j].length;j++) {
				System.out.println(a[i][j]);
			}
	
		}
	}
}

Arrays类

• 数组的工具类 java.util.Arrays

import java.util.Arrays;

public class test {
	public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4, 546, 876, 456, 23 };
		System.out.println(a);// [I@372f7a8d
		// 打印数组元素 Arrays.toString()
		String a1 = Arrays.toString(a);
		System.out.println(a1);// [1, 2, 3, 4, 546, 876, 456, 23]

		// Arrays.toString()可以自己写个工具类和他效果差不多
		printArray(a);
		System.out.println();

		// 排序Arrays.sort(a)
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));// [1, 2, 3, 4, 23, 456, 546, 876]

		// Arrays.fill() 填充 都是0
	/*	Arrays.fill(a, 0);
		System.out.println(Arrays.toString(a));// [0, 0, 0, 0, 0, 0, 0, 0] */
		Arrays.fill(a, 2, 4, 0);//第二个到第三个赋值为0  区间[2,4)
		System.out.println(Arrays.toString(a));//[1, 2, 0, 0, 23, 456, 546, 876]
	}

	// 自己写的工具类
	public static void printArray(int[] a) {
		for (int i = 0; i < a.length; i++) {
			if (i == 0) {
				System.out.print("[");
			}
			if (i == a.length - 1) {
				System.out.print(a[i] + "]");
			} else {
				System.out.print(a[i] + ", ");
			}
		}
	}

}

冒泡排序

import java.util.Arrays;

public class test1 {
	public static void main(String[] args) {
		// 1.比较数组中，两个相邻的元素，如果第一个数大于第二个大，我们就交换他们的位置
		// 2.每一次比较，都会产生出一个最大，或者最小的数字
		// 3.下一轮可以少一次排序
		// 4.依次排序，直到结束！
		int[] a = { 1, 4, 5, 87, 32, 456, 2, 4, 45 };
		int[] sort = sort(a);
		System.out.println(Arrays.toString(sort));
		//结果 [1, 2, 4, 4, 5, 32, 45, 87, 456]
	}

	public static int[] sort(int[] array) {
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length - 1; j++) {
				if (array[j + 1] < array[j]) {//符号变'>' 结果从大到小
					// 临时变量
					int temp = 0;
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
		return array;
	}
}