zoukankan      html  css  js  c++  java
  • Java学习笔记-数组

    数组作为一种成熟的数据结构,在Java中也有着大量的运用

    数组的定义

    概念

    同一种类型数据的集合。其实数组就是一个容器
    数组的好处:可以自动给数组中的元素从0开始编号,方便操作这些元素
    数组也是一种类型,所有元素具有相同的类型
    数组一旦完成初始化其长度就固定了

    格式

    格式1:
    元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
    示例:int[] arr = new int[5];

    格式2:
    元素类型[] 数组名 = new 元素类型[]{元素,元素,···};
    示例:
    int[] arr = new int[]{3,5,1,7};
    int[] arr = {3, 5, 1, 7};

    type [] arrayName;
    type arrayName[];

    数组初始化:
    静态初始化:显式指定每个元素的初始化值,系统决定其长度
    arrayName = new type[]{element1,element2,element···}
    type[] arrayName = {element1,element2,element···}
    动态初始化:指定数组长度,系统分配初始化值
    arrayName = new type[lenght]

    类型 分配的默认值
    整型(byteshortintlong 0
    浮点型(floatdouble 0.0
    字符型 'u0000'
    布尔型 false
    引用类型 null

    数组长度:
    int i = arrayName.length;

    foreach循环,遍历数组和集合

    for ( type variableName : array | collection )
    {
    	//variableName自动迭代访问的每个元素
    }
    

    数组的内存分配及特点

    数组内存结构

    Java程序在运行时,需要在内存中的分配空间。为了提高运算效率,有对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式

    栈内存:

    • 用于存储局部变量,当数据使用完,所占空间会自动释放

    堆内存:

    • 数组和对象,通过new建立的实例都存放在堆内存中
    • 每一个实体都有内存地址值
    • 实体中的变量都有默认初始化值
    • 实体不在被使用,会在不确定的时间内被垃圾回收器回收

    方法区,本地方法区,寄存器

    数组操作常见问题

    数组脚标越界异常(ArrayIndexOutOfBoundsException)

    int[] arr = new int[2];
    System.out.println(arr[3]);
    

    访问到了数组中的不存在的脚标时发生

    空指针异常(NullPointerException)

    int[] arr = null;
    System.out.println(arr[0]);
    

    arr引用没有指向实体,却在操作实体中的元素时

    数组常见操作

    遍历

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

    获取最值(最大值,最小值)

    public int getMax(int[] arr){
        int max = arr[0];
        for(int x = 1; x < arr.length; x++){
            if(arr[x] > max)
                max = arr[x];
        }
        return max;
    }
    

    排序(选择排序,冒泡排序)

    选择排序:

    public void selectSort(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 void bubbleSort(int[] arr){
        for(int x = 0; x < arr.length - 1; x++){									
            for(int y = 0; y < arr.length - x - 1; y++)//-x:让每一次比较的元素减少,-1:避免角标越界。{
                if(arr[y] < arr[y + 1]){
                    int temp = arr[y];
                    arr[y] = arr[y + 1];
                    arr[y +  1] = temp;
                }
            }
        }
    }
    

    折半查找(二分查找)

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

    进制转换的java实现

    /* 十进制 -> 二进制 */
    public void toBin(int num){
        trans(num, 1, 1);
    }
    
    /* 十进制 -> 八进制 */
    public void toOct(int num){
        trans(num, 7, 3);
    }
    
    /* 十进制 -> 十六进制 */
    public void toHex(int num){
        trans(num, 15, 4);
    }
    
    public void trans(int num,int base,int offset){
        if(num == 0){
            System.out.println(0);
            return ;
        }
        char[] chs = {'0','1','2','3'
                    ,'4','5','6','7'
                    ,'8','9','A','B'
                    ,'C','D','E','F'};
    
        char[] arr = new char[32];
        int pos = arr.length;
    
        while(num != 0){
            int temp = num & base;
            arr[--pos] = chs[temp];
            num = num >>> offset;
        }
    
        for(int x = pos; x < arr.length; x++){
            System.out.print(arr[x]);
        }
    
        return ;
    }
    

    数组中的数组

    二维数组[][]
    格式1:

    int[][] arr = new int[3][2];
    

    定义了名称为arr的二维数组
    二维数组中有3个一维数组
    每一个一维数组中有2个元素
    一维数组的名称分别为arr[0], arr[1], arr[2]
    给第一个一维数组1脚标位赋值为78写法是:arr[0][1] = 78;

    格式2:

    int[][] arr = new int[3][];
    

    二维数组中有3个一维数组
    每个一维数组都是默认初始化值null
    可以对这个三个一维数组分别进行初始化

    arr[0] = new int[3];
    arr[1] = new int[1];
    arr[2] = new int[2];
    

    格式3:

    int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
    

    定义一个名称为arr的二维数组
    二维数组中的有三个一维数组
    每一个一维数组中具体元素也都已初始化
    第一个一维数组arr[0] = {3,8,2};
    第二个一维数组arr[1] = {2,7};
    第三个一维数组arr[2] = {9,0,1,6};
    第三个一维数组的长度表示方式:arr[2].length;

    获取arr数组中所有元素的和。使用for的嵌套循环即可

    注意特殊写法情况:int[] x,y[]; x是一维数组,y是二维数组

    type[][] arrayName;
    理解:type[]为一种类型。拓展出了Java原本没有的二维数组。其本质依旧是一维数组,数组元素为数组,也就是一种引用。
    arrayName = new type[length][];
    第一个长度必须指定,否则无法分配内存大小

    Arrays类的使用

    Arrays类位于java.util包下。
    static方法:
    int binarySearch ( type[] a , type key ):使用二分法查询key元素值在a数组中出现的索引

    int binarySearch ( type[] a , int fromIndex , int toIndex , type key ):搜索a数组中fromIndex到toIndex索引的元素

    type[] copyOf ( type[] original , int length ):将original数组复制成一个长度为的新数组。如果大于length则用默认初始化值填充,如果小于length则从length处截断

    type[] copyOfRange ( type[] original , int from , int to ):复制original数组从from到to的元素

    boolean qeuals ( type[] a , type a2 ):对比a和a2数组的长度和元素是否相同,相同则返回true

    void fill ( type[] a , type val ):将数组a中的所有元素赋值为val

    void fill ( type[] a , int fromIndex , int toIndex , type val ):将数组的fromIndex到toIndex索引的数组元素赋值为val

    void sort ( type[] a ):对数组a的元素进行排序

    void sort ( type[] a , int fromIndex , int toIndex ):对从fromIndex到toIndex索引的元素进行排序

    String toString ( type[] a ):将数组转化成一个字符串,将多个元素连缀在一起,用逗号和空格隔开

    工具方法(parallel利用CPU并行,xxx代表数据类型):
    void parallelPrefix ( xxx[] array , XxxBinaryOperator op ):使用op参数指定的计算公式计算得到的结果作为新元素。(op:left/right)

    void parallelPrefix ( xxx[] array , int fromIndex , int toIndex , XxxBinaryOperator op ):与上一个方法的区别在于仅重新计算fromIndex到toIndex索引元素

    void setAll ( xxx[] array , IntToXxxFunction generator ):使用指定生成器(generator)为所有数组元素设置值,该生成器控制数组元素的值的生成算法

    void parallelSetAll ( xxx[] array , IntToXxxFunction generator ):与上述方法相同,增加了并行能力,利用多CPU并行提高性能

    void parallelSort ( xxx[] a ):与sort()方法类似,增加了并行能力

    void parallelSort ( xxx[] a , int fromIndex , int toIndex):对从fromIndex到toIndex的元素进行排序

    Spliterator.OfXxx spliterator ( xxx[] array ):将该数组的所有元素转化成对应的Spliterator对象

    Spliterator.OfXxx spliterator ( xxx[] array , int startInclusive , int endExclusive):与上述方法类似,转换从startInclusive到endExclusive索引的元素

    XxxStream stream ( xxx[] array ):将数组转化成Stream(流式编程的API)

    XxxStream stream ( xxx[] array , int startInclusive , int endExclusive):与上述方法类似,转化从startInclusive到endExclusive索引的元素

  • 相关阅读:
    程序员面视题解析
    Forms身份验证
    梅花雨日历控件
    系统架构师学习笔记_第四章(下)
    系统架构师学习笔记_第三章
    系统架构师学习笔记_第六章(上)
    系统架构师学习笔记_第五章(下)
    系统架构师学习笔记_第一章
    系统架构师学习笔记_第四章(上)
    系统架构师学习笔记_第五章(上)
  • 原文地址:https://www.cnblogs.com/cj5785/p/10664869.html
Copyright © 2011-2022 走看看