Java中的一维数组和二维数组-学习笔记

最新推荐文章于 2023-09-10 14:44:19 发布

StrawberryBoy

最新推荐文章于 2023-09-10 14:44:19 发布

阅读量1.6k

点赞数 2

分类专栏： Java

本文链接：https://blog.csdn.net/lhw19931201/article/details/106005082

版权

Java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

数组的定义

数组的概念：同一种类型数据的集合。其实数组就是一个容器。

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

定义数组的格式：

元素类型[] 数组名= new 元素类型[元素个数或数组长度];

例如：int [] arr = new int[3]; //定义一个可以存储3个整数的容器

还有另外一种格式：

元素类型[] 数组名= new 元素类型[]{元素，元素，……};

例如：int [] arr = new int[]{1,2,3,4} //定义一个可以存储4个整数的容器,四个元素为1，2，3，4

注意：数组名是数组在内存中的首地址。

int[] arr=new int[3];
System.out.println(arr);  //输出数组的首地址

数组的内存结构

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，需对空间进行不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

内存中一共有5个区；

注意：

堆内存中的每一个实体变量都有默认的初始化值，如果不指定则为0；

当堆区的实体不再被引用时，会在不确定的时间内被被垃圾回收器回收。

//如果数组没有进行初始化，则默认元素为0
int[] arr=new int[3];
    for(int i=0;i<arr.length;i++)
    {
      System.out.println(arr[i]);
    }

由关键字“new”创建的实体数组在堆内存上创建，一旦创建完成左边的arr引用数组变量就指向堆内存上创建的实体变量。

数组操作常见问题

1）数组脚标越界异常(ArrayIndexOutOfBoundsException)

int[] arr = new int[2];
System.out.println(arr[3]);  //arr数组最大的下标是1，此时超出了最大下标，会出错

2）空指针异常(NullPointerException)

int[] arr = null;
System.out.println(arr[0]);//arr引用没有指向实体，却在操作实体中的元素。

数组的常见操作

问题1：获取数组中的最值。

通过定义一个函数来实现获取数组中的最值。

public static void main(String[] args) {
    int[] arr={1,2,3,4,5};
    int maxNum=getMax(arr);
    int maxNum2=getMax2(arr);
    int minNum=getMin(arr);
    System.out.println(maxNum);
    System.out.println(maxNum2);
    System.out.println(minNum);

  }
  //获取数组中的最大值方法一：
  public static int getMax(int[] array)
  {
    int max=array[0];  //定义的最大值为数组中任意一个元素即可
    //通过循环语句对数组进行遍历
    for(int x=1;x<array.length;x++)
    {
      if(array[x]>max)
        max=array[x];
    }
    return max;
  }
  //获取最大值的方法二：
  public static int getMax2(int[] array)
  {
    int max=0;//将临时变量初始化为0，其实是在初始化为数组中任意一个角标
    for(int x=1;x<array.length;x++)
    {
      if(array[x]>array[max])
        max=x;
    }
    return array[max];
  }
  //获取数组的最小值
  public static int getMin(int[] array)
  {
    int min=0;
    for(int i=1;i<array.length;i++)
    {
      if (array[i]<array[min])
        min=i;
    }
    return array[min];
  }

问题2：输出数组中的全部元素。

//打印数组的全部元素
public static void main(String[] args) {
    int[] arr={1,2,3,4,5,6};
    printArray(arr);
  }
  //定义函数，用于打印数组中的元素。元素间用逗号隔开
  public static void printArray(int[] array)
  {
    System.out.print("[");
    for(int i=0;i<array.length;i++)
    {
      if(i!=array.length-1)  //如果不是最后的元素则后面加上逗号
        System.out.print(array[i]+",");
      else   //是最后的元素则后面加上"]"
        System.out.println(array[i]+"]");
    }
  }

问题3：对数组中的元素进行反转

//对数组中的元素进行反转{1,2,3,4,5,6} --->{6,5,4,3,2,1}
  //定义反转函数
  public static void reverseArray(int[] array)
  {
    for(int start=0,end=array.length-1;start<end;start++,end--)
    {
      int temp=array[start];
      array[start]=array[end];
      array[end]=temp;
    }
  }

问题4：十进制转化为二进制

public static void main(String[] args) {
    int num=10;
    toBin(num);
  }
  //将十进制转十六进制方法一：
  public static void toBin(int num)
  {
    StringBuffer sb=new StringBuffer();
    while(num>0)
    {
      sb.append(num%2);
      num=num/2;
    }
    System.out.print(sb.reverse());
  }

问题4：十进制转换为十六进制

方法一：基本方法

public static void main(String[] args) {
    int num=60;
    toHex(num);
  }
  //将十进制转十六进制方法一：
  public static void toHex(int num)
  {
    StringBuffer sb=new StringBuffer();
    for(int i=0;i<8;i++)  //循环8次因为int共32位，用4位二进制数来表示一位16进制
    {
      int temp=num&15;   //&15就是提取最后四位二进制数
      if(temp>9)
        sb.append((char)(temp-10+'A'));
      else
        sb.append(temp);
      //使用>>>右移的过程中如果是负数的话高位会自动去补1，这样防止一直右移
      num=num>>>4;
    }
    //因为先输出的是低位然后是高位所以结果是反着，通过sb.reverse将元素反过来
    System.out.println(sb.reverse());
  }

