Java基础学习-4

1、数组的使用

        数组是引用类型 ，数据存放在堆

        数组的知识点掌握

        1.1、声明数组、创建数组对象、数组的数据访问【索引-内存】

                - -数组的声明 int[] arr;int arr[];

                数组对象的创建，必须指定数组长度，固定长度

                静态方式：直接给数值

                        arr = {1,2,3,4,5,6};

                动态的形式

                        arr = new int[6];

        1.2、遍历数组【for、foreach】

                访问从0开始

//一维遍历
//for
for(int i = 0;i<arrays.length;i++){
    System.out.println(arrays[i]); 
}
//foreach
for(int is:arrays){
    System.out.println(is); 
}
//二维 for
for(int i = 0;i<arrays.length;i++){
    for(int k = 0;k<arrays[i].length;k++){     
    System.out.println(arrays[i][k]);       
    }
}
//二维 foreach
for (int[] is:arrays){
    for(int i:is){
        System.out.println(i);    
    }
}

        1.3多维数组的定义和创建

                   多维数组就是一个数组中包含多个数组

                {

                        {1,2,3},

                        {4,5,6},

                        {7,8,9}

                };

                arrays[1][2]//第二个一位数组，第三个元素

                注意数组越界异常：

        总结：

                1.变量是在栈内存定义的，里面存放的是数组的引用地址

                2.数组是一个引用类型，数组是一个对象数据，存放在堆内存中

                3.一维数组：

                        【基本数据类型】：当前堆内存块中直接存放该数值

                        【引用类型】：当前内存块中存放是该引用类型的对象地址

                4.多维数组

                        当前堆内存块中存放是该子数组的对象引用地址

                        java 基本数据类型传递参数时是值传递 ；

                        引用类型传递参数时是引用传递 。

                        然而数组虽然是引用传递 ，但是将引用 z = null 只是将引用z不指向任何对象 ，并不会对原先指向的对象数据进行修改 。

        1.4 、数组排序以及操作

                1.4.1、冒泡排序

                             每次操作后，确定一位；每确定一位，下一次操作的比较次数减一；它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

import java.util.Arrays;
/**
 * @quthor chenxys;
 * @version 1.0
 * @deprecated 冒泡排序
 * */

public class BubbleSorting {
    public static void main(String[] args) {
        //定义一个数组
        int[] arrys = {12,3,2,56,43};
        //操作次数，->n-1
        for (int i = 0; i <arrys.length-1 ; i++) {
            //第i次操作，每次操作减1;->n-i-1
            for (int j = 0; j < arrys.length-i-1; j++) {
                //判断是否前一个数比后一个大
                if (arrys[j]>arrys[j+1]){
                    //借助中间变量，实现交换
                    int temp = arrys[j];
                    arrys[j] = arrys[j+1];
                    arrys[j+1] = temp;
                }
            }
        }
        //通过Arrays.toString(arrys)进行输出
        System.out.println(Arrays.toString(arrys));//把arrays转换为字符串
        //对数组进行遍历输出
//        for (int is:
//             arrys) {
//            //排序之后，进行输出
//            System.out.print(is+"\t");
//        }
    }
}

                1.4.2、选择排序

                        选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

import java.util.Arrays;

public class SelectionSort_1 {
    public static void main(String[] args) {
        //原数据并进行打印
        int[] array = {11,33,20,33,13,8};
        System.out.print("原数据:");
        System.out.println(Arrays.toString(array));
        //第i次操作
        for (int i = 0; i <array.length-1 ; i++) {
            //定义一个临时变量用于存储较小值
            int k = i;
            //从第i+1个开始看
            for (int j = i+1; j <array.length ; j++) {
                //判断当前这个数是否比后面的数小
//                if (array[k]>array[j]){
//                    //大于后面的就和后面的进行交换
//                    k = j;//最小的索引
//                }
                //当后面的值小于k所代表的值时，进行交换
                if (array[j] < array[k]) {
                    k = j;
                }else if (array[j] == array[k]){
                    continue;
                }

                //起始位置和遍历之后的位置如果不相等，就交换位置
                //把最小的和起始位置进行交换
                if (i != k) {
                    //定义一个临时变量
                    int temp = array[i];
                    array[i] = array[k];
                    array[k] = temp;
                }
            }
        }

        //打印数组
        System.out.println("交换后：");
        System.out.println(Arrays.toString(array));
    }
}

                1.4.3、折半逆转（反转数组）（倒序）              

