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

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、概念

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

        使用数组的好处：可以自动给数组中的元素从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         //第一次遍历时x23         //第二次遍历时y
24         int sum=0,x,y;
25         for(x=0;x)
26         {
27             for(y=0;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//外循环遍历数组  
22         {
23             for(int y=x+1;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//原理是从零角标开始，相邻角标元素值大的往后面放，
33         {                                //因此遍历一次后，该数组最大的元素在最后面
34             for(int y=0;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//打印数组的格式   {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("\n");
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//将数组的两端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)
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)
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//取出起始位和末尾位，只要起始位能够小于末尾位
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)
28         {
29             if(x!=arr.length-1)
30                 sop(arr[x]+",");
31             else
32                 sop(arr[x]+"}");
33         }
34         sop("\n");
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//取出元素个数-1的个数，目的取出唯一剩到最后的元素
        {
            for(int y=0;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//寻找
        {
            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));//将数组和被淘汰的号码传入
    }
}

 

转载于:https://www.cnblogs.com/ktlshy/p/4713095.html