• 黑马程序员——Java基础语法---数组


    ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------

    一、概念

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

            使用数组的好处:可以自动给数组中的元素从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};

        特别注意:int[] x,y[];         //x一维,y二维。int[] x;int[] y[];

            其中: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 class  Array2Demo
     2 {//目标:熟悉二维数组的存在,即一维数组中的组员为
     3      // 一维数组
     4     public static void main(String[] args) 
     5     {
     6 
     7 
     8         /*
     9         int arr[]=new int [3];//新建一个一维数组,数组中有三个元素
    10         
    11         int arr[][]=new int[3][4]//新建一个二维数组,3列4行
    12         int arr[][]=new int[3][];//二维数组,有三个组员,组员中各有一维数组
    13         arr[0][]=new int[3];
    14         arr[1][]=new int[1];
    15         arr[2][]=new int[2];
    16         System.out.println(arr,length);//打印是二维数组的长度 3;
    17         System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度
    18         */
    19         int arr[][]  = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
    20         //求数组中元素的和
    21         //分析:二维数组需要使用双重for循环
    22         //第一次遍历时x<arr.length
    23         //第二次遍历时y<arr[x].length
    24         int sum=0,x,y;
    25         for(x=0;x<arr.length;x++)
    26         {
    27             for(y=0;y<arr[x].length;y++)
    28             {
    29                 sum=sum+arr[x][y];
    30             }
    31         }
    32         System.out.println("数组和为:"+sum);
    33     }
    34 }

     

     

    五、数组常见操作

    1、 数组排序:

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

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

     

     1 import java.util.*;
     2 /*
     3 对给定数组进行排序。
     4 {5,1,6,4,2,8,9}*/
     5 class ArrayTest2 
     6 {    
     7     public static void swap(int arr[],int a,int b)
     8        {/*
     9 分析:无论哪一种排序都需要交换,为了提高代码的复用率
    10 独立将交换函数封装
    11 */
    12            int temp=arr[a];
    13             arr[a]=arr[b];
    14             arr[b]=temp;    
    15         }
    16     public static void selectSort(int arr[])//分析:选择排序
    17     {    /*分析:选择排序:原理是将遍历一遍数组将最小值放到最前面
    18             之后遍历便从角标1开始,如此重复,
    19             直到遍历到arr.length-2为止
    20         */
    21         for(int x=0;x<arr.length-1;x++)//外循环遍历数组  
    22         {
    23             for(int y=x+1;y<arr.length;y++)//内循环比较大小 
    24             { 
    25                 if(arr[x]>arr[y])
    26                 swap(arr,x,y);
    27             }
    28         }
    29     }
    30     public static void VubbleSort(int arr[])//分析:冒泡排序
    31     {
    32         for(int x=0;x<arr.length-1;x++)//原理是从零角标开始,相邻角标元素值大的往后面放,
    33         {                                //因此遍历一次后,该数组最大的元素在最后面
    34             for(int y=0;y<arr.length-x-1;y++)//-x:让每一次比较的元素减少。-1:避免角标越界。 
    35             {    if(arr[y]>arr[y+1])
    36                 swap(arr,y,y+1);
    37             }
    38         }
    39     }
    40 
    41     public static void printArray(int arr[])
    42     {
    43         sop("{");
    44         for(int x=0;x<arr.length;x++)//打印数组的格式   {x,x,x,x,x......}
    45         {
    46             if(x!=arr.length-1)
    47                 sop(arr[x]+",");
    48             else
    49                 sop(arr[x]+"}");
    50             
    51         }
    52         sop("
    ");
    53     }
    54     public static void main(String[] args) 
    55     {
    56         int arr[]={5,1,6,4,2,8,9};
    57         sop("数组排序前:");
    58         printArray(arr);
    59         //VubbleSort(arr);
    60         selectSort(arr);
    61         sop("数组排序后:");
    62         printArray(arr);
    63     }
    64     public static void sop(Object obj)
    65     {
    66         System.out.print(obj);
    67     }
    68 }

    2、 折半查找

     1 class  ArrayTest4
     2 {/*
     3 数组的查找操作。
     4 
     5 练习:有一个有序的数组,想要将一个元素插入到该数组中,
     6 还要保证该数组是有序的。如何获取该元素在数组中的位置。
     7 分析:通过折半查找寻找出元素应该所属的角标
     8       之后创建新的数组存储,新的数组
     9 */
    10 
    11     public static int halfSearch(int arr[],int key)//传递进来的是有序的数组  和要查找的元素
    12     {                                                //返回的是该元素应该在的位置
    13         int low=0,high=arr.length,num;
    14         for(num=(low+high)/2;low<high;num=(low+high)/2)//将数组的两端low+high 除二 取出该位置num的元素与要查找的元素比较
    15         {                                                
    16             if(key==arr[num])                            
    17                 return num+1;   //如果查找到元素值相同 ,则返回的位置为num+1;
    18             else
    19                 {
    20                     if(key>arr[num])//若要查找的元素大,则将num加1的所在位置 传递给  low
    21                         low=num+1;
    22                     else
    23                         high=num-1;//若要查找的元素小  则将num减1的所在位置 传递给  high
    24                 }
    25                 
    26 
    27         }
    28         return low; //如果没有查找到元素与之相同,则返回  low   ,这个low便是如果元素要插入这个数组,该元素应该存在的位置
    29     }
    30     public static void sop(Object obj)//打印  任何对象
    31     {
    32         System.out.println(obj);
    33     }
    34     public static int getIndex(int arr[],int key)//按照数组的顺序 查找 有没有与要查找元素相同的元素(该数组可以无序)
    35         {
    36             int x;
    37             for(x=0;x<arr.length;x++)
    38             { if(key==arr[x])
    39                 return x;                    //如果有则返回位置
    40             }
    41             return -1;                        //没有则返回-1
    42         }
    43     
    44     public static void main(String[] args) 
    45     {
    46         int arr[]={2,4,5,7,8,19,32,45};
    47         int arr1[]={3,2,1,5,4,2,9};
    48         int x=halfSearch(arr,9);
    49         int y=getIndex(arr1,5);
    50         System.out.print('{');
    51         for(int a=0;a<arr.length-1;a++)
    52         System.out.print(arr[a]+",");
    53         System.out.print(arr[arr.length-1]);//打印arr数组
    54         System.out.println('}');
    55         sop(x);
    56 
    57         sop(y);
    58         
    59     }
    60 }
     

     

     

    3、数组的反转

     1 /*
     2 对给定的数组进行反转。
     3 {3,1,5,6,2} --->
     4 {2,6,5,1,3}
     5 
     6 分析:要反转数组,只要将数组的首尾依次互换
     7 而一个数组有奇偶,然而要反转的次数是确定的即
     8 int x=arr.length/2.
     9 因此只需要调用循环就可以了
    10 
    11 */
    12 
    13 class  ArrayTest3
    14 {    public static void reverseArray(int arr[])
    15     {
    16         for(int start=0,end=arr.length-1; start<end ; start++,end--)//取出起始位和末尾位,只要起始位能够小于末尾位
    17         {                                                            //即还有未交换位置的元素,之后将起始位增1,末尾位减1
    18             int temp=arr[start];
    19         arr[start]=arr[end];                 //交换两个位置所在的元素
    20         arr[end]=temp;
    21         
    22         }
    23     }
    24     public static void printArray(int arr[])   //打印数组的格式 {x,x,x,x......}
    25     {
    26         sop("{");
    27         for(int x=0;x<arr.length;x++)
    28         {
    29             if(x!=arr.length-1)
    30                 sop(arr[x]+",");
    31             else
    32                 sop(arr[x]+"}");
    33         }
    34         sop("
    ");
    35     }
    36     public static void sop(Object obj)  //打印任何对象
    37     {
    38         System.out.print(obj);
    39     }
    40     public static void main(String[] args) 
    41     {
    42         int arr[]={3,1,5,6,2};//创建数组
    43         sop("交换前的数组为");
    44         printArray(arr);
    45         reverseArray(arr);
    46         sop("交换后的数组为");
    47         printArray(arr);
    48     }
    49 }

    4、实战演练 LuckNumber

    class  LuckNumber
    { /*有n个小朋友手拉手围成圈,编号为1~n,小朋友轮流从1开始报数报到m,
       报到m的自动退出该圈,游戏到最后剩下的是几号小朋友?
       分析:将小朋友的个数存到数组中,
             当报到m时,将该数组元素变成0;
             当碰到0时,指针自动读取下一个元素,
             当报到最后一个时,指针跳到0角标,从新开始
    */
        public static void sop(Object obj)//打印任何对象
        {
            System.out.print(obj);
        }
        public static int getLuck(int arr[],int m)
        {   int pos=-1,num=0;
            for(int x=0;x<arr.length-1;x++) //取出元素个数-1的个数,目的取出唯一剩到最后的元素
            {
                for(int y=0;y<m;y++)//每次数过m个非零的元素时,使该元素变为零
                { pos++;
                    if (pos==arr.length)
                        pos=0;
                    while(arr[pos]==0)
                    {pos++;
                        if (pos==arr.length)
                        { pos=0;
                        }
                    }
                    
                }
                arr[pos]=0;
            }
            for(int t=0;t<arr.length;t++)//寻找
            {
                if (arr[t]!=0)
                { 
                    num=arr[t];
                }
            }
            return num;
        }
        public static void main(String[] args) 
        {
            int n=3,arr[]=new int[n];//建立数组,通过for循环将1~12传入数组
            for(int i=1;i<=arr.length;i++)
            {
                arr[i-1]=i;
            }
            sop(getLuck(arr,2));//将数组和被淘汰的号码传入
        }
    }
  • 相关阅读:
    测试代码
    内网与外网间通信[转]
    向微软首席执行官史蒂夫·鲍尔默致敬
    Spring Cloud OAuth2
    Docker搭建 MySQL 主从复制
    MySQL-查询结果缓存
    网页手机wap2.0网页的head里加入下面这条元标签,在iPhone的浏览器中页面将以原始大小显示,并不允许缩放
    Mybatis一对一关联查询
    application.Properties 自定义变量 注解@ConfigurationProperties使用方法
    Hibernate中的脏检查和缓存清理机制
  • 原文地址:https://www.cnblogs.com/ktlshy/p/4713095.html
走看看 - 开发者的网上家园