• Java基础语法(三)---数组

    一、概念

            同一种类型数据的集合。简单的来说就是一容器，用来装东西的。

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

     

    二、一维数组的格式

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

                      如： int []  arr = new int [3];  也可以写成： int arr[] = new int[3];

            格式2：元素类型 []数组名 = new 元素类型 [ ]{元素1,元素2,…};

                       如： int []  arr = new int []{1,2,3,4,5};

            还有一种简写的静态初始化格式：如： int [] arr={1,2,3,4,5};

            其中：new是用来在堆内存中产生一个容器实体。

    数组也被称为引用数据类型。在内存中的分配如下图：

    注：1、System.out.println(arr);得到的结果是一个哈希值，也叫地址值。

            2、数组在堆内存开辟空间后，就有默认的初始化值。如：int默认0；boolean默认false。

    内存小知识：

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

            栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

            堆内存：1、数组和对象，通过new建立的实例都存放在堆内存中。

                          2、每一个实体都有内存地址值。

                          3、实体中的变量都有默认初始化值。

                          4、实体不在被使用，会在不确定的时间内被垃圾回收器回收。

     

    三、数组操作常见问题

        1、数组脚标越界异常(ArrayIndexOutOfBoundsException)。例：

                 int[] arr = new int[2];

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

                访问到了数组中的不存在的脚标时发生。

        2、空指针异常人生感悟(NullPointerException)。例：

                int[]arr = null;

                 System.out.println(arr[0]);

                 arr引用没有指向实体，却在操作实体中的元素时。

     

    四、数组中的数组

            也称多维数组，这里我们主要讲二维数组。

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

            解释：以上格式表示定义了名称为arr的二维数组。有3个一维数组，每一个一维数组中有2个元素。一维数组的名称分别为arr[0],arr[1],arr[2]。给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78。

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

             注：此种格式中每个一维数组都是默认初始化值null。

             格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};//每一个一维数组中具体元素都初始化了。

    注：一种特殊定义伤感的句子写法：int[]x,y[]; x是一维数组，y是二维数组。

    二维数组在内存中的分配情况示例：

     

    五、数组常见操作

    1、 数组排序：

            常见的排序方式：冒泡排序和选择排序。在Java已经定义好了一种排序方式，在开发使用中，直接调用即可。排序的方式有很多，其中最快的排序方式为希尔排序。

    下面是我自己敲的选择和冒泡两种排序方式的程序：

            选择排序程序：

    [java] view plaincopy
     
    1. //使用选择排序方式对指定的数组进行排序  
    2.   
    3. class  Demo  
    4. {  
    5.     public static void main(String[] args)   
    6.     {  
    7.         int[] arr= {1,11,5,3,9,55,23,67,18};  
    8.         //输出原数组  
    9.         printArray(arr);  
    10.         //调用排序方法  
    11.         selectSort(arr);  
    12.         //输出排序后的数组  
    13.         printArray(arr);  
    14.     }  
    15.       
    16. /* 
    17. 选择排序 
    18. 1、先用0角标上的元素依次与其他元素进行比较，将较小值元素存放到0角标。 
    19. 2、然后再拿1角标上的元素依次进行比较，以此类推。 
    20. */  
    21.     public static void selectSort(int[] arr)  
    22.     {  
    23.         //外循环遍历数组  
    24.         for (int x=0;x<arr.length-1;x++)  
    25.         {  
    26.             //内循环比较大小  
    27.             for (int y=x+1;y<arr.length;y++)  
    28.             {  
    29.                 //如果后一个元素比拿去比较的元素大，就交换两元素位置  
    30.                 if(arr[x]>arr[y])  
    31.                 {  
    32.                     //arr[x]=arr[y];  
    33.                     //arr[y]=temp;  
    34.                     swap(arr,x,y);  
    35.                 }     
    36.             }  
    37.         }  
    38.     }  
    39.   
    40.     //遍历数组  
    41.     public static void printArray(int[] arr)  
    42.     {  
    43.         System.out.print("[");  
    44.         for (int x=0;x<arr.length;x++)  
    45.         {  
    46.             if(x!=arr.length-1)  
    47.                 System.out.print(arr[x]+",");  
    48.             else  
    49.                 System.out.print(arr[x]+"]");  
    50.         }  
    51.         //换行  
    52.         System.out.println();  
    53.     }  
    54.   
    55.     //互换方法  
    56.     public static void swap(int[] arr,int a,int b)  
    57.     {  
    58.         arr[a]=arr[a]^arr[b];  
    59.         arr[b]=arr[a]^arr[b];  
    60.         arr[a]=arr[a]^arr[b];  
    61.     }  
    62. }  

     输出结果：

             

     

    冒泡排序程序：

    [java] view plaincopy
     
    1. //使用冒泡排序方式对指定程序进行排序  
    2.   
    3. class Demo1   
    4. {  
    5.     public static void main(String[] args)   
    6.     {  
    7.         int arr[]={22,63,89,13,6};  
    8.         //打印原数组  
    9.         printArray(arr);  
    10.         //调用排序方法  
    11.         bubbleSort(arr);  
    12.         //打印排序后的数组  
    13.         printArray(arr);  
    14.     }  
    15.   
    16.     /* 
    17.     冒泡排序 
    18.     1、先从头角标相邻两个元素之间进行比较，将较大值存放在后一个元素中，然后再与后一个元素的进行比较，直至最大值存放到最后一个元素中。 
    19.     2、再重复1操作，每次计较次数减一，一圈比完后存放的较大元素不再参与比较。 
    20.     */  
    21.   
    22.     public static void bubbleSort(int[] arr)  
    23.     {  
    24.         for (int x=0;x<arr.length-1;x++)  
    25.         {  
    26.             for (int y=0;y<arr.length-1-x;y++)//-x:让没每一次比较的元素减少。-1：避免角标越界。  
    27.             {  
    28.                 if(arr[y]>arr[y+1])  
    29.                     swap(arr,y,y+1);  
    30.             }  
    31.         }  
    32.     }  
    33.     //遍历数组  
    34.     public static void printArray(int[] arr)  
    35.     {  
    36.         System.out.print("[");  
    37.         for (int x=0;x<arr.length;x++)  
    38.         {  
    39.             if(x!=arr.length-1)  
    40.                 System.out.print(arr[x]+",");  
    41.             else  
    42.                 System.out.print(arr[x]+"]");  
    43.         }  
    44.         //换行  
    45.         System.out.println();  
    46.     }  
    47.   
    48.     //互换方法  
    49.     public static void swap(int[] arr,int a,int b)  
    50.     {  
    51.         arr[a]=arr[a]^arr[b];  
    52.         arr[b]=arr[a]^arr[b];  
    53.         arr[a]=arr[a]^arr[b];  
    54.     }  
    55. }  

     输出结果

     

    2、 折半查找

    程序：

    [java] view plaincopy
     
    1. /* 
    2. 需求：将一个已知元素插入到一个有序数组中，要求不改变数组顺序，打印元素应该插入数组位置的角标。 
    3. 思路：1、可以利用折半查找的方式，先定义两个变量，一个初始化0角标，作为最小值，一个初始化为最后一个角标，作为最大值， 
    4.         再定义一个变量，存储最小值与最大值的一半，也就是中间位置，然后将已知元素与中间值位元素进行比较。 
    5.       2、如果比中间值元素大，则将最小值变为中间值加1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复 
    6.       3、如果比中间值元素小，则将最大值变为中间值减1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复 
    7. */  
    8. class  HalfSearch  
    9. {  
    10.     public static void main(String[] args)   
    11.     {  
    12.         int[] arr={2,6,9,11,15,19,22,30};  
    13.         //打印数组  
    14.         printArray(arr);  
    15.         int key=20;  
    16.         //用第一种折半方式输出插入的角标值  
    17.         System.out.println("当key=20在数组arr中插入的角标位置是："+halfSearch1(arr,key));  
    18.         key=1;  
    19.         //用第二种折半方式输出插入的角标值  
    20.         System.out.println("当key=1在数组arr中插入的角标位置是："+halfSearch2(arr,key));  
    21.     }  
    22.   
    23.     //折半查找<一>  
    24.     public static int halfSearch1(int[] arr,int key)  
    25.     {  
    26.         int min=0,max=arr.length-1,mid=(max+min)/2;  
    27.         while(key!=arr[mid])  
    28.         {  
    29.             if(min>max)  
    30.                 return min;  
    31.             else if(key>arr[mid])  
    32.                 min=mid+1;  
    33.             else   
    34.                 max=mid-1;  
    35.             mid=(max+min)>>>1;//折半操作             
    36.         }  
    37.         return mid;   
    38.     }  
    39.   
    40.     //折半查找<二>  
    41.     public static int halfSearch2(int[] arr,int key)  
    42.     {  
    43.         int min=0,max=arr.length-1,mid;  
    44.   
    45.         while(min<max)  
    46.         {  
    47.             mid=(max+min)>>>1;//折半操作  
    48.             if(key>arr[mid])  
    49.                 min=mid+1;  
    50.             else if(key<arr[mid])  
    51.                 max=mid-1;  
    52.             else  
    53.                 return mid;  
    54.         }  
    55.         return min;   
    56.     }  
    57.   
    58.     //遍历数组  
    59.     public static void printArray(int[] arr)  
    60.     {  
    61.         System.out.print("[");  
    62.         for (int x=0;x<arr.length;x++)  
    63.         {  
    64.             if(x!=arr.length-1)  
    65.                 System.out.print(arr[x]+",");  
    66.             else  
    67.                 System.out.print(arr[x]+"]");  
    68.         }  
    69.         //换行  
    70.         System.out.println();  
    71.     }  
    72. }  

    运行结果：

     

    3、 进制转换

    十进制转换为二进制、八进制、十六进制的小程序：

    [java] view plaincopy
     
    1. /* 
    2. 使用查表法将十进制转换为二进制、八进制、十六进制 
    3. */  
    4. class  Conversion  
    5. {  
    6.     public static void main(String[] args)   
    7.     {  
    8.         int num=60;  
    9.   
    10.         toBin(num);  
    11.   
    12.         toOct(0);  
    13.   
    14.         toHex(-num);  
    15.     }  
    16.   
    17.     //转换为二进制  
    18.     public static void toBin(int num)  
    19.     {  
    20.         conversion(num,1,1);  
    21.     }  
    22.   
    23.     //转换为八进制  
    24.     public static void toOct(int num)  
    25.     {  
    26.         conversion(num,7,3);  
    27.     }  
    28.   
    29.     //转换为十六进制  
    30.     public static void toHex(int num)  
    31.     {  
    32.         conversion(num,15,4);  
    33.     }  
    34.     //转换
    35.     public static void conversion(int num,int diwei,int yiwei)  
    36.     {  
    37.         //如果num等于0，结果输出为0  
    38.         if(num==0)  
    39.         {  
    40.             System.out.println("num="+0);  
    41.             return;  
    42.         }  
    43.         //定义一个包含二进制、八进制、十六进制的表  
    44.         char[] chs={'0','1','2','3','4','5','6','7',  
    45.                     '8','9','A','B','C','D','E','F',};  
    46.   
    47.         //定义一个临时容器
    48.         char[] arr=new char[32];  
    49.   
    50.         //定义一个操作数组的指针  
    51.         int pos=arr.length;  
    52.   
    53.         //利用与低位最大值的方式取出低位，存到临时数组中  
    54.         while(num!=0)  
    55.         {  
    56.             arr[--pos]=chs[num&diwei];//--pos倒着往临时容器里存  
    57.             num >>>=yiwei; //无条件右移相应位数  
    58.         }  
    59.           
    60.         //打印转换后的结果  
    61.         for(int x=pos;x<arr.length; x++)  
    62.             System.out.print(arr[x]);  
    63.           
    64.         //换行  
    65.         System.out.println();  
    66.     }  
    67. }  

     输出结果：
  • 相关阅读:
    生成格雷码 转自leetcode
    webstorm注册码 永久有效！！！（亲测有效）
    Myeclipse或者eclipse太卡
    对封装的再次理解(容器)
    几个好的参考的网站
    将json字符串转为json对象，从对象中取需要的数据
    ElementUI学习笔记
    Oracle的case when 和decode
    20190807更新数据相关笔记
    oracle未查找到任何数据问题
  • 原文地址：https://www.cnblogs.com/tiankong101/p/4226605.html
Copyright © 2020-2023  润新知