java学习笔记 --- 数组

一、Java的内存分配
 　　 A:栈内存： 存储局部变量，只要是在方法中定义的变量都是局部变量。一旦变量的生命周期结束该变量就被释放。
 　　 B:堆内存： 存储所有new出来的，及实体（对象），每一个实体都有一个首地址值，每一个变量都有默认初始化值，不同类型的不一样。

　　　　　　　　当实体不在使用时，就会被垃圾回收机制处理。
  　　C:方法区(面向对象部分详细讲解)
  　　D:本地方法区(系统相关)
 　　 E:寄存器(CPU使用)

二、数组　　

　　(1)定义：存储同一种数据类型的多个元素的容器。
　　(2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。
          　　　编号的专业叫法：索引
　　(3)定义格式
 　　　　 A:数据类型[] 数组名;(推荐使用）
  　　　　B:数据类型 数组名[];（知道就好，一般不用）
　　(4)数组的初始化
 　　　　 A:动态初始化
  　　　　 只给长度，系统给出默认值
   　　　　　　举例：int[] arr = new int[3];
 　　　　 B:静态初始化
 　　　　  给出值，系统决定长度
 　　　　　　  举例：int[] arr = new int[]{1,2,3};
 　　　　　　  简化版：int[] arr = {1,2,3};
 
  
三、数组的常用方法

public class Dome1 {
        public static void main(String[] args) {
            //使用输入值初始化数组
            int[] arr = new int[10];
            //调用想要的方法
            
    
        }
        //使用输入值对数组初始化
        public static void chu(int[]arr){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入数组值：");
            for(int x =0;x<arr.length;x++){
                arr[x] = sc.nextInt();
            }
        }
        //使用随机数初始化数组
        public static void rando(int[] arr){
            for(int x=0;x<arr.length;x++){
                arr[x] = (int) (Math.random()*100);
            }
        }
        
        //数组的遍历 方式1
        public static void printArray(int[] arr){
            for(int x=0;x<arr.length;x++){
                System.out.println(arr[x]);
            }
        }
        
        //遍历方式2
        public static void printArray2(int[]arr){
            System.out.print("[");
            for(int x=0;x<arr.length;x++){
                if(x != arr.length-1){
                    System.out.print(arr[x]+",");
                }else{
                    System.out.print(arr[x]+"]");
                }
            }
            System.out.println();
        }
        //对数组中的所有元素求和
        public static int sum( int arr[]){
            int sum = 0;
            for(int x=0;x<arr.length;x++){
                sum +=arr[x];
            }
            return sum;
        }
        //找出最大元素级下标
        public static int max(int[] arr){
            int max = arr[0];
            int indexOfMax = 0;
            for(int x=0;x<arr.length;x++){
                if(arr[x]>max){
                    max= arr[x];
                    indexOfMax = x;
                }else{
                    max = max;
                    indexOfMax = 0;
                }
                    
            }
            return max;
            
        }
        //找出元素最小值及下标
        public static int min(int[]arr){
            int min = arr[0];
            int indexOfMin = 0;
            for(int x=0;x<arr.length;x++){
                if(arr[x]<min){
                    min = arr[x];
                    indexOfMin=x;
                }else{
                    min = min;
                }
            }
            return min;
        }
        //随意打乱元素
        public static void rodm(int[] arr){
            for(int x=0;x<arr.length;x++){
                int index = (int) Math.random()*arr.length;
                
                //交换下标
                int temp = arr[x];
                arr[x] = arr[index];
                arr[index] = temp;
            }
        }
        //移动元素
        public static void shift(int[] arr){
             int temp = arr[0];
            for(int x=1;x<arr.length;x++){
                arr[x-1] = arr[x];
            }
            arr[arr.length-1] = temp;
        }
        //增强for 遍历数组
        public static void bin(int[]arr){
            for (int i : arr) {
                System.out.println(arr[i]);
                
            }
        }
        
}

四、数组的排序方法

public class Dome3 {
    public static void main(String[] args) {
        
    }
    //选择排序
　　

    public static void selectionSort(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;
                    }
                }
            }
        }
    //冒泡排序
    public static void bubbleSort(int[] arr)
    {
        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;
                }
            }
        }
    }

}

说明：

1、选择排序

　　选择排序是排序中的一种。算法原则（从小到大排序）：先用数组中第一个空间值和数组中剩余的其他空间值一一做比较，在比较的过程有任何值比第一个空间值小，就用第一个空间值和当前这个空间值换位置，直到所有值和第一个空间值全部比较完。第一个空间中就放着最小值。接着在使用数组第二个空间值和数组中剩下空间中值做比较，比较方式和前一次相同。以此类推，比较完成。

　　规律：第一个空间和剩余空间比一圈，第二个空间在和剩余空间比一圈，以此类推，到倒数第二个空间值和最后一个空间值比完，整个数组有有序了。正好符合了外循环循环一次，内循环执行一圈。即外循环控制每次到底使用那个空间值和剩余空间比较，内循环提供剩余空间。

　　图解：

　　                              　　

2、冒泡排序

　　冒泡排序算法原理：这种算法和生活中常见的水中气泡的浮沉类似。

　　数组冒泡算法（从小到大）：

　　　　第一轮：数字第一个空间值和第二个空间值比较，把较大的值存在第二个空间中，接着第二个空间值和第三个空间值作比较，较大的值存在第三个空间中，以此类推直到倒数第二个空间和倒数第一个空间比较，把较大值存放在最后一个空间中。

　　　　第二轮：由于最后一个空间已经是最大值了，那么第二轮算法和第一轮一样，只是最后一次比较是倒数第三个空间和倒数第二个空间比较。把较大的值存在倒数第二个空间中。

　　　　以此类推。

　　图解：

　　　　

五、数组的查找方法

public class Dome2 {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5, 6 };
        System.out.println(binarySearch(arr, 6));

    }

    // 线性查找，根据需要找的数，找到在数组中的下标
    public static int linearSearch(int[] arr, int k) {
        for (int x = 0; x < arr.length; x++) {
            if (k == arr[x]) {
                return x;
            }

        }
        return -1;
    }
    //二分法查找，数组必须有序
    public static int binarySearch(int[] arr, int k){
        int low = 0;
        int high = arr.length-1;
        while(high>=low){
            int mid = (low+high)/2;
            if(k<arr[mid]){
                high = mid-1;
            }else if(k == arr[mid]){
                return mid;
            }else{
                low = mid+1;
            }
                
        }
        return -1;
    }
}

 说明：

1、一半查找

从组中第一个空间开始查找，每取出一个空间值和待查找的数值做比较，若相等，就返回当前角标，若数组遍历结束，没有找到相等的值，则返回-1.

2、二分法查找

折半查找，必须保证数组已经是有序的。

思路：

       1，通过角标先获取中间角标上元素。

       2，让该元素和要找的数据比较。

       3，如果要找的数大了，缩小范围，要找的范围应该是 中间的角标+1---尾角标。

            如果要找的数小了，要找的范围 头角标---中间角标-1；

       4，不断如此重复，就可以找到元素对应的角标。

 六、arrays类

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。