一维数组Array

数组参考文档：https://www.cnblogs.com/yinzhengjie/p/8719728.html

数组内存储的都是相同的数据类型

数组的基础内容

1. 数组的动态、静态初始化 

   静态的数组初始化—》在数组定义时，就赋予了初始值

2. 数组的默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，其中的每个元素也按照成员变量的规则被隐式初始化

3. 数组的元素遍历

数组常见异常

数组越界

import java.util.Arrays;

public class ArrayTest {
    public static void main(String[] args) {
//        静态初始化
        int [] arr1 = {1,2,3,4};
//        动态初始化
        int [] arr2 =  new int[10];


        for (int i =0;i<10;i++){
            arr2[i]= i ;
        }
        for (int i =0;i<arr2.length;i++){
            System.out.println(arr2[i]);
        }

        int[][] arr4={{3,5},{6,7},{8,9}};
        //查找数组中的字符串
        int a= Arrays.binarySearch(arr4[0],3);
        int b =Arrays.binarySearch(arr1,7);
        int c =Arrays.binarySearch(arr1,34);
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //比较两个数组是否相等
        int[] arr3= new int[]{3,3,3,5,9};
        int[] arr5= new int[]{3,3,3,5,9};
        Boolean aaa = Arrays.equals(arr5,arr3);
        System.out.println(aaa);

        //插入填充数组元素
        int[] arr6= new int[]{1,3,6,5,9};
        int[] arr8= new int[]{1,3,6,5,9};
        int[] arr7= new int[]{122,333,433,35,229};
        //      最后arr6全是20
        Arrays.fill(arr6,20);
        for (int i =0;i<arr6.length;i++){
            System.out.println(arr6[i]);
        }
        //将arr7的第3到5位全部填充为29
        Arrays.fill(arr7,3,5,29);
        for (int i =0;i<arr7.length;i++){
            System.out.println(arr7[i]);
        }

        //数组拷贝-数组越界：arr7共5个元素，下标值：0~4，从下标3开始copy只可以再复制2个元素，所以length=4会造成，放到到了数据中不存在的索引，导致数组越界
//        System.arraycopy(arr6,1,arr7,3,4);
//        length：从1到2都可以
        System.arraycopy(arr6,1,arr7,3,2);
        for (int i =0;i<arr7.length;i++){
            System.out.print(arr7[i]+",");
        }
//        也会数组越界
        System.out.println(arr7[20]);
   }
}

数组的默认值

public class ArrayDefault {
    public static void main(String[] args) {
        int [] arr2 = new int[8];
//        引用数据类型数组
        String [] arr1 = new String[8];

        System.out.println(arr2[4]);
        // 引用数据类型数组的默认值是null
        System.out.println(arr1[4]);
    }
}

Arrays类的常用方法

toString

sort

binarySearch 查找数组中的字符串

asList

equals 比较两个数组是否相等

插入填充数组元素

import javax.xml.bind.SchemaOutputResolver;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//Arrays类包含用来操作数组的各种方法
//主要有以下几种 静态 方法（针对一维数组）
//toString
//sort
//binarySearch 只针对有序数组
//asList


public class ArraysClassTest {

        public static void main(String[] args) {

                int[] arrInt = {55,44,33,22,11};
                String[] as = {"1", "2", "3"};
                //toString,public static String toString(Array[] array)参数为数组
                //将数组按照默认格式输出为字符串
                System.out.println(Arrays.toString(arrInt));

                Arrays.sort(arrInt);
                System.out.println(Arrays.toString(arrInt));

                //binarySearch只可针对有序数组进行查找
                int a = Arrays.binarySearch(arrInt,33);
                System.out.println(a);

                //asList,将数组转化为list进行返回
//                注意：集合类Collection只能用来存储引用数据类型！所以List<int> 会报错
//                List<int> li = Arrays.asList(arrInt);

                List<String> sli= Arrays.asList(as);
                List<String> sl2 = new ArrayList<String>(Arrays.asList(as));
                sli.add("test");
                System.out.println(sli);
        }

}

数组的应用-冒泡排序

import java.util.Arrays;

public class BubbleSortTest {

    static int[] Bubble(int [] arr){
        for (int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){

                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        int[] ars= new int[]{2,64,3,6,43,2,3,100};
//        Bubble(ars);
        Arrays.sort(ars);
        for (int i=0;i<ars.length;i++){
        System.out.println(ars[i]);}
    }
}