开发语言 Java数组的定义与使用

目录

一.一维数组的定义

1.创建数组

2.初始化数组

 二.数组的使用

1.访问数组

 2.遍历数组

 3.修改数据内容

三.有关数组方法的使用

1.toString

2. copyOf

 四.查找数组中的元素

1.顺序查找

2.二分查找binarySearch

五.数组排序

1.冒泡排序

2.排序方法sort

 六.数组逆置

 七.二维数组的定义

八.二维数组的打印

一.一维数组的定义

1.创建数组

数组定义有三种方法：

int[] array1 = new int[10];//前面的int[]为数组的类型，后面的int[10]为其能够存放的大小，array1为其数组名称

int[] array2 = {1,2,3,4,5};

int[] array3 = new int[]{1,2,3,4,5};

2.初始化数组

初始化数组有动态初始化和静态初始化两种

动态初始化：在创建数组时，只定义数组中元素的个数，并未给里面的元素进行赋值

例如：

int

[]

array

=

new

int

[

10

];

静态初始化：在创建数组时不定义数据元素个数，而直接将数组里的数据内容进行赋值，编译器会自己判定数组有几个元素，

后面的数据必须与前面定义的数据类型一致

例如：

int[] array1 = {0,1,2,3,4,5,6,7,8,9};  

 初始化能分为两步,分步的第二步中new int[]不能省略

int

[]

array

;

array 

=

new

int

[]{

10

,

20

,

30

};

 当数组中的元素为动态初始化时，会有对应的默认值

 二.数组的使用

1.访问数组

通过数组的下标进行访问，数组在内存中是一块连续的内存空间

public class Test {

public static void main(String[] args) {

int[] array = {1,2,3,4,5};

System.out.println(array[3]);

}

}

 数组的下标是从0开始的，所以数组用下标访问最大能到数组长度-1

public class Test {

public static void main(String[] args) {

int[] array = {1,2,3,4,5};

System.out.println(array[5]);

}

}

超过会报异常

 2.遍历数组

数组有3种打印方式

(1)for循环打印数组

public class Test {

public static void main(String[] args) {

int[] array = {1,2,3,4,5};

for (int i = 0; i < array.length; i++) {

System.out.print(array[i]+" ");

}

}

}

(2)foreach打印数组

public class Test {

public static void main(String[] args) {

int[] array = {1,2,3,4,5};

for (int x:array) {

System.out.print(x+" ");

}

}

}

 (3)toString打印数组

import java.util.Arrays;

public class Test {

public static void main(String[] args) {

int[] array = {1,2,3,4,5};

System.out.println(Arrays.toString(array));//使用toString方法需要导包，类似C语言中的头文件

}

}

运行结果:

 3.修改数据内容

1.直接传变量

public class Test {

public static void func(int x){

x = 10;

System.out.println("x:"+x);

}

public static void main(String[] args) {

int num = 0;

func(num);

System.out.println("num:"+num);

}

}

运行结果：

num的值没有被修改为10，因为方法传参的时候传的是形参，形参相当于是实参的一份临时拷贝，形参的修改不会影响到实参(相当于调用方法时创建的栈帧里有一个变量的值为0，然后被修改为10，方法调用结束，创建的栈帧销毁，并无影响)

2.传的是数组

import java.util.Arrays;

public class Test {

public static void func(int[] array){

array[0] = 10;

}

public static void main(String[] args) {

int[] array = {1,2,3};

func(array);

System.out.println(Arrays.toString(array));

}

}

 运行结果：

 3.传的数组返回的也是数组

import java.util.Arrays;

public class Test {

public static int[] func(int[] array){

array[0] = 10;

array[2] = 30;

return array;

}

public static void main(String[] args) {

int[] array = {1,2,3};

func(array);

System.out.println(Arrays.toString(array));

}

}

运行结果：

三.有关数组方法的使用

1.toString

toString方法的作用是将数组的数据变成字符串类型数据

import java.util.Arrays;

public class Test {

public static void main(String[] args) {

int[] array = {1,2,3,4,5};//定义一个数组

String arrays = Arrays.toString(array);//用字符串类型接受方法的返回值

System.out.println(arrays);

}

}

运行结果：

模拟实现toString

public class Test {

public static String toString(int[] array){//返回类型为字符串类型

String array1 = "[";//定义一个字符串类型数据

for (int i = 0; i < array.length; i++) {

array1+=array[i];

if(i!= array.length-1){

array1+=",";

}

}

array1+="]";

return array1;

}

public static void main(String[] args) {

int[] array = {1,2,3,4,5};//定义一个数组

String arrays = toString(array);//用字符串类型接收方法的返回值

System.out.println(arrays);

}

}