import java.util.Arrays;
public class HalfReversal_1 {
    public static void main(String[] args) {
        //定义一个数组存放元素,并进行输出
        int[] arr3 = {10, 20, 30, 40, 50, 60, 70, 80, 90};
        System.out.println("当前的数组顺序为:");
        System.out.println(Arrays.toString(arr3));
        //需要互换的次数
        for (int i = 0; i < arr3.length / 2; i++) {
            //进行数组互换
            int sum = 0;
            sum = arr3[i];
            //将高位项给低位项
            arr3[i] = arr3[arr3.length - 1 - i];
            //将低位项给高位项
            arr3[arr3.length - 1 - i] = sum;
        }
        //输出交换顺序后的数组
        System.out.println("交换顺序后的数组为:");
        System.out.println(Arrays.toString(arr3));
    }
}

                1.4.4、折半查找（二分查找法）【前提数组要正序排序】

                                --先从数组中间开始找，如果查找的数>中间值，则在后面找；如果查找的数<中间值，则在前面面找

                                --如果第一次找不到，则二分从后面（前面）的中间继续找，直到起始位置>结束位置就退出循环

import java.util.Arrays;
import java.util.Scanner;
public class CommonBinarySearch {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,2,3,4,6,7,8,9,10};
        System.out.println(Arrays.toString(arr));
        //输入要查询的数
        Scanner input = new Scanner(System.in);
        System.out.print("请输入要查询的数:");
        int key = input.nextInt();
        //定义低位
        int low = 0;
        //定义高位
        int high = arr.length-1;
        //定义中间值
        int middle = 0;
        if(low>high||key<low||key>high){
            System.out.println("输入有误");
        }
        //设置标志位
        boolean isFind = false;
        while (low<=high){
            //给中间值赋值
            middle = (low+high)/2;
            //判断中间值>查询值
            if (arr[middle] > key) {
                high = middle - 1;
            }
            //中间值<查询值
            else if (arr[middle] < key) {
                low = middle + 1;
            }
            //查询值=中间值
            else {
                System.out.println("你要查询的"+key+"：在第"+middle+"位");
                isFind = true;
                break;
            }
        }
        if (isFind==false){
            System.out.println("未找到");
        }
    }
}

1.5、数组工具类的使用

        1.5.1、排序（升序）

Arrays.sort(array);//array为要排序的数组

        1.5.2、复制（copyof）

Arrays.copyof(arr,3);//(数组名,复制数（复制多少）)
Arrays.copyofRange(arr,3,5);//(数组名,复制数起始位置(包括),复制终止位置(不包括))

        1.5.3、查找（二分查找法【必须要升序排序】）找不到返回负数    

Arrays.binarySearch(array,165);//(数组名,查询数)
Arrays.binarySearch(array,1,6,5);//(数组名,查询起始位置（包括），查询终止位置（不包括 ），查询数);

        1.5.4、填充（fill）

Arrays.fill(array,165);//(数组名,填充数)
Arrays.fill(array,1,6,5);//(数组名,填充起始位置（包括），填充终止位置（不包括 ）填充数)

        1.5.5、equals（比较数组是否相等 ）

System.out.println(Arrays.equals(arr,array));//要求长度相等 ，位置相同才true

        1.5.6、toString（转换为字符串）

System.out.println(Arrays.toString(array));