方法二：

通过将十六进制中的元素建立表，通过查表法来转换。

  public static void main(String[] args) {
    int num=60;
    toHex(num);
  }
  //将十进制转十六进制方法一：
  public static void toHex(int num)
  {
    /*
    查表法：将十六进制所有的元素临时存储起来。建立对应关系。
    元素  0 1 2 3 4 5 6 7 8 9 A  B  C  D  E  F  
    下标  0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    每一次num&15后的值作为索引去查建立好的表。就可以找对应的元素。
    这样比 -10+'a'简单的多.
    */
    char[] ch={'0','1','2','3',
        '4','5','6','7'
        ,'8','9','A', 'B'
        ,'C','D','E','F'};
    //建立临时容器来存储求出来的数
    char[] arr=new char[8];  //因为要取8次所以有8个元素
    int pos=arr.length;
    while(num!=0)
    {
      int temp=num&15;
      //将取到的num作为索引去查建立好的表，将此值存到数组最后的下标中
      arr[--pos]=ch[temp];
      num=num>>>4;
    }
    System.out.println("pos="+pos);
    //对存储数据的arr数组进行遍历
    for(int i=pos;i<arr.length;i++)
    {
      System.out.println(arr[i]);  //只输出数组中的有效位
    }
  }

数组中的排序问题：

排序有”选择排序“和”冒泡排序“问题。

先说选择排序:先让数组中的第一个元素跟之后的每个元素比较大小，比较的同时互换大小。一轮结束后，再让第二个元素依次与剩下的元素比较，依次类推直到剩下最后两个元素比较。

/*
选择排序算法
*/
public static void main(String[] args) {
    int[] arr={4,5,2,3,8};
    selectSort(arr);
    for(int i=0;i<arr.length;i++)
    {
      System.out.println(arr[i]); //对排数后的数组元素输出
    }
  }
  //选择排序对arr数组进行排序
  public static void selectSort(int[] array)
  {
    for(int x=0;x<array.length-1;x++)
    {
      for(int y=x+1;y<array.length;y++)
      {
        if(array[x]>array[y])
        {
          int temp=array[x];  //定义临时变量存储最大值
          array[x]=array[y];
          array[y]=temp;
        }
      }
    }
  }

接下来再说一下冒泡排序：

对数组中的每相邻两个数进行比较，因此一轮结束后最大的值在最右边，因此下一轮比较剩下的元素时元素的个数少1，此最大值不参与比较了。

/*
冒泡排序
*/
 public static void main(String[] args) {
    int[] arr={4,5,2,3,8};
    bubbleSort(arr);
    for(int i=0;i<arr.length;i++)
    {
      System.out.println(arr[i]); //对排数后的数组元素输出
    }
  }
public static void bubbleSort(int[] array)
  {
    for(int x=0;x<array.length-1;x++)
    {
      for(int y=0;y<array.length-x-1;y++)   //-x:让每一次比较的元素减少，-1：避免角标越界。
      {
        if(array[y]>array[y+1])  //让相邻元素比较
        {
          int temp=array[y];
          array[y]=array[y+1];
          array[y+1]=temp;
        }
      }
    }
  }

其实在java中已经定义好了一种排序方式，就是使用Arrays.sort(array)；开发中，如果对数组进行排序，就使用该句代码。

使用时需导入相应包：

import java.util.Arrays;

二维数组

定义数组格式：

格式一：int[][] arr = new int[3][2];

定义了名称为arr的二维数组；
二维数组中有3个一维数组；
每一个一维数组中有2个元素；
一维数组的名称分别为arr[0], arr[1], arr[2]；
给第一个一维数组1脚标位赋值为8写法是：arr[0][1] = 8;
二维数组arr的长度就是3，就是一维数组的个数；

格式2：int[][] arr = new int[3][];

二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化arr[0] = new int[3];arr[1] = new int[1];arr[2] = new int[2];

格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组；
二维数组中的有三个一维数组；
每一个一维数组中具体元素都已初始化；
第一个一维数组 arr[0] = {3,8,2}；
第二个一维数组 arr[1] = {2,7}；
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length
注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。

例：获取二维数组中所有元素的和？

public static void main(String[] args) {
    int[][] arr = {{1,2},{3,6,3,4},{1,2,3}};
    int sum=0;
    for(int x=0;x<arr.length;x++)
    {
      for(int y=0;y<arr[x].length;y++)
      {
        sum=sum+arr[x][y];
      }
    }
    System.out.println(sum);
  }

数组练习题

有关进制转换问题。

StrawberryBoy

关注

2
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Java中的一维数组和二维数组-学习笔记

目录数组的定义数组的内存结构数组操作常见问题数组的常见操作二维数组数组练习题数组的定义数组的概念：同一种类型数据的集合。其实数组就是一个容器。数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。定义数组的格式：元素类型[] 数组名= new 元素类型[元素个数或数组长度];例如：int [] arr = new int[3]; //定义一个可以存储3个整数的容器还有另外一种格式：元素类型[] 数组名= new 元素类型[...
复制链接

扫一扫