Java数组详解

版权声明：本文为博主原创文章，未经博主允许不得转载。

数组：数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序顺序排列组合而成。其中，每一个数据作一个元素，每个元素可以通过一个索引（下标）来访问他们。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量

数组基本特点：

1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

2.其元素必须是相同类型，不允许出现混合类型。

3.数组类型可以是任何数据类型，包括基本类型和引用类型

数组的声明方式

type[] arr_name;//推荐使用方式
type   arr_name[];

定义数组，给数组赋值，当给创建数组时，栈内存中有变量，堆内存什么都没有，当给数组分配空间10以后，才会在堆内存中给数组真的分配空间。

注意：数组长度为0与null不相同

创建引用类型的一维数组

数组的初始化方式分为三种：静态初始化，动态初始化，默认初始化

//静态初始化
int[] a={1,2,3,4,5,6,7,8,9,11,12,32,43,,54,34,35};

数组默认初始化与成员变量默认初始化相同

数组遍历

增强for循环：for-each是JDK1.5新增的功能，专门用于读取数组或集合中所有元素，即对数组进行遍历。但是不能修改数组或集合中元素的值

ss代表要遍历的数组，temp时一个中间临时变量。

增强for循环不能遍历二维数组，要想访问多维数组的所有元素，就要用到嵌套。

二维数组

public class Test01{

    public static void main(String[] args){
        //静态初始化
        int[][] a={
        
            {1,2},
            {3,4,0,9},
            {5,6,7}    
        }
        //动态初始化
         int[][] a=new int[3][];
         a[0]=new int[2];
         a[1]=new int[4];
         a[1]=new int[3];
         a[0][0]=new int[1]; 
         a[0][1]=new int[2];
  
         a[1][0]=new int[3];  
         a[1][1]=new int[4];  
         a[1][2]=new int[0];  
         a[1][3]=new int[9];
  
         a[2][0]=new int[5];  
         a[2][1]=new int[6];  
         a[2][2]=new int[7];  
  
    }
}

二维数组的内存分析

二维数组例子：矩阵的运算

public class Materix{

    public static void main(String[] args){
        
        int[][] a={
            {1,2},{2,4}
        };
        
        int[][] a={
            {3,4},{5,6}
        };
        
        int[][] c=new int[2][2];
        for(int i=0;i<c.length;i++){
            for(int j=0j<c.length;j++){
                c[i][j]=a[i][j]+b[i][j]
            }
        }
        
    }
}

实际上java中没有多维数组，只有一维数组，因为多维数组被解释为“数组的数组”，而这也正是java的一个优势所在。

 

在java.util.Arrays类下有很多对数组操作的方法，具体请看java的API,里面会有对方法使用的详细解释。

数组的拷贝，用System类中的arratcopy方法，java.util.Arrays包含了操作数组的各种方法，比如搜索、排序，aList方法用于将数组转换成集合。

Arrays.sort(a)数组的排序，Arrays.toString(a)打印数组   数组的填充  Arrays.file(a,2,4,100);将2到4索引的元素替换为100

二分查找法 

//二分法查找的前提是：数组的顺序必须是已经排好的
public class TestBinarySearch{
    public static void main(String[] args){

        System.out.println(args[1]);
        int[] arr={234,245,77,3,543,67,78,95,378,205,369,703,251}
        int searchWord=6780;//所要查找的数
        int searchCount=0;//循环的次数

        System.out.println("普通循环查找%d的次数是%d"，searchWord,genetalLoop(arr,searchWord));
 System.out.println("二分法查找%d的次数是%d"，searchWord,binarySearch(arr,searchWord));

        static int genetalLoop(int[] arr,int searchWord){
            // 普通循环发，最好需要比较一次，比如查找1；
            int searchCount=0; 
        for(int 1=0;i<arr.length;i++){
                
                searchCount++;
                if(searchWord==arr[i])
                break;
            }
          return searchCount;
        }
    }

    static int binarySearch(int[] arr,int searchWord){

        Arrays,sort(arr);//首先对传进来的数组进行排序
        //二分查找法
        int index=0;//相当于指针的东西
        int iStart=0;
        int iEnd=arr.length;
        int searchCount=0;
        for(int i=0;i<arr.length/2;i++){
            searchCount++;
            index=(iStart+iEnd)/2;
            if(arr[index]<searchWord){
                iStart=index;
            }else if (arr[index]>searchWord){
                iEnd=index
            }else{break;}
        }
      return searchCount;
    }


}

 

冒泡排序法

public class Test{

        public static void main(String[] args){

        int[] values={2,1,0,5,9,7,6,3,15,21};
        sort(values);
    System.out.println(Arrays.toString(values));
    }

    public static void sort(int[] values){
        int temp;
        for(int i=0;i<values.length;i++){
            for(int j=0;j<values.length-1-i;j++){
                if(values[j]>values[j+1]){
                temp=values[j];
                values[j]=values[j+1];
                values[j+1]=temp;
                }
            }
        }
    }
}

//从小到到达排序，会先将最大的找出来，放到最后；从大到小排列，会先将最小的找出来放放到最后
//第一次完全把数组遍历一次，把最小的找出来了，再遍历一次会把比最小的大一个的数找出来，以此类推。

转载请注明出处！