一.一维数组
数组的基本特点：
1.长度是确定的，数组被创建后是不可改变大小的
2.数组元素必须是相同类型
3.元素可以是任何数据类型，包括基本数据类型和引用类型
4.数组属于引用类型，数组也可看成对象，数组中每个元素相当于该对象的成员变量，因此数组一经分配空间，其中每个元素也被按照和实例变量同样的方式被隐式初始化，同时数组本身就是对象(new一个对象)，而Java的对象本身就在堆当中，因此初始化的数组在堆中。
声明和初始化：
//数组nums声明
int[] nums;
//数组初始化,new说明开辟了10个空间
nums=new int[10];
//数组赋值，不赋值会自动赋默认值，如int类型默认值是0
nums[0]=10;
//注意这种写法是错误的：
int[] nums;//定义数组为int 类型
nums={1,2,3};//报错了！！！！！！！！
总结声明和初始化：
1.静态初始化：创建+赋值
int[] a={1,2,3,4,5,6};
2.引用类型，新建一个Man.java文件，里面有一个叫Man的类
Man[] men={new Man(),new Man(),new Man()...};
3.动态初始化:包含默认初始化
int[] b=new int[10];
b[0]=10;
数组的使用：
一维数组的使用：1.直接打印；2.数组作为形式参数传递给方法；3.反转打印
public class arraydemo01 {
public static void main(String[] args) {
int[] a={1,2,3,4,5};
//数组的使用-直接打印
for (int i : a) {
System.out.println(i);//直接打印
}
//数组的使用-数组可作为方法参数
printArray(a);
//数组的使用-反转数组
reverse(a);
}
public static void printArray(int[] a){
for(int i=0;i<a.length;i++){
System.out.print(a[i]);
}
}
public static void reverse(int[] a){
for(int i=a.length-1;i>=0;i--){
System.out.println(a[i]);
}
}
}扩展：
声明和初始化时数组在计算机的内存分配情况
二.多维数组（只了解二维）
直接声明+初始化：
int[][] array={ {1,2},{2,3},{3,4}};
输出方式：
1.直接打印； 2.通过将数组传参给方法
代码实践：
package base;
public class arrarydemo02 {
public static void main(String[] args) {
//1.二维-直接声明+初始化
int[][] nums={
{1,2},{3,4},{5,6}};
//2.随便输出一些测试
System.out.println(nums[0][0]);
System.out.println(nums[0]); //输出哈希码，是地址
System.out.println(nums.length);//输出3
System.out.println(nums[0].length);//输出2
//3.直接输出每个元素
for(int i=0;i<nums.length;i++){
for(int j=0;j<nums[i].length;j++){
System.out.println(nums[i][j]);
}
}
//4.通过调用方法输出部分
System.out.println("=================");
printArray(nums[0]);
}
public static void printArray(int[] a){
for(int i=0;i<a.length;i++){
System.out.println(a[i]+" ");
}
}
}
三.Java里的Arrays类（Java提供很多方便的方法，可在Java的API文档里找)
使用arrays的方法需要导入工具类：
import java.util.arrays
这里学习几个方法就好：
1.Arrays.toString():作用是将括号内容通过字符串形式打印
2.Arrays.sort():对数组元素进行升序排序
3.Arrays.fill():将括号内涉及的元素变为0
注意输出要用Arrays.toString()方法
代码实践：
输出结果:
四.冒泡排序
冒泡不论是理解还是怎么样都要记住，冒泡使用频率很高，多写几次代码差不多就掌握了，之前写的例子可以帮助理解：
键盘输入这n个数字分别是 2 3 1 1
for (int i = 0; i < n - 1; i++) {# i的所有遍历值为 0 1 2
for (int j = 0; j < n - 1 - i; j++) {#当i=0时，j的所有遍历值为 0 1 2；当i=0时，j的所有遍历值为 0 1 ；当i=0时，j的所有遍历值为 0 ；
i=0且j=0时，a[j]=a[0]=2 a[j+1]=a[1]=3 不满足if条件，a[j]与a[j+1]不交换位置 数组a[100]: 2 3 1 1
i=0且j=1时，a[j]=a[1]=3 a[j+1]=a[2]=1 满足if条件，a[j]与a[j+1]交换位置 数组a[100]: 2 1 3 1
i=0且j=2时，a[j]=a[2]=3 a[j+1]=a[3]=1 满足if条件，a[j]与a[j+1]交换位置 数组a[100]: 2 1 1 3
i=1且j=0时，a[j]=a[0]=2 a[j+1]=a[1]=1 满足if条件，a[j]与a[j+1]交换位置 数组a[100]: 1 2 1 3
i=1且j=1时，a[j]=a[1]=3 a[j+1]=a[2]=1 满足if条件，a[j]与a[j+1]交换位置 数组a[100]: 1 1 2 3
i=2且j=0时，a[j]=a[0]=3 a[j+1]=a[1]=1 满足if条件，a[j]与a[j+1]不交换位置 数组a[100]: 1 1 2 3
练习代码
五.稀疏数组
用来记录有效坐标
当一个数组中大部分元素为0或者为同一值时，可使用稀疏数组来压缩空间。
处理方式：
记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列存放在一个小规模的数组中，起到压缩作用
如
原始数组：
0 0 0 0 0
0 1 0 0 0
0 0 2 0 0
0 0 0 0 0
0 0 0 0 0
这个5*5的数组只有1，2两个有效值，其余都是0，
保存在稀疏数组中：
| 行 | 列 | 值 | |
| [0] | 5 | 5 | 2 |
| [1] | 1 | 1 | 1 |
| [2] | 2 | 2 | 2 |
第[0]行表示数组有5行5列，有效值个数是2
第[1]行表示在数组的第1行第1列有数值1
第[2]行表示在数组的第2行第2列有数值2
练习（反复练习）
思路：将原始数组压缩成稀疏数组，再将稀疏数组还原成原始数组
代码:
package array;
public class arraydemo05 {
public static void main(String[] args) {
//创建5*5数组
int[][] array1=new int[5][5];
array1[1][1]=1;
array1[2][2]=2;
//输出原始数组
System.out.println("输出原始数组:");
for (int[] ints:array1){
for(int anInt:ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
//转换成稀疏数组保存：
//先获得原始数组有效值个数
int sum=0;//记录有效值个数
for(int i=0;i<5;i++){
for (int j=0;j<5;j++){
if(array1[i][j]!=0){
sum++;
}
}
}
//创建稀疏数组
int[][] array2=new int[sum+1][3];
array2[0][0]=5;
array2[0][1]=5;
array2[0][2]=sum;
//遍历array1，把原始数组非0值放在稀疏数组
int count=0;
for (int i=0;i<array1.length;i++){
for(int j=0;j<array1[i].length;j++){
if(array1[i][j]!=0){
count++;
array2[count][0]=i;
array2[count][1]=j;
array2[count][2]=array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("输出稀疏数组:");
for(int i=0;i<array2.length;i++){
System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]);
}
//还原，根据稀疏数组输出原始数组
int[][] array3=new int[array2[0][0]][array2[0][1]];//数组大小
for(int i=1;i<array2.length;i++){
array3[array2[i][0]][array2[i][1]]=array2[i][2];
}
//输出还原数组
System.out.println("输出还原数组:");
for(int[] ints:array3){//先一维一维输出
for(int anInt:ints){//再一个一个输出
System.out.print(anInt+" ");
}
System.out.println();
}
}
}
运行结果：
