目录
数组的定义和使用：
数组的初始化：
遍历数组：
数组是引用类型
初始JVM的内存分布
再读引用变量
认识null
数组的应用场景
作为函数的参数
作为函数的返回值
数组练习
数组转字符串
排序
冒泡排序
数组逆序
数组求平均值
数组的定义和使用：
数组是一块连续的内存，用来存储相同类型的数据
数组名.length：
int[] array3 = new int[10];//默认全部初始化为0
System.out.println(array3.length);//数组长度int n = 10;
int[] array4 = new int[n];//数组的初始化：
数组的初始化主要分为动态初始化以及静态初始化
- 动态初始化：在创建数组时，直接指定数组中元素的个数
int[] array3 = new int[10];//默认全部初始化为0- 静态初始化：在创建数组时不直接指定数组元素个数，而是直接将具体的数据内容进行指定
int[] array = {1, 2, 3, 4};//简化形式
//int array2[]={1,2,3,4};//不推荐
int[] array2 = new int[]{1, 2, 3, 4};new是一个关键字，一般用来new对象，即数组是一个对象，Java当中一切皆对象
int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20,30};
// 注意省略格式不可以拆分,否则编译失败
// int[] array3:
// array3 = {1, 2, 3};int[] array = null;//小写
System.out.println(array);
如果数组中存储元素类型为引用类型，默认值为null
遍历数组：
//增强for循环 for-each循环
for (int x : array2) {
System.out.print(x + " ");
}遍历这个数组的时候，把数组当中的元素赋值给x
数组是引用类型
初始JVM的内存分布
- 程序运行时代码需要加载到内存
- 程序运行产生的中间数据要存放在内存
- 程序中的常量也要保存
- 有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁
如果堆内存中存储的数据不加区分的随意存储，那对内存管理起来将会非常麻烦
因此JVM对所使用的内存按照功能的不同进行了划分：
再读引用变量
认识null
public static void main(String[] args) {
int[] array = null;//一个不指向对象的引用
System.out.println(array.length);
}
array当前不指向任何对象，因此没有长度，不能对这个内存进行任何读写操作，一旦尝试读写，就会出现异常
注意：JAVA中并没有约定null和0号地址的内存有任何关联
对象不能指向对象，只有引用可以指向对象
数组的应用场景
作为函数的参数
public static void main(String[] args) {
int[] array = {1, 2, 3, 4};
fun(array);
for (int x : array) {
System.out.print(x + " ");
}
}
public static void fun(int[] array) {
array = new int[]{11, 22, 33, 44, 55};//重新在堆中开辟了地址
}结果：
只是修改了形参的指向
作为函数的返回值
public static void main(String[] args) {
int[] array = getArray();
System.out.println(array[0]);
}
public static int[] getArray() {
int[] arr = {
1,2,3,4,5,6};
return arr; // return 返回数组,返回的是数组内存中地址
}
数组练习
数组转字符串
import java.util.Arrays;
public class Shift {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(array));
}
}
排序
import java.util.Arrays;
public class Shift {
public static void main(String[] args) {
int[] array = {21, 12, 13, 54, 5};
System.out.println(Arrays.toString(array));//打印
// Arrays.sort(array);//自动排序
Arrays.sort(array, 0, 2);//区间排序[0,2)——>0,1
System.out.println(Arrays.toString(array));
}
}
开发效率很高！
import java.util.Arrays;
public class Shift {
public static void main(String[] args) {
int[] array = {21, 12, 13, 54, 5};
System.out.println(myToString(array));//打印
// Arrays.sort(array);//自动排序
Arrays.sort(array, 0, 2);//区间排序[0,2)——>0,1
System.out.println(myToString(array));
int[] array2 = {};
System.out.println(Arrays.toString(array2));//[]
}
public static String myToString(int[] array) {//相当于Arrays.toString
if (array == null) {
return "null";
}
if (array.length == 0) {
return "[]";
}
String ret = "[";
for (int i = 0; i < array.length; i++) {
ret += array[i];
if (i != array.length - 1) {
ret += ", ";
}
}
ret += "]";
return ret;
}
}
冒泡排序
public class bubbleSort {
public static void bubbleSort(int[] array) {
//i代表趟数
for (int i = 0; i < array.length - 1; i++) {
//已经优化了，每次比上次少1个
boolean flg = false;
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
int tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
flg = true;
}
}
if (!flg) {
//没有交换，进一步优化
return;
}
}
}
数组逆序
public class Reverse {
public static void reverse(int[] array) {
if (array == null) {
return;
}
int i = 0;
int j = array.length - 1;
while (i < j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
i++;
j--;
}
}
public static String myToString(int[] array) {
if (array == null) {
return "null";
}
if (array.length == 0) {
return "[]";
}
String ret = "[";
for (int i = 0; i < array.length; i++) {
if (i != array.length - 1) {
ret += (array[i] + "," + " ");
} else {
ret += array[i];
}
}
return ret += "]";
}
public static void main(String[] args) {
int[] array = {1, 2, 3, 4};
reverse(array);
System.out.println(myToString(array));
}
}
数组求平均值
public class Average {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
System.out.println(avg(arr));
}
public static double avg(int[] arr) {
int sum = 0;
for (int x : arr) {
sum += x;
}
return (double) sum / (double) arr.length;
}
}
