javaCode的数组2

数组的两种定义格式

1：第一种
格式1:
需要一个容器，但是不明确容器的具体数据。
元素类型[] 数组名=new 元素类型[长度]。
int[] arr=new int[3];

2：第二种
格式二：
需要一个容器，存储已知的具体数据。
元素类型[] 数组名=new 元素类型[]{元素1,元素2,……};
int[] arr=new int[]{89,34,29,23};
int[] arr2={89,34,29,23};

对数组的操作

1：对数组遍历

    public class Demo{
        public static void main(String[] args){
            int[] arr=new arr[]{1,34,45,51,2,3};
            //第一种循环遍历
            for(int x=0;x<arr.length;x++){
                            System.out.println("arr["+x+"]="arr[x]);
            }
            //第二种循环遍历
            for(int y=arr.length-1;y>=0;y--){
                            System.out.println("arr["+x+"]="arr[x]);
            }
        }
    }

2:对数组的操作取最值

    //第一种取最值的方式
    public class Demo{
        public static void main(String[] args){
            int[] arr =new int[1,2,41,12,345,11];

            int maxElement=arr[0];
            for(int x=1;x<arr.length;x++){
                if(arr[x]>maxElement){
                    maxElement=arr[x];
                }
            }
            Sysout.out.println("maxElement="+maxElement);
        }
    }

    //第二种取最值的方式
    public class Demo{
        public static void main(String[] args){
            int[] arr =new int[1,2,41,12,345,11];
            int maxIndex=0;
            for(int x=1;x<arr.length;x++){
                if(arr[x]>arr[maxIndex]){
                    maxIndex=x;
                }       
            }
            System.out.println(arr[maxIndex]);
        }
    }

3:数组的操作从小到大的排序

    public class Demo{
        public static void main(String[] args){
            int[] arr =new int[1,2,41,12,345,11];

            for(int x=0;x<arr.length;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;
                    }
                }
            }
        }
    }

4:数组操作冒泡排序

    public class Day05Array05_1 {
    public static void main(String[] args) {
            int[] arr={34,19,11,109,3,56};
        //  Arrays.sort(arr);//java中定义的冒泡排序方法

            for(int x=0;x<arr.length;x++){
                System.out.println(arr[x]);
            }

            maopao(arr);
    }

    private static void maopao(int[] arr) {
        /*
         * 内循环:
         * -1:为了避免角标越界
         * -x:为了让外循环增加一次，内循环参数与比较
         *      的元素个数递减
         * */
        for(int x=0;x<arr.length-1;x++ ){

                for(int y=0;y<arr.length-1-x;y++){
                    if(arr[y]>arr[y+1]){
                        int temp=arr[y]; 
                        arr[y]=arr[y+1];
                        arr[y+1]=temp;
                    }
        }
    }


        for(int k=0;k<arr.length;k++){
            System.out.println(arr[k]);
        }
}
}

5：数组的操作查找

    public class Demo{
        public static void main(String[] args){
            int[] arr={1,2,3,4,5};
            int index=getIndex(arr, 5);
            System.out.println("index="+index);
        }

        public static int getIndex(int[] arr,int key){
            for(int x=0;x<arr.length;arr++){
                    if(arr[x]=key){
                        return key;
                    }
            }
            return -1;
        }

    }

6:数组-折半查找(二分法)
二分法使用的前提是数据必须要有序

    public class Demo(){
        public static void main(String[] args){
            int[] arr={1,2,3,4,5,6,7,8};
            int index=halfSearch(int[] arr;5);
            System.out.println("index:"+index);
        }

    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[min]){
                    min=mid+1;      
                }else if(key<arr[mid]){
                    max=mid-1;  
                }
                if(max<min){
                    return -1;
                }
                mid=(max+mid)/2;
            }
                return mid;
        }
    }

    public static int halfSearch_2(int[] arr,int key){
        int max,min,mid;
        min=0;
        max=arr.length-1;
        while(min<=max){
                mid=(max+min)/2;
                if(key>arr[mid]){
                    min=mid+1;
                }else if(key<arr[mid]){
                    max=mid-1;
                }else{
                    return mid;
                }
        }
        return -1;
    }