JavaSE之数组的使用

         我们在C语言中已经学习了数组的定义和使用,那么在Java中的数组和C语言中有什么区别呢,今天我们就一起来看一看。

目录

1.创建数组

1.1动态初始化

1.2数组的使用

1.2.1数组的访问

1.2.2打印数组中的元素

2.1引用类型

 2.2null的作用

3.数组练习

3.1数组转字符串

3.2找出数组中最大的元素

3.3求数组中元素的平均值

3.4查找数组中指定元素

3.5检验数组的有序性(检验数组是否是升序)

3.6冒泡排序

3.7数组逆序

3.8数组数字排列

3.9数组的拷贝

3.9.1深拷贝与浅拷贝

 4.二维数组


1.创建数组

1.1动态初始化

//数据类型[] 数组名称 = new 数据类型 [] {初始化数据}
int[] array = new int[]{1,2,3};
//[]中都不能有数字的存在

静态初始化

//数据类型[] 数组名称 = { 初始化数据 };
int[] array = {1,2,3};
//其实我们也可以写成
int array[] = {1,2,3};
//但我们还是推荐写成第一种,因为int[]是一个整体

1.2数组的使用

1.2.1数组的访问

public class Hang {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        //获取数组的长度
        System.out.println("length: " + array.length);
        //访问数组中的元素
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        //改变数组中元素
        array[2] = 10;
        System.out.println(array[2]);//执行结果:10
    }
}

访问过程中的下标越界

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

 表示数组越界

1.2.2打印数组中的元素

 方法1:for循环遍历数组

int[] array={1,2,3};
for(int i=0;i<array.length;i++){
 System.out.println(array[i]);
}

方法2:使用for-each遍历数组

int[] array={1,2,3};
for(int i=0;i<array.length;i++){
 System.out.println(array[i]);
}
//但此方法拿不到数组的下标

方法3:利用toString函数

toString是Arrays类中的一个方法,可以将数组中的元素转换成字符串,中间用 , 隔开,放到[ ]中。

2.1引用类型

        在Java数组中,数组其实就是一个对象,而定义数组时用到的关键字new,这个关键字new就是实现类的一个实例化,实例出一个对象,而这个能接收实例化对象的值就是引用类型。这个能接收实例化对象的值其实就是一个地址,该地址指向对象,即数组。

那么什么是引用呢:

        引用就相当于一个别名,类似于指针,保存了一个地址。创建一个引用,只是相当于创建了一个很小的变量,这个变量保存了一个整数, 这个整数表示内存中的一个地址.

在具体的讲解引用之前,我们先来看一幅图:

                        Java虚拟机的组成

举个例子:

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

此处的array就是个引用变量,而引用指向一个对象即{1,2,3,4},引用里面存储的就是一个变量的地址。

话不多说,上代码:

 2.2null的作用

int[] arr = null;
Syout.out.println(arr[0]);

 但此时就会出现空指针异常的错误,这是因为null表示一个无效的内存位置,不能对这个内存进行任何的读写操作。

例题1:

 如果只运行fun2,则结果不同,这是因为main把其地址传给fun2中array之后,fun2里面存储的是main中地址的一份临时拷贝,指向的对象还是之前的数组,但通过操作,将arr[0]改变成99.

通过上面的例题,我们可能会有疑问,一个引用是否可以指向多个对象?

public static void main(String[] args) {
        
        int[] array = new int[]{1,2,3,4};
        array1 = new int[10];
        array1 = new int[2];
        array1 = new int[5];
       //这个是不行的,因为此时array1存储的地址是可以改变的,现在的结果就是存储的是new int[5]的地址 ,因此一个引用只能指向一个对象 
        int[] array1 = {1,2,3};
        int[] array2 = array1;
    }
   //array2这个引用指向了array1这个引用指向的对象
   //引用指向引用,这句话是错的,引用只能指向对象

引用不一定在栈上,如果是一个局部变量,那就在栈上,如果是成员变量,则不一定在栈上

