Java 学习 day04

17-数组(概述-内存结构)

概念：同一种类型数据的集合，其实数组就是一个容器。

可以自动给数组中的元素从0开始编号，方便操作这些元素。

int[] x = new int[3];

01-数组(静态初始化-常见问题)

int[] arr = new int[]{3,1,6,5,4}; //静态初始化方式

简化形式： int[] arr = {3,1,6,5,4};

常见问题：

①ArrayIndexOutOfBoundsException  操作数组时，访问到了数组中不存在的角标。

②NullPointerException 空指针异常：当引用没有任何指向值为null的情况，该引用还在用于操作实体。

02-数组(常见操作-遍历)

数组的操作：获取数据中的元素。通常会用到遍历。

length -- 数组中有一个属性可以直接获取到数组元素个数：

使用方式：数组名称.length 

Eg:定义功能，用于打印数组中的元素。元素之间用逗号隔开。

    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                System.out.print(arr[i] + ",");
            } else {
                System.out.println(arr[i]);
            }
        }
    }

03-数组(常见操作-获取最值)

Eg：给定一个数组{5,1,6,4,2,8,9} 1. 获取数组中的最大值以及最小值

package myFirstCode;

/*
 * 给定一个数组{5,1,6,4,2,8,9} 1. 获取数组中的最大值以及最小值
 */
public class ArrayTest {
    
    /*
     * 获取数组中最大值。
     * 思路：
     * 1. 获取最大值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
     * 通过一个变量进行临时存储。
     * 2. 让数组中的每一个元素都和这个变量中的值进行比较。
     * 如果大于了变量中的值，就用该变量记录最大值。
     * 3. 当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值。
     * 
     * 步骤：
     * 1.定义变量。初始化为数组中任意一个元素即可。
     * 2.通过循环语句对数组进行遍历。
     * 3.在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；
     * 
     * 需要定义个功能来完成。一遍提高复用性。
     * 1.明确结果，数组中的最大元素 int 
     * 2.未知内容：一个数组 int[]
     */

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = { 5, 2, 6, 4, 9, 8, 1 };
        System.out.println("最大值="+getMax(arr));

    }

    public static int getMax(int[] arr) {
        int tmp = arr[0], tmp1 = arr[0];
        for (int i = 1; i < arr.length; i++) {

            if (arr[i] > tmp) {
                tmp = arr[i];
            }
            if (arr[i] < tmp1) {
                tmp1 = arr[i];
            }

        }
        return tmp;
//        return tmp1;
    }

}

04-数组(排序-选择排序)

Eg：对给定数组进行排序。

选择排序：内循环结束一次，最值出现头角标位置上。

package myFirstCode;
/*
 * 对给定数组进行排序。
 * {5,1,6,4,2,8,9}
 */
public class ArrayTest2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {5,1,6,4,2,8,9};
        //排序前：
        printArray(arr);
        //排序
        selectSort(arr);
        //排序前：
        printArray(arr);
    }
    
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                System.out.print(arr[i] + ",");
            } else {
                System.out.println(arr[i]+"]");
            }
        }
    }
    
//选择排序
    public static void selectSort(int[] arr){
        
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if (arr[i]<arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }                
            }            
        }        
    }
    
//冒泡排序
    public static void bubbleSort(int[] arr)
    {
        for (int i = 0; i < arr.length-1; i++) 
        {
            for (int j = 0; j < arr.length-i-1; j++) //-x:让每一次比较的元素减少，-1：避免角标越界。
            {
                if (arr[j]<arr[j+1])
                {
                    int temp = arr[j];    
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    
                    
                }
            }
        }
    }
}

05-数组(排序-冒泡排序)

冒泡排序：相邻的两个元素进行比较，如符合条件换位。第一圈：最值出现了最后位。

Eg：对给定数组进行排序。

    public static void swap(int[] arr,int a,int b){
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

***//Arrays.sort(arr); // java中已经定义好的一种排序方式，开发中，对数组排序，要使用此方法。***

package myFirstCode;
/*
 * 对给定数组进行排序。
 * {5,1,6,4,2,8,9}
 */
public class ArrayTest2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {5,1,6,4,2,8,9};
        //排序前：
        printArray(arr);
        //排序
        selectSort(arr);
        //排序前：
        printArray(arr);
    }
    
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                System.out.print(arr[i] + ",");
            } else {
                System.out.println(arr[i]+"]");
            }
        }
    }
    
    public static void selectSort(int[] arr){
        
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if (arr[i]<arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }                
            }            
        }        
    }
}

