Java的学习笔记（05）数组
数组01：什么是数组 数组是同类型数据的集合
数组的下标从0开始
数组02：数组的声明和创建 首先必须声明数组变量，才能在程序中使用数组。
dataType[] arrayRefVar; //首选方法 或 dataType arrayReVar[]; java语言使用new操作符来创建数组，语法如下：
dataType[] arrayReVar = new dataType[arraySize]; package array;
public class ArrayDemo01 {
public static void main(String[] args) {
//变量类型 变量名字 = 变量的值；
//数组类型
int[] nums; //首选方法√
int nums2[]; //不是首选方法
//new一个数组
nums = new int[10]; //长度为10的int类型数组；或者说这个数组可以存放10个int类型数据
}} package array;
public class ArrayDemo01 {
public static void main(String[] args) {
//变量类型 变量名字 = 变量的值；
//数组类型
int[] nums; //首选方法√ 声明一个数组
nums = new int[10]; //创建一个数组
nums[0]= 1; //给数组元素中赋值
nums[1]= 2;
nums[2]= 3;
nums[3]= 4;
nums[4]= 5;
nums[5]= 6;
nums[6]= 7;
nums[7]= 8;
nums[8]= 9;
nums[9]= 10;
//计算所有元素的和
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println(sum);
}} 经典二合一
// int[] nums; //首选方法√ 声明一个数组 // nums = new int[10]; //创建一个数组
int[] nums = new int[10]; //经典二合一获取数组的长度 arraty.length 数组名.length
数组03：三种初始化及内存分析 静态初始化
动态初始化
数组的默认初始化
package array;
public class ArrayDemo02 {
public static void main(String[] args) {
//静态初始化: 创建+赋值
int[]a = {1,2,3,4,5,6,7,8,9};
Man[] men = {new Man(1,1),new Man(2,2)};
//动态初始化:包含默认初始化
int[]b = new int[10];
}} 数组04：下标越界及小结 数组一旦被创建，长度大小不可改变。
数组元素必须是相同类型，不允许出现混合类型。
数组元素可以是任何数据类型，包括基本类型和引用类型。
数组属于引用类型，数组也可以看作是对象，数组的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
数组05：数组的使用 package array;
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arrsys = {1,2,3,4,5};
for (int i = 0; i < args.length ; i++) {
System.out.println(arrsys[i]);
}
int sum = 0;
for (int i = 0; i < arrsys.length; i++) {
sum +=arrsys[i];
}
System.out.println("sum=" + sum);
int max =arrsys[0];
for (int i = 0; i < arrsys.length; i++) {
if (arrsys[i]>max){
max=arrsys[i];
}
}
System.out.println("max=" + max);
}} package array;
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//直接for循环，无下标
for (int array : arrays){
System.out.println(array);
}
printArrsy(arrays);
System.out.println( );
System.out.println("========================");
int[] reverse = reverse(arrays);
printArrsy(reverse);
}
//打印数组元素
public static void printArrsy(int[] arrays){
for(int i = 0; i<arrays.length;i++){
System.out.print(arrays[i]+" ");
}
}
//反转数组
public static int[] reverse(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;
}} 数组06：二维数组、多维数组 package array;
public class ArratDemo05 {
public static void main(String[] args) {
int[][] array = {{1,2},{2,3},{3,4},{4,5}};
/**
* array[0][0] = 1 array[0][1] = 2 {1,2}
* array[1][0] = 2 array[1][1] = 3 {2,3}
*/
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}} 数组07：Arrays类讲解 数组的工具类 java.util.Arrays
package array;
import java.lang.reflect.Array; import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] array = {1,2,36565,895645,5648754,87,68,12,3};
System.out.println(Arrays.toString(array)); //打印数组全部内容
Arrays.sort(array); //数组排序，从小到大
System.out.println(Arrays.toString(array));
Arrays.fill(array,0);
System.out.println(Arrays.toString(array));
}} 查看JDK帮助文档，知道具体方法。
给数组赋值 fill方法 对数组排序 sort方法 比较数组 equals方法 查找数组元素 binarySearch方法（能对排序好的数组进行二分查找） 数组08：冒泡排序 八大排序算法之一
package array;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
//冒泡排序
int[] a = {1,3,6,2,9,8,0};
int[] sort = sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array){
int temp = 0;
for (int i = 0; i < array.length-1; i++) {
boolean flag = false;
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;
flag = true;
}
}
if (flag==false){
break;
}
}
return array;
}} 数组09：稀疏数组 数据结构的内容，减少存储空间的使用
for .each循环，遍历数组的简单写法。
for(int[] ints : 数组名){
} package array;
public class ArrayDemo08 {
public static void main(String[] args) {
int[][] array1 = new int[11][11];
array1[1][2]=1;
array1[2][3]=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 < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j]!=0){
sum++;
}
}
}
//创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组，将非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("==============================");
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]+"\t"
);
}
System.out.println("==============================");
//读取稀疏数组
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+"\t");
}
System.out.println();
}
}}