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]

类型分配的默认值
整型(byteshortintlong0
浮点型(floatdouble0.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索引的元素

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页