06-数组(排序-位置置换功能抽取)

 任何排序，都需要对满足条件的元素进行位置置换，所以可以把这部分相同的代码提取出来，单独封装成一个函数。

Eg：

public static void swap(int[] arr,int a,int b){
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

07-数组(折半查找)

数组的查找

package myFirstCode;
/*
 * 数组的查找
 */
public class ArrayTest4 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {3,1,5,4,2,9};
        int index = getIndex(arr,2);
        System.out.println("index="+index);
    }

    //定义功能，获取key第一次出现在数组中的位置，如果返回是-1，那么代表该key在数组中不存在。
    public static int getIndex(int[] arr,int key)
    {
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==key)
                return i;            
        }
        return -1;
    }

}

折半查找

package myFirstCode;

/*
 * 数组的查找
 */
public class ArrayTest4 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // int[] arr = {3,1,5,4,2,9};
        // int index = getIndex(arr,2);
        int[] arr = { 1, 3, 5, 7, 9, 25, 33 };
        int index = halfSearch(arr, 9);
        System.out.println("index=" + index);
    }
    
    /*
     * 折半的第二种方式。
     */
    public static int halfSearch2(int[] arr,int key)
    {
        int min = 0,max = arr.length-1,mid;
        while (min<=max) {
            mid = (max+min)>>1;// >>1 等于 /2
            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, mid, max;
        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 i = 0; i < arr.length; i++) {
            if (arr[i] == key)
                return i;
        }
        return -1;
    }

}

练习，有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的。

    /*
     * 练习，有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的。
     */
    public static int getIndex_2(int[] arr,int key)
    {
        int min = 0,max = arr.length-1,mid;
        while (min<=max) {
            mid = (max+min)>>1;// >>1 等于 /2
            if(key>arr[mid])
                min = mid + 1;
            else if(key<arr[mid])
                max = mid - 1;
            else 
                return mid;
        }
        return min;
    }

08-数组(十进制-二进制)

Eg:

public class ArrayTest5 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        toBin(6);
    }

    public static void toBin(int num)
    {
        StringBuffer sb = new StringBuffer();
        while (num > 0) 
        {
            sb.append(num%2);
            num = num / 2;    
        }
        System.out.println(sb.reverse());
        
    }
}

09-数组(十进制-十六进制)

Eg：

package myFirstCode;

public class ArrayTest5 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        toBin(6);
        toHex(60);
    }

    public static void toHex(int num)
    {
        StringBuffer  sb = new StringBuffer();
        for (int x = 0; x < 8; x++) 
        {
            int temp = num & 15;
            if(temp>9)
                sb.append((char)(temp-10+'A'));
            else
                sb.append(temp);
            
            num = num >>>4;
        }
        System.out.println(sb.reverse());
    }
    
    
    public static void toBin(int num)
    {
        StringBuffer sb = new StringBuffer();
        while (num > 0) 
        {
            sb.append(num%2);
            num = num / 2;    
        }
        System.out.println(sb.reverse());
        
    }
}

10-数组(查表法十进制-十六进制)

11-数组(查表法十进制-二进制)

12-数组(进制转换优化)

13-数组(二维数组)

int[][] arr = new int[3][4]; //定义了名称为arr的二维数组。二维数组中有3个一维数组。

　　　　　　　　　　　　　　//每一个一维数组中有四个元素。

package myFirstCode;

public class Array2Demo {

    public static void main(String[] args) {
//        // TODO Auto-generated method stub
//        //int[] arr = new int[3];//一维数组
//        int[][] arr = new int[3][4];//定义了名称为arr的二维数组。二维数组中有3个一维数组。
//                                    //每一个一维数组中有四个元素。
//        System.out.println(arr[0]);
        /*
        int[][] arr = new int[3][];
        
        arr[0] = new int[3];
        arr[1] = new int[1];
        arr[2] = new int[2];
        
        System.out.println(arr.length);
        System.out.println(arr[2].length);
        */

        int[][] arr = {{3,5,7,9},{2,3,4,6},{1,5,8,9}};
        
        int sum = 0;
        for (int x = 0; x < arr.length; x++) {
            for (int y = 0; y < arr[x].length; y++) {
                sum = sum + arr[x][y];    
            }
        }
        System.out.println("sum="+sum);
        
    }

}

14-数组(二维数组练习)

一维数组--int[] x;int x[];

二维数组--int[][] y;int y[][];int[] y[];

int[] x,y[];  --等同于--  int[] x; int[] y[];