java基础梳理六：数组

数组：Array，存储同一种数据类型的多个元素的容器


// 注意：【数组是引用数据类型，基本数据类型都是值类型】


// 数组的声明形式：
// 形式1：数据类型[] 数组名（要求大家使用这种形式）：声明了一个xxx数据类型的数组，名字叫yyy
// 形式2：数据类型 数组名[] ：声明了一个xxx数据类型，名字叫yyy的数组


// 声明一个成绩数组
// int[] scoreArr;
// int scoreArr[]; // 语法ok，但是不建议


 数组变量使用前必须初始化


// 数组初始化的形式：
1、动态初始化：由使用者设置数组的长度，再填充元素
数据类型[] 数组名 = new 数据类型[数组的长度]


// A：new关键字用来在内存的堆(Heap)中开辟一块空间
// B：数组的长度是有使用者设置的
// C：用数组的下标（索引）来表示数据中元素的位置，下标（索引）从0开始，到数组的长度-1结束
// D：数组的长度也就是描述数组中元素的个数


2、静态初始化：由使用者填充元素，由系统计算数组的长度
①、简写格式：
数据类型[] 数组名 = { 元素1, 元素2, ... , 元素n }
②、完整格式
数据类型[] 数组名 = new 数据类型[] { 元素1, 元素2, ... , 元素n }


// 注意：
// 1、静态初始化的简写形式看起来没有new，但是实际上还是做了new的操作，还是在内存的堆上开辟了空间
// 2、数组的初始化有两种形式，使用时只选用一种，不要混搭


// 混搭动态初始化和静态初始化
// int[] arr3 = new int[3] { 10, 20, 30 };




// 【数组在内存中的存储形式】
// 赋值号左边的是数组的声明
// 赋值号右边的是数组的值
// 通过栈上声明的变量到堆中找到具体值存放的位置来使用


数组中元素的默认值
// byte、short、int、long类型的数组的元素默认值为0
// double、float类型的数组的元素默认值为0.0
// char类型的数组的元素默认值为'\u0000'
// boolean类型的数组的元素默认值为false




// 对数组中的部分元素进行赋值
scoreArr[0] = 80;
scoreArr[2] = 55;

1、数组的元素的值发生变化后，数组的地址没有发生变化的
2、数组中的元素的值发生变化后，没有发生变化的元素的值还是之前的值




// 不同的数组，元素的值相同，修改后，对其他的数组里的元素的值无影响
// 因为不同的数组中的元素是存放在内存的堆中不同的空间里的
------------------------------------------------------------------------


// 数组--引用类型的特点
int[] arr1 = new int[3];
arr1[0] = 80;
arr1[2] = 55;


System.out.println("数组1的地址为：" + arr1);
arr1中元素{80,100,0}

// 注意：下一句话就体现出了引用数据类型的特点
int[] arr2 = arr1;
System.out.println("数组2的地址为：" + arr2);
arr2中元素{80,100,0}

arr2[0] = 70;
arr2[1] = 100;

System.out.println("数组1的地址为：" + arr1);
arr1中元素{70,100,55}

System.out.println("数组2的地址为：" + arr2);
arr2中元素{70,100,55}

// 从运行出的结果，我们得知：

// 1、（a1与a2的地址值相同）只有使用了new，才是在内存的堆上开辟了新的空间

// 2、引用数据类型在做传递时，传递的是引用


System.out.println("\r\n-------------------------------------------------------------------------------------");

// 值类型的特点：
// 存储在栈上，没有栈和堆之间的指向引用，变化只影响自身
int i = 2;
System.out.println("i的值为：" + i);

int j = i;
System.out.println("j的值为：" + j);

System.out.println("---------------");

j = 8;
System.out.println("i的值为：" + i);
System.out.println("j的值为：" + j);


--------------------------------------------


// 要求：把数组中的元素的值都显示出来
for (int i = 0; i < scoreArr.length; i++) {
System.out.println(scoreArr[i]);
}

