Java基础--数组

数组

一维数组

1. 概念：同一种类型数据的集合，其实数组就是一个容器；
2. 数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素；

3. 定义一维数组的格式：

   • 元素类型[ ] 数组名 = new 元素类型[元素个数或数组长度]；
     示例：int[ ] arr=new int[4];//数组元素不明确时用这种方式；指定角标的方式赋值:
     arr[0]=3;
     arr[1]=4;
     arr[2]=5;
     arr[3]=7;
   • 元素类型[ ] 数组名=new 元素类型[ ]{元素1，元素2，元素3……}；
     例：int[ ] arr=new int [ ]{3,4,5,7};//当元素内容明确时用这种方式
     　　int[ ] arr={3,4,5,7};//这两种写法是等效的；

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

   • 栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放；
   • 堆内存：
     数组和对象都存放在堆内存中；
     每个实体都内存地址值；
     实体中的变量都有默认初始化值；
     实体不再被使用，会在不确定的时间内被垃圾回收器回收；
   • 方法区；
   • 本地方法区；

   • 寄存器；

   • 注：

     1. int[] arr=new int[5];
        arr=null;//该语句表示数组arr指向为null、此时之前建立的数组不在被使用；
     2. 数组的属性之一：可以直接获取到数组元素的个数length
        使用方式：数组名称.length；
        例：打印某个数组的长度：System.out.println(arr.length);

5. 给数组中的元素排序；
   数组排序可使用嵌套循环来完成；

   • 选择排序
     
     代码示例：

     class SelectorSort
     {
         public static void selector(int[] arr)
         {
             for(int x=0;x<arr.length-1;x++)
             {
                 for(int y=x+1;y<arr.length;y++)
                 {
                     if(arr[x]>arr[y])
                     {
                         int temp=arr[x];
                         arr[x]=arr[y];
                         arr[y]=temp
                     }
                 }
             } 
         }
     }
     

   • 冒泡排序：相邻的两个元素进行比较，如果符合条件换位；
     
     代码示例；

     class BubbleSort
     {
     public static void bubbleSort(int[ ] arr)
     {
         for(int a=0;a<arr.length-1;a++)
         {
             for(int b=0;b<arr.length-a-1;b++)
             {
                 if(arr[b]>arr[b+1])
                 {
                     int temp=arr[b];
                     arr[b]=arr[b+1];
                     arr[b+1]=temp;
                 }
             }
         }
     }
     }

   • 开发中Java有排序功能：Arrays.sort(数组名);

6. 查找

   • 顺序查找（定义一个变量，遍历数组元素将对应值赋给变量）
   • 折半查找：提高效率，但保证是有序的数组
     

     import java.util.*;
     class ArrayTest 
     {
     public static void main(String[] args) 
     {
     //      int[] arr = {3,2,1,5,4,2,9};
     //      int index = getIndex(arr,2);
     //      System.out.println("index="+index);
     
         int[] arr = {2,4,5,7,8,19,32,45};//8
     
         int index = getIndex_2(arr,190);
         System.out.println("index="+index);
     }
     //int x = Arrays.binarySearch(arr,190);//java提供好的一个进行折半查找的功能。开发时使用这个。
     //System.out.println("x="+x);
     public static int getIndex_2(int[] arr,int key)
     {
         int min = 0,max = arr.length-1,mid;
         while(min<=max)
         {
             mid = (max+min)>>1;
             if(key>arr[mid])
                 min = mid + 1;
             else if(key<arr[mid])
                 max = mid - 1;
             else
                 return mid;
         }
         return min;
     }
     
     /*
     折半的第二种方式。
     */
     public static int halfSearch_2(int[] arr,int key)
     {
         int min = 0,max = arr.length-1,mid;
     
         while(min<=max)
         {
             mid = (max+min)>>1;
     
             if(key>arr[mid])
                 min = mid + 1;
             else if(key<arr[mid])
                 max = mid - 1;
             else
                 return mid;
         }
         return -1;
     }
     /*
     折半查找。提高效率，但是必须要保证该数组是有序的数组。
     */
     public static int halfSearch(int[] arr,int key)
     {
         int min,max,mid;
         min = 0;
         max = arr.length-1;
         mid = (max+min)/2;
     
         while(arr[mid]!=key)
         {
             if(key>arr[mid])
                 min = mid + 1;
             else if(key<arr[mid])
                 max = mid - 1;
     
             if(min>max)
                 return -1;
             mid = (max+min)/2;
         }
         return mid;
     }
     //定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。
     public static int getIndex(int[] arr,int key)
     {
         for(int x=0; x<arr.length; x++)
         {
             if(arr[x]==key)
                 return x;
         }
         return -1;
     }
     }

7. 进制转换
   二进制转十进制、八进制、十六进制的通用方法：

   class ArrayTest 
   {
   public static void main(String[] args) 
   {
       //toBin(-6);
       //toHex(-60);
       //toBa(60);
   //      System.out.println(Integer.toBinaryString(6));
   //      System.out.println(Integer.toHexString(6));
   }
   /*
   十进制-->二进制
   */
   public static void toBin(int num)
   {
       trans(num,1,1);
   }
   /*
   十进制-->八进制
   */
   public static void toBa(int num)
   {
       trans(num,7,3);
   }
   /*
   十进制-->十六进制
   */
   public static void toHex(int num)
   {
       trans(num,15,4);
   }
   public static void trans(int num,int base,int offset)
   {
       if(num==0)
       {
           System.out.println(0);
           return ;
       }
       char[] chs = {'0','1','2','3'
                   ,'4','5','6','7'
                   ,'8','9','A','B'
                   ,'C','D','E','F'};
       char[] arr = new char[32];
       int pos = arr.length;
       while(num!=0)
       {
           int temp = num & base;
           arr[--pos] = chs[temp];
           num = num >>> offset;
       }
       for(int x=pos; x<arr.length; x++)
       {
           System.out.print(arr[x]);
       }
       return ;
   }
   }
   

二维数组

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；
   • 可以对这三个一维数组分别进行初始化；
     arr[0]=new int[3];//初始化二维数组的一维数组长度为3；
     arr[1]=new int[1];
     arr[2]=new int[2];

3. 数组为引用数据类型，默认初始化值为null；
   例：定义数组int[ ][ ] arr=new int[3][ ];
   　　则：arr[0]=null;

   • arr.length为二维数组的长度；
   • 二维数组的静态初始化方式：
     int[][] arr={{3,4,5},{3,5},{1,4,8}};

4. 数组的定义形式有多种：

   • 一维数组的定义形式：
     int[ ] x;等同于：int x[ ];
   • 二维数组的定义形式：
     int[ ][ ] y；等同于 int y[ ][ ];等同于 int[ ] y[ ];
     综上所述：
     　　int[ ] x,y[ ]；等同于int[ ] x；int[ ] y[ ];
     　　即：x为一维数组，y为二维数组；