3.数组练习

3.1数组转字符串

public class Hang {
    public static String toString(int[] arr){
        String str = "[";
        for(int i = 0;i < arr.length;i++){
            str += arr[i];
            if(i != arr.length-1){
                str += ",";
            }
        }
        str += "]";
        return str;
    }

3.2找出数组中最大的元素

public static int max(int[] arr) { 
int max = arr[0]; 
(int i = 1; i < arr.length; i++) { 
if (arr[i] > max) { 
max = arr[i]; 
  } 
  }
  return max;
}

3.3求数组中元素的平均值

public class Hang {
    public static int Avg(int[] array){
        int sum = 0;
        for(int i= 0;i<array.length;i++){
            sum += array[i];
        }
        return sum/array.length;
    }

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(Avg(array));
    }
}

3.4查找数组中指定元素

public class Hang {
    public static int birsearch(int[] array,int n){
        int left = 0;
        int right = array.length-1;
        while(left <= right){
            int mid = (left + right)/2;
            if(n < array[mid]){
                right = mid-1;
            }else if(n > array[mid]){
                left = mid + 1;
            }else{
                return mid;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] array ={1,2,3,4,5};
        System.out.println(birsearch(array,5));
    }
   //执行结果为4

3.5检验数组的有序性(检验数组是否是升序)

public class Hang {

    public static boolean fun1(int[] array){
        for(int i = 0;i < array.length;i++){
            if(array[i] > array[i + 1]){
                return false;
            }
        }
        return true;
    }
}

3.6冒泡排序

import java.util.Arrays;

public class Hang {

    public static void bubbleSort(int[] array){
        for(int i = 0;i < array.length;i++){
            for(int j = array.length-1;j >i;j--){
                if(array[j-1]>array[j]){
                    int tmp=array[j-1];
                    array[j-1]=array[j];
                    array[j]=tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] array={8,5,3,24};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}
//运行结果为{3,5,8,24}

3.7数组逆序

public class Hang {
    
    public static void reverse(int[] array){
        int left = 0;
        int right = array.length - 1;
        while(left < right){
            int tmp = array[left];
            array[left] = array[right];
            array[right] = tmp;
            left++;
            right--;       
        }
    }
}

3.8数组数字排列

数组偶数放前面,奇数放后面

import java.util.Arrays;

public class Hang {
    public static void fun2(int[] array){
        int left = 0;
        int right = array.length-1;
        while(left < right){
            //指向一个奇数
            while(left < right && array[left] % 2 ==0){
                left++;
            }
            //指向一个偶数
            while(left < right && array[right] % 2 !=0){
                right--;
            }
            int tmp = array[left];
            array[left] = array[right];
            array[right] = tmp;
        }
    }

    public static void main(String[] args) {
        int[] array={1,2,4,5,6};
        fun2(array);
        System.out.println(Arrays.toString(array));
    }

3.9数组的拷贝

方法1:

public static int[] Copyof(int[] array){
        int[] ret=new int[array.length];
        for(int i = 0;i < array.length;i++){
            ret[i]=array[i];
        }
        return ret;
    }
    public static void main(String[] args) {
        int[] array1={1,2,3,4,5};
        int[] array2=Copyof(array1);
        System.out.println(Arrays.toString(array2));
    }
//创建一个大小和array1一样大的数组来拷贝原数组

方法2:

import java.util.Arrays;
 
public static void main(String[] args) {
        int[] array1={1,2,3,4,5};
        int[] array2=Arrays.copyOf(array1,array1.length);
        System.out.println(Arrays.toString(array2));
    }

3.9.1深拷贝与浅拷贝

 4.二维数组

public class Hang {

    public static void main(String[] args) {
        int[][] array = {{1,2,3},{4,5,6},{7,8,9}};
        for(int i = 0;i<array.length;i++){
            for(int j = 0;j<array[i].length;j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }
}

  • 3
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值