// 要求：使用循环和数组长度等，制作一个方法printArray, 可以打印出数组中的元素，最终显示为[元素1的值,元素2的值,...元素n的值]
// 打印数组
public static void printArray(int[] arr) {
System.out.print("[");
// i就是数组的索引
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) { // 数组中的最后一个元素，是加上]
System.out.print(arr[i] + "]");
} else { // 数组中的其他元素，是加上,
System.out.print(arr[i] + ",");
}
}
}




// 制作一个方法getMaxItem，得到数组中的最大元素值
int maxItem = getMaxItem(arr);
System.out.println("数组中最大的元素值为：" + maxItem);
}
/*
 * 方法：传入一个int类型的数组，取得到数组中的最大元素值 
* 思路： 
* 1、先设置一个作为比较的标杆，从数组中拿出一个元素认为它是最大的
* 2、把数组中的其他元素与之进行比较
* 3、如果有元素比作为标杆的元素大，则替代之
* 4、比较完成，得到最大的元素值
*/
public static int getMaxItem(int[] arr) {
int tempMax = arr[0];


for (int i = 0; i < arr.length; i++) {
if (arr[i] > tempMax) {
tempMax = arr[i];
}
}


return tempMax;
}


-------------------------------------------------
//"null"
int[] arr = { 10, 20, 30 };
System.out.println(arr[0]);


// 产生异常：java.lang.NullPointerException
arr = null;
// System.out.println(arr[0]);
// System.out.println(arr.length);
System.out.println(arr); // null


// 设置引用类型变量的值为null，让其断开了与在堆上开辟的空间的联系
// null是一个特殊值，类比boolean类型的特殊值true和false，null表示的是引用数据类型的空值
// 引用数据类型的默认值是null
int[] arr1;

// Type mismatch: cannot convert from null to int
// int i = null; // null只能用于引用数据类型，不能用于值类型
}


---------------------------------------------------


// int[] arr = { 1, 2, 3 };
// printArray(arr);


printArray(new int[] { 1, 2, 3 });
// 匿名数组：没有显示定义数组名的数组
// 这里匿名数组使用new直接在内存的堆中开辟元素个数长度的空间、并存储这些元素
// 然后作为实参传给方法的形参供方法使用


// 匿名数组的优点：直接new出来用，不用再做声明
// 匿名数组的缺点：只能使用一次（因为没有声明，用完了就找不到了）




// 匿名数组的定义时，不能使用静态初始化的简写形式，语法出错
// Syntax error on token "printArray", @ expected before this token
// printArray({1,2,3});

}

// 打印数组
public static void printArray(int[] arr) {
System.out.print("[");
// i就是数组的索引
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) { // 数组中的最后一个元素，是加上]
System.out.print(arr[i] + "]");
} else { // 数组中的其他元素，是加上,
System.out.print(arr[i] + ",");
}
}
}


-------------------------------------------------------

// 给方法传递值类型参数 和 给方法传递引用类型参数
int i = 1;
System.out.println(i);// i:1


show(i);

System.out.println(i); // i:1


System.out.println("-----------------------------------");


int[] arr = { 1, 2, 3 };
printArray(arr);
System.out.println();

show(arr);


System.out.println();
printArray(arr);
}


// 方法接收的是值类型的参数
// i为形参，它接受show方法调用时传递过来的实参
// show方法中使用的i叫局部变量，声明该局部变量的地方是形参定义的地方、也是它的作用域开始的地方，作用域结束的地方是show方法右侧的大括号
public static void show(int i) {
i += 2; // i:3
System.out.println("方法内的参数值为：" + i);
}


/ 方法接收的是引用类型的参数
// 传递引用类型的参数，其实传递的是堆内存中开辟的空间的地址（也就是所谓的把引用传递过去了）
public static void show(int[] arr) {
for (int i = 0; i < arr.length; i++) {
// 这里其实就是拿着堆内存中数组的元素在操作
arr[i] += 2;
}
System.out.println("方法内的参数值为：" + arr);
printArray(arr);
}
--------------------------------------------------------------------

排序

1、选择排序

2、冒泡排序

3、插入排序