运行结果：

2. copyOf

第一个参数original - 要复制的数组

第二个参数newLength - 要返回的副本的长度

import java.util.Arrays;

public class Test {

public static void main(String[] args) {

int[] array = {1,2,3,4,5};

int[] newArray = new int[array.length];//新数组

newArray = Arrays.copyOf(array,array.length);

System.out.println(Arrays.toString(newArray));

}

}

运行结果：

模拟实现copyOf 

import java.util.Arrays;

public class Test {

public static int[] copyOf(int[] array,int length){

int[] newArray = new int[array.length];

for (int i = 0; i < array.length; i++) {//循环赋值

newArray[i] = array[i];

}

return newArray;

}

public static void main(String[] args) {

int[] array = {1,2,3,4,5};

int[] newArray = copyOf(array, array.length);

newArray[2] = 30;//将拷贝好的数组的第3个元素赋值为30，观察该改变是否对原数组是否有影响

System.out.println("array:"+Arrays.toString(array));

System.out.println("newArray:"+Arrays.toString(newArray));

}

}

运行结果：

 四.查找数组中的元素

1.顺序查找

public class Test {

public static int find(int[] array,int k){

for (int i = 0; i < array.length; i++) {

if(k == array[i]){

return i;//找到了就返回下标

}

}

return -1;//找不到返回-1

}

public static void main(String[] args) {

int[] array = {1,2,3,0,7,8,9,4,5,6};

int ret = find(array,4);

System.out.println(ret);

}

}

运行结果：

2.二分查找binarySearch

二分查找必须是有序数组

import java.util.Arrays;

public class Test {

public static void main(String[] args) {

int[] array = {1,2,3,4,5,6,7,8,9,10};

int ret = Arrays.binarySearch(array,4);

System.out.println(ret);

}

}

运行结果：

模拟实现binarySearch 

a - 要搜索的数组

key - 要搜索的值 

public class Test {

public static int binarySearch(int[] array,int k){

int left = 0;

int right = array.length-1;

while(left<=right){

int mid = (left+right)/2;

if(array[mid]>k){//查找范围左移

right = mid-1;

}else if(array[mid]

left = mid+1;

}else{

return mid;

}

}

return -1;

}

public static void main(String[] args) {

int[] array = {1,2,3,4,5,6,7,8,9,10};

int ret = binarySearch(array,4);

System.out.println(ret);

}

五.数组排序

1.冒泡排序

import java.util.Arrays;

public class Test {

public static void bubbleSort(int[] array){

for (int i = 0; i < array.length-1; i++) {

boolean flag = true;

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;

flag = false;

}

}

if(flag == true){//已经有序

break;

}

}

}

public static void main(String[] args) {

int[] array = {1,2,3,6,5,0,4,8,7,9};

bubbleSort(array);

System.out.println(Arrays.toString(array));

}

运行结果：

2.排序方法sort

import java.util.Arrays;

public class Test {

public static void main(String[] args) {

int[] array = {1,2,3,6,5,0,4,8,7,9};

Arrays.sort(array);

System.out.println(Arrays.toString(array));

}

}

运行结果：

 六.数组逆置

import java.util.Arrays;

public class Test {

public static void reverse(int[] array){

int head = 0;

int tail = array.length-1;

while(head

int tmp = array[head];

array[head] = array[tail];

array[tail] = tmp;

head++;//后移

tail--;//前移

}

}

public static void main(String[] args) {

int[] array = {1,2,3,4,5,6};

reverse(array);

System.out.println(Arrays.toString(array));

}

运行结果:

 七.二维数组的定义

二维数组同样有三种定义方式

public class Test {

public static void main(String[] args) {

int[][] array1 = {{1,2,3},{4,5,6}};

int[][] array2 = new int[2][3];

int[][] array3 = new int[][]{{1,2,3},{4,5,6}};

}

八.二维数组的打印

Arrays包里面的toString方法是将数组中的元素转换为字符串，用2个toString方法来打印二维数组时，第一个toString已经将数组转换为字符串，第二个toString是不能接收字符串的，所以不能用toString来打印二维数组

应用deepToString来打印

import java.util.Arrays;

public class Test {

public static void main(String[] args) {

int[][] array = {{1,2,3},{4,5,6}};

System.out.println(Arrays.deepToString(array));

}

运行结果：

查看原文