Java-数组

数组

0、是一种数据结构。是按照一定顺序存放，同种元素的集合

1、定长的，不能改变长度，灵活性差

2、数组是可保存一族数据的数据结构，本身也占用一个内存地址，故是引用类型。

例如，用来存储80个人的成绩。有一个共同的数组名字，然后用索引区分。索引来访问元素 赋值 取值。

数组的存放原理

0、数组名字是一个指针，存在一列里，这一列叫做栈。指针就是告诉你，东西存在哪里

1、指针，告诉你第一件放在哪，其他的都是挨着放的，所以很清晰。

2、数组保存的东西是像装在个仓库的，这一列叫做堆。

数组的定义

格式1：

type[] array;

int[] a;

格式1：

type array[]; //迎合C语言的习惯

double b[];

数组初始化

0、声明数组了，实际并未赋值。

1、初始化 就是让数组名指向数组存放的东西

2、该过程有： 给数组中的元素分配空间和赋值，然后是对数组名字的赋值 然后为数组引用（相连接）。

3、初始化有两种：静态、动态

静态初始化

就是—— 一开始就给数组每个元素赋值

两种

//1、声明再初始化：
int[] array;
arrray = new int[]{1,2,3,4,5};

//2、声明又初始化同时进行
int[] arry = new int[]{1,2,3,4,5};

一般简写：

int[] array = {1，2，3，4，5}；

动态初始化

就是—— 我只给出数组长度，系统来赋值

int[] array = new int[10];

数组的常用操作

1、获取数组长度

array.length

例如

int[] list = new int[10];
int size = list.length;

2、遍历数组

用for循环+array[i]打印每个元素。

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

3、得最大最小值

public class Test{
	public static void main(String[] args){
		int[] list = {1,2,3,4,5};
		int max = 0;
		int min = 0;
		max = min = list[0];//给max、min都赋上list[0]
		for(int i =0;i<list.length;i++)
			{
				if(list[i]>max){max =list[i];}
				if(list[i]<min){min =list[i];}
			}
	System.out.println("max:" + max);								System.out.println("min;" + min);
	}
}

4、排序 冒泡排序

Bubble Sort

可以清晰地看到，每一次大排序过后，都有一个元素沉底（大的放到应在的位置）

package test1;
public class Class1 {
public static void  main(String[] args){
//送你一个乱序的数组
	int[] list = {4,3,1,5,2};
	int smallcount = 0;
	
//bubble sort
	for(int i=0;i<list.length-1;i++){ //共有list.length个元素，两两比较，则list.length-1次大的
		for(int j=0;j<list.length-1-i;j++) { //每次沉底一个元素，则对于小循环：list.length-1-i
			if(list[j]>list[j+1]) {
				//相邻的两个元素的大小比较，小的放前面，大的放后面
				int temp = list[j];
				list[j] = list[j+1];
				list[j+1] = temp;
				
				for(int a=0;a<list.length;a++) {
					System.out.print(list[a]+"\t");
				}				
				smallcount++;
				System.out.print("这里是第"+ smallcount +"次小排序的结果\n");	
			
			}
			
			
		}
		System.out.print("\t"+"\t"+"这里是第"+ (i+1) +"次大排序的结果\n");	
	}
}}

3	4	1	5	2	这里是第1次小排序的结果
3	1	4	5	2	这里是第2次小排序的结果
3	1	4	2	5	这里是第3次小排序的结果
		这里是第1次大排序的结果
1	3	4	2	5	这里是第4次小排序的结果
1	3	2	4	5	这里是第5次小排序的结果
		这里是第2次大排序的结果
1	2	3	4	5	这里是第6次小排序的结果
		这里是第3次大排序的结果
		这里是第4次大排序的结果

5、数组复制

因为数组名保存是数组的首地址

复制给另一个的时候复制的，也是首地址

所以这样直接复制得到的还是原来的数组

如果要复制。可以用System类里面的arraycopy() 或者是clone()

二维数组

声明

int[][] array;
int array[][];

初始化

当定义一个二维数组。

定义的是三条横着的数组，每个有两个空间

array = new int[3][2];
array[0];//第0行--有两个空间

锯齿数组

package test1;



public class Class1 {
public static void  main(String[] args){
	int[][] a = {{1,2,3},{4,5,6}};
	System.out.println("该数组的一维长度："+a.length);
	System.out.println("该数组的二维总长度："+a[0].length+ "+" + a[1].length);
	int b[] = {1,23,4,56};
	int s[];
	s = b;
	for(int i= 0;i<s.length;i++)
	System.out.print(s[i] +"." );
}}

该数组的一维长度：2
该数组的二维总长度：3+3
1.23.4.56.

很多坑

静态初始化

package test1;

public class Class1 {
public static void  main(String[] args){
	System.out.println("锯齿数组-静态的初始化：");}

	int[][] array={
			{1,2,3,4,5},
			{2,3,4,5},
			{3,4,5},
			{4,5},
			{5}
	};
	//打印
	for(int i =0;i<array.length;i++){
		for(int j=0;j<array[i].length;j++){
			System.out.print(array[i][j]+"\t");}
		System.out.println("OK!");}
}
}

动态的初始化

package test1;

public class Class1 {
public static void  main(String[] args){
	System.out.println("锯齿数组-动态的初始化：");
	int[][] x = new int[5][];
	x[0] = new int[5];
	x[1] = new int[4];
	x[2] = new int[3];
	x[3] = new int[2];
	x[4] = new int[1];
	
	//已有一个静态的
	int[][] array={
			{1,2,3,4,5},
			{2,3,4,5},
			{3,4,5},
			{4,5},
			{5}
	};
	//把array[][]赋给x[][]
	for(int i =0;i<array.length;i++){
		for(int j=0;j<x[i].length;j++){
			x[i][j] = array[i][j];}
	}

	//print x[][]
	for(int i =0;i<array.length;i++){
		for(int j=0;j<x[i].length;j++){
			System.out.print(x[i][j]+"\t");
		}
		System.out.println("OK!");}
	}
}

好的这就是锯齿数组
0	0	0	0	0	OK!
0	0	0	0	OK!
0	0	0	OK!
0	0	OK!
0	OK!