【本节目标】
1、理解数组基本概念
2、掌握数组的基本用法
3、数组与方法互操作
4、熟练掌握数组相关的常见问题和代码
1.数组的基本概念
1.1 为什么要使用数组
有一组类型相同的数据需要存放在一起,这就是所谓的数组。
1.2 什么是数组
数组:可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。在java中,首先数组中存放的元素类型相同;其次,数组的空间是连在一起的;然后每个空间有自己的编号,起始位置的编号是0,即数组的下标。
1.3 数组的创建及初始化
1.3.1数组的创建
例如:
int[] array1 = new int[66];
double[] array2 = new double[6];
String[] array3 = new String[3];
1.3.2数组的初始化
初始化分为动态初始化与静态初始化
1、动态初始化:在创建数组时,直接指定数组中元素的个数
int[] array = new int[10];
2、静态初始化:在创建数组时不直接指定元素个数,而直接将具体的元素内容指定
int[] array1 = new int[]{1,2,3,4};
double[] array2 = new double[]{1.0,2.0,3.0,4.0};
String[] array3 = new String[]{"hello","java"};
【注】1、静态初始化可以简写,省略后面的new T [ ]。
2、静态初始化时必须保证前后数据类型一致。
3、如果不确定数组当中内容时,使用动态初始化,否则建议使用静态初始化。
4、如果数组没有初始化,数组元素有其默认值。
类型 默认值 byte 0 short 0
int 0 long 0 float 0.0f double 0.0 char /u0000 boolean false 5、如果数组中存储元素类型为引用类型,默认值为null。
1.4 数组的使用
1.4.1 数组元素的访问
数组在内存中是一段连续的空间,空间的编号都是从0开始的,依次递增,该编号称为数组的下标,数组可以通过下标访问其任意位置的元素,也可以通过[ ]对数组中的元素进行修改。
【注】1、支持随机访问,即通过下标快速访问数组中任意位置的元素。
2、下标从0开始,[0,N)坐闭右开,不能越界,否则编译器会报下标越界异常。
抛出java.lang.ArrayIndexOutofBoundsException异常。
1.4.2 遍历数组
遍历:是将数组中的所有元素都访问一遍,访问是指对数组中的元素进行某种操作。比如打印:
int[] array = new int[] {10,20,30,40,50};
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}
也可以用for-each(for循环的另外一种)遍历数组:
int[] array = {1,2,3};
for(int x : array){
System.out.println(x);
}
2、数组是引用类型
2.1初始JVM的内存分布
这里只谈堆和虚拟机栈
堆:JVM所管理的最大内存,使用new创建的对象都是在堆上保存,堆是随着程序开始运行时而创建的,随着程序的推出而销毁,堆中的数据只要还有在使用的,就不会被销毁。
虚拟机栈:与方法调用相关的一些信息,每个方法执行的时候,都会创建一个栈帧,栈帧中包含有:局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息,保存的都是与方法执行时相关的一些信息。
2.2 基本类型变量与引用类型变量的区别
基本数据类型创建的变量,称为基本变量,该变量空间中的直接存放的是其所对应的值;
而引用数据类型创建的变量,一般称为对象的引用,其空间中存储的是对象所在空间的地址。
public static void func(){
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}
a,b是基本变量,因此其空间中保存的就是给该变量初始化的值。
array是数组类型的引用变量,其内部保存的内容是数组在堆空间中的首地址。(类似于指针)
2.3 再谈引用变量
public static void main(String[] args) {
int[] array = {1,2,3};
System.out.println(array);//真实地址的哈希值
}
public static void main(String[] args) {
int[] array1 = {1,2,3,4,5};
int[] array2 = array1; //这个引用array2,指向了array1所指向的对象
System.out.println("array1:" + Arrays.toString(array1));
System.out.println("array2:" + Arrays.toString(array2));
}
上图代码中array1与array2是等价的,引用的是同一个数组。
public static void main(String[] args) {
int[] array1 = new int[3];
array1[0] = 10;
array1[1] = 20;
array1[2] = 30;
for (int x:array1) {
System.out.print(x+" ");
}
System.out.println();
System.out.println("====================");
int[] array2 = new int[]{1,2,3,4,5};
array2[0] = 100;
array2[1] = 200;
array1 = array2; //让array1去引用array2引用的数组的空间,此时array1和array2实际是同一个数组。
array1[2] = 300;
array1[3] = 400;
array2[4] = 500;
for (int i = 0; i < array1.length; i++){
System.out.print(array1[i]+" ");
}
System.out.println();
System.out.println("====================");
for (int i = 0; i < array2.length; i++){
System.out.print(array2[i]+" ");
}
}
public static void main(String[] args) {
int[] array1 = {1,2,3,4};
int[] array2 = {1,2,3,4};
System.out.println(array1);
System.out.println(array2);
}
两个数组虽然里面的值一样,但地址不一样。
2.4认识null
null在java中表示“空引用”,也就是一个不指向对象的引用。
public static void main(String[] args) {
int a = 0;
System.out.println(a);
int[] array = null;
System.out.println(array[0]);
}
3、数组的应用场景
3.1 保存数据
public static void main(String[] args){
int[] array = {1,2,3};
for(int i = 0; i < array.length; ++i){
System.out.println(array[i] + " ");
}
}
3.2 作为函数的参数
1、参数传基本数据类型
public static void func(int a){
a = 20;
System.out.println(a);
}
public static void main(String[] args) {
int x = 10;
func(x);
System.out.println(x);
}
在func方法中修改形参a的值,不影响实参x的值。
2、参数传数组类型(引用数据类型)
public static void func1(int[] array){
array = new int[]{11,12,13,14};
}
public static void func2(int[] arr){
arr[0] = 199;
}
public static void main(String[] args) {
int[] array1 ={1,2,3,4};
func1(array1);
System.out.println(Arrays.toString(array1));
int[] arr = {100,99,88,77};
func2(arr);
System.out.println(Arrays.toString(arr));
}
因为数组是引用类型,按照引用类型来进行传递,是可以修改其中存放的内容。在Java里面都是按值传递,地址也是值。
3.3 作为函数的返回值
//获取斐波那契数列的前n项
public static int[] fib(int n){
if(n <= 0){
return null;
}
int[] array = new int[n];
array[0] = array[1] = 1;
for(int i = 2; i < n; ++i){
array[i] = array[i-1] + array[i-2];
}
return array;
}
public static void main(String[] args) {
int[] array = fib(5);
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}
}
4、数组练习
4.1 数组转字符串
//数组转字符串
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
}
Arrays.toString是Java里的java.util.Arrays包,打印数组比较方便。
4.2 数组拷贝
//利用for循环遍历数组拷贝
public static void main(String[] args) {
int[] array = {1,2,3,4};
int[] copy = new int[array.length];
for (int i = 0; i < array.length; i++) { //遍历数组
copy[i] = array[i];
}
System.out.println(Arrays.toString(copy));
}
//使用Arrays.copyOf拷贝
public static void main(String[] args) {
int[] array = {1,2,3,4};
int[] copy = Arrays.copyOf(array,array.length);
System.out.println(Arrays.toString(copy));
}
Arrays.copyOf是以后数组拷贝运用最广泛的。
//使用array.clone拷贝数组
public static void main(String[] args) {
int[] array = {1,2,3,4};
int[] copy = array.clone();
System.out.println(Arrays.toString(copy));
System.out.println(array);
System.out.println(copy);
}
//使用Arrays.copyOfRange拷贝数组
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
int[] ret = Arrays.copyOfRange(array,1,6); //java里面的范围都是左闭右开
System.out.println(Arrays.toString(ret));
}
4.3 求数组中元素的平均值
public static double avg(int[] array){
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
return sum * 1.0 / array.length;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
System.out.println(avg(array));
}
4.4 查找数组中指定元素(顺序查找)
//顺序查找
public static int search(int[] array,int key){
for (int i = 0; i < array.length; i++) {
if(array[i] == key){
return i;
}
}
return -1;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
int index = search(array,4);
if(index == -1){
System.out.println("找不到!");
}else{
System.out.println("找到了,下标为:"+index);
}
}
4.5 查找数组中的指定元素(二分查找)
前提是你查找的数据必须是有序的。
//二分查找
public static int binarySearch(int[] array,int key){
int left = 0;
int right = array.length-1;
while(left <= right){
int mid = (left + right) / 2;
if(array[mid] < key){
left = mid + 1;
}else if(array[mid] == key){
return mid;
}else{
right = mid - 1;
}
}
return -1;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
int index = binarySearch(array,44);
if(index == -1){
System.out.println("找不到!");
}else{
System.out.println("找到了,下标为:"+index);
}
}
//排序过后的查找、Arrays自带的查找
public static int binarySearch(int[] array,int key){
int left = 0;
int right = array.length-1;
while(left <= right){
int mid = (left + right) / 2;
if(array[mid] < key){
left = mid + 1;
}else if(array[mid] == key){
return mid;
}else{
right = mid - 1;
}
}
return -1;
}
public static void main(String[] args) {
int[] array = {1,2,33,4,5};
Arrays.sort(array);//先将数组排序
System.out.println("排序之后的数组: "+Arrays.toString(array));
int index = Arrays.binarySearch(array,32);
if(index == -1){
System.out.println("找不到!"); //返回下标为:-(low+1)
}else{
System.out.println("找到了,下标为:"+index);
}
}
【注】1、sort方法默认是升序排序
2、对于现在的简单数据类型,目前还做不到降序。
3、怎样做到指定的升序或降序,需要去学习后面的接口。
4.6 数组排序(冒泡排序)
//冒泡排序法
public static void bubbleSort(int[] array){
//i表示趟数
for (int i = 0; i < array.length - 1; i++) {
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;
}
}
}
}
public static void main(String[] args) {
int[] array = {1,2,33,4,5};
System.out.println("排序之前的数组: "+Arrays.toString(array));
bubbleSort(array);
System.out.println("排序之后的数组: "+Arrays.toString(array));
}
//冒泡排序法优化
public static void bubbleSort(int[] array){
for (int i = 0; i < array.length - 1; i++) {
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 == false){
break;
}
}
}
public static void main(String[] args) {
int[] array = {1,2,33,4,5};
System.out.println("排序之前的数组: "+Arrays.toString(array));
bubbleSort(array);
System.out.println("排序之后的数组: "+Arrays.toString(array));
}
4.7 数组逆序
public static void main(String[] args) {
int[] arr = {1,2,3,4};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static void reverse(int[] arr){
int left = 0;
int right = arr.length - 1;
while(left < right){
int tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
left++;
right--;
}
}
5、二维数组
基本语法:
数据类型[ ][ ] 数组名称 = new 数据类型 [行数][列数] {初始化数据};
public static void main(String[] args) {
int[][] arr = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]+" ");
}
System.out.println("");
}
}