流年似水博客开通了,本站主要是写关于Web和大数据方面内容,正在更新中,欢迎大家光临!
  1. 文章:97 篇
  2. 总浏览:68,792 次
  3. 评论:22条
  4. 最后更新:2020-06-08
  5. 分类目录:39 个

Java之数组详解

Java l, xy 294℃ 0评论
文章目录[隐藏]

数组

  1. 数组的概念:

(1)    保存相同类型一组元素的集合(容器)

  1. 数组入门

(1)    语法:

1           声明时已知要存储的值(静态初始化)

  1. 数据类型[] 数组名 = new 数据类型[长度];

 

2           声明时不知要存储的值(动态初始化)

 

  1. 数据类型[] 数组名 = new 数据类型[]{1,值2...}
  2. 数据类型[] 数组名 = {1,值2...};

例如:

//数据类型和[] 之间可以有空格,包括赋值号左右两侧

Int [] ints = new int[3];
int arr[] = new int[]{12,2,5,6};
int[] array = {2,2,3,4};

 

注意:

语法中赋值号左边的中括号也可以在数组名的后面

数据类型 数组名[] = new 数据类型[长度];

例如: int ints[] = new int[3];

//数组名和中括号之间有空格也可以,,包括赋值号左右两侧

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

 

(2)    使用:

1           回顾:基本数据类型使用:

1)       基本类型三要素

  1. 数据类型
  2. 变量名
  3. 变量值

2)       基本类型使用:(声明、赋值可以合在一起)

  1. 声明
  2. 赋值
  3. 使用数组的使用:

3)       数组的四要素

  1. 数据类型
  2. 变量名(对象名、引用、数组名)
  3. 元素
  4. 下表

4)       引用类型使用:

  1. 声明 (在java虚拟机中分配空间、不会再堆内存中分配空间)
  2. 赋值(在堆内存中分配空间,并将引用保存在中变量中)
  3. 使用

2           数组的初始化:

1)       动态初始化:

  1. 使用场景:不知道数组内存放的值的时候
  2. 案例:

int[ints = new int[4];

Ints[0] = 42;

.....

2)       静态初始化:

  1. 使用场景:已知数组内存放的具体值
  2. 案例:

a)       方式

  1. 案例:

Double[] doubles = new double[]{12.5,16,1,2};

  1. 注意事项:

i)       赋值号右边的[]内不能写数组的大小,因为编译器可以通过大括号自动推断

ii)    大括号内的值必须是只能声明类型、或者能够自动转换为声明类型


iv)    大括号内的值之间使用逗号(,)分割,不可省略

b)       方式二:

  1. 案例

Double[] doubles = {12.5,16,1,2};

  1. 注意事项:

i)       同方式注意事项的(iiIV

ii)    不能将声明赋值分开,因为此时不能进行长度推断

int[] ints;
//编译出错
ints = {1,2,3};

 

 

(3)    默认值:

Byte

0

Short

0

Int

0

Long

0

Float

0.0

Double

0.0

Char

\u0000 相当于Unicode码值为0的值

Boolean

false

引用类型

null

 

(4)    注意事项:

  1. 使用数组的好处:

(1)    代码简洁:减少定义多个相同类型的变量,避免多次在中开辟空间。因为一次可以开辟多个连续空间,存储多个相同类型元素。效率高

(2)    分类存储:空间连续,方便查找。

  1. 数组的特点:

(1)    不能扩容,数组一旦定义长度就已经固定。(也是缺点)

(2)    保存相同数据类型的数据

(3)    新增、查找效率高;插入、删除效率低

(4)    引用类型,数组类型是对象(Object),数组中每个元素相当于该对象的成员变量

  1. 数组的基本使用

(1)    正序遍历

int[] ints = {15863};
//正序遍历
for (int i = 0i < ints.lengthi++) {
    System.out.println(ints[i]);    }
}

 

 

(2)    逆序遍历

int[ints = {15863};

//逆序遍历
for (int i = ints.length 1i <= 0i--) {
    System.out.println(ints[i]);
}

 

(3)    求最值

/**
@param ints
@return Integer   如果ints长度为0,返回null,否则返回数组中的最大值
@throws NullPointerException 如果intsnull
*/
public static Integer getMax(int[] ints) {
    Objects.requireNonNull(ints);
    if (ints.length == 0) {
        return null;
    }
    int max = ints[0];
    for (int i = 1i < ints.lengthi++) {
        if (max < ints[i]) {
            max = ints[i];
        }
    }
    return max;
}

 

(4)    求和、平均值

/**
*  求和、平均值
* */
public static double sum(int[] ints){
    double sum = ;
    for (int i = 0i < ints.lengthi++){
        sum += ints[i];
    }
    System.out.println("平均值:"+ (sum / ints.length));
    return sum;
}

 

(5)    查找

1           线性查找

1)       特点:按个遍历

2)       时间复杂度为  n

3)       代码:

/**
在数组array查找是否包含element
*
@param array
@param element
@return int  包含返回其下表,否则返回f -1
@throws NullPointerException 如果arraynull
*/
public static <Tint search1(T[] arrayelement) {
    Objects.requireNonNull(array);
    int index = -1;
    t;
    for (int i = 0i < array.lengthi++) {
        if ((t = array[i]) != null && t.equals(element)) {
            index = i;
        }
    }
    return index;
}

 

2           二分查找

1)       前提:有序集合

2)       代码:

  1. 非递归实现

/**
二分查找
*
@param ints   数组
@param search 关键字
@return  boolean               
*/
public static boolean binarySearch(int[] intsint search) {
    int low = 0;
    int hight = ints.length ;
    while (hight >= low) {
        int mid = (low + hight) / 2;
        if (ints[mid] == search) {
            return true;
        else if (ints[mid] > search) {
            hight = mid - 1;
        else {
            low = mid + 1;
        }
    }
    return false;
}

 

  1. 递归实现

/**
二分查找
*
@param ints   数组
@param search 关键字
@param low    
@param high   
@return boolean
*/
public static boolean binarySearchDiGui(int[] intsint searchint lowint high) {
    if (high >= low) {
        int mid = (low + high) / 2;
        if (ints[mid] == search) {
            return true;
        else if (ints[mid] > search) {
            high = mid - 1;
            return binarySearchDiGui(intssearchlowhigh);
        else {
            low = mid + 1;
            return binarySearchDiGui(intssearchlowhigh);
        }
    } else {
        return false;
    }

}

 


(6)    排序

1           冒泡排序

1)       思想

相邻元素相比较,每一次循环就会有一个元素在正确的位置上

2)       特点:

  1. 时间复杂度:O(n^2)
  2. 是否稳定:稳定

       3)   代码



/**
* 冒泡排序
*
* @param ints int类型数组
* @throws NullPointerException 如果<code>ints</code>为null时
*/
public static void bubbleSort(int[] ints) {
for (int i = 0; i < ints.length - 1; i++) {
//标志是否已经排序完成
boolean flag = true;
for (int j = 0; j < ints.length - 1 - i; j++) {
if (ints[j] > ints[j + 1]) {
int temp = ints[j];
ints[j] = ints[j + 1];
ints[j + 1] = temp;
flag = false;
}
}
if (flag) {
break;
}
}
}

 

2           选择排序

1)       思想:每次都使用一个元素跟所有元素比较

2)       代码:

/**
选择排序
*
@param ints
*/
public static void chooseSort(int[] ints) {
    for (int i = 0i < ints.lengthi++) {
        for (int j = i + 1j < ints.lengthj++) {
            if (ints[i] > ints[j]) {
                int temp = ints[i];
                ints[i] = ints[j];
                ints[j] = temp;
            }
        }
    }
}

 

3           插入排序

1)       思想:假设第一个有序,依次将后面元素添加到有序列表中,使得有序列表依然保存有序

2)       代码:

/**
插入排序
*
@param ints
*/
public static void insertSort(int[] ints) {
    for (int i = 1i < ints.lengthi++) {
        int key = ints[i]index = i;
        //找到插入位置
        for (int j = i - 1j >= 0j--) {
            if (key < ints[j]) {
                index = j;
                continue;
            }
            break;
        }
        //位置发现改变
        if (index != i) {
            //移动位置
            for (int x = i> indexx--) {
                ints[x] = ints[x - 1];
            }
            //插入到有序列表中
            ints[index] = key;
        }
    }
}

3)        

  1. 数组的中级使用

(1)    数组复制

1           思想:重新创建一个与原数组等长的新数组,并将值进行拷贝

2           注意:

1)       当数组内存放的时引用类型时,下面代码可用

3           代码实现:

 

/**
*  数组拷贝
*  @param ints
*  @return 当源数组intsnull是返回null,否则返回源数组的拷贝
* */
public static int[] copyArray(int[] ints){
    if (ints == null){
        return null;
    }
    int[] arr = new int[ints.length];
    for (int i = 0i < ints.lengthi++){
        arr[i] = ints[i];
    }
    return arr;
}

 

(2)    数组翻转

1           思想:将数组中的首项和尾项交换,一次类推。

得出以下规律:

交换的次数 = 数组.length / 2;

首交换元素下标 +  位交换元素下标 = 数组.length - 1 ;

2           代码实现:

1)       实现

/**
数组翻转
*/
public static void 数组翻转1() {
    int[] ints = {1597164};
    //数组翻转
    for (int i = 0i < ints.length 2i++) {
        int temp = ints[i];
        ints[i] = ints[ints.length i];
        ints[ints.length i] = temp;
    }
    //打印
    for (int i = 0i < ints.lengthi++) {
        System.out.print(ints[i] + "\t");
    }
}

 

2)       实现二:




/**
* 数组翻转2
*/
public static void 数组翻转2() {
int[] ints = {1, 5, 9, 7, 1, 6, 4};

int minIndex = 0, maxIndex = ints.length - 1;

//翻转
for (int i = 0; i < ints.length - 1; i++) {
if (minIndex >= maxIndex) {
break;
}
int temp = ints[minIndex];
ints[minIndex] = ints[maxIndex];
ints[maxIndex] = temp;
minIndex++;
maxIndex--;
}
//打印
for (int i = 0; i < ints.length; i++) {
System.out.print(ints[i] + "\t");
}
}

 

3)       实现三:(这种是借助新数组来实现的)



/**
* 数组翻转3
* 思路:新创建一个与原数组长度相同的数组,逆向赋值,
*
* 缺点:
* 占用空间大
* 时间复杂度高
*/
public static void 数组翻转3() {
int[] ints = {1, 5, 9, 7, 1, 6, 4};

//创建新数组
int[] newArray = new int[ints.length];

//将源数组值拷贝到新数组
for (int i = 0; i < ints.length; i++){
newArray[i] = ints[i];
}
//逆序遍历新数组,将值赋值给源数组
for (int i = newArray.length - 1,j = 0 ; i >= 0; i--,j++){
ints[j] = newArray[i];
}
//打印
for (int i = 0; i < ints.length; i++) {
System.out.print(ints[i] + "\t");
}
}

 

 

  1. 数组的高级使用

(1)    添加/插入

1           添加:

1)       思路:使用每次添加前,先判断是否需要扩容,若需要则扩容,然后将源数组中的内容拷贝到新数组中,然后添加新元素到新数组的末尾

2           插入:

1)       思路

使用每次添加前,先判断是否需要扩容,若需要则扩容,然后将源数组中的内容拷贝到新数组中,新数组将要插入元素后元素后移,然后添加新元素到插入到新数组指定位置

2)       思路二:

使用每次添加前,先判断是否需要扩容,若需要则扩容,然后将源数组中的内容拷贝到新数组中,新数组将要插入元素后元素后移,然后添加新元素到插入到新数组指定位置

 

    1、创建新数组,长度=arr.length+1
    2、循环依次赋值
    3、将新元素插入到新数组的指定的位置或最后的位置
    4、将新数组的地址赋值给arr

  1. 二位数组的使用

(1)    声明

1           语法:

1)       数据类型[][] 数组名;

(2)    初始化

1           静态初始化

1)       数据类型[][] 数组名 = new 数据类型[][]{ {1,值2,..},{1,值2...},...};

2)       数据类型[][] 数组名 = { {1,值2,..},{1,值2...},...};

2           动态初始化

1)       数据类型[][] 数组名 = new 数据类型[][];

2)       数据类型[][] 数组名 = new 数据类型[][];

  1. 注意:这样写不会再内存中开辟二位数组中的一位数组,需要初始化

 

3           注意细节:

1)       在静态初始化1)中,赋值号右边的两个中括号内不能写行、列

2)       动态初始化中2)中,赋值号右边两个中括号中  可以省略

(3)    使用

1           静态:

1)        for(int i=0;i<arr.length;i++){
    for(int j=0;j<arr[i].length;j++){
      System.out.print(arr[i][j]);
    }
 }

2           动态:

1)       格式1:固定列数
    1、声明
    类型[][] ;
    
    2、开辟长度
     = new 类型[行数][列数];
    3、赋值
    for(int i=0;i<arr.length;i++){
    for(int j=0;j<arr[i].length;j++){
          arr[i][j] = ;
       }
    }
    
    4、使用

    for(int i=0;i<arr.length;i++){
       for(int j=0;j<arr[i].length;j++){
         System.out.print(arr[i][j]);
       }

    }

2)       

格式2:不固定列数
    
    1、声明
    类型[][] ;
    
    2开辟长度
     = new 类型[行数][];
    3、赋值
    for(int i=0;i<arr.length;i++){
      arr[i] = new 类型[长度];//长度一般需要找规律
       for(int j=0;j<arr[i].length;j++){
          arr[i][j] = ;
       }
    }
    
    4、使用

    for(int i=0;i<arr.length;i++){
       for(int j=0;j<arr[i].length;j++){
         System.out.print(arr[i][j]);
       }

    }

3           应用:

1)       杨辉三角



/**
* 杨辉三角形
* <p>
* 行
* 1 1
* 2 2
* 3 3
* <p>
* 列:
* 1
* 1 1
* 1 2 1
* 1 3 3 1
* 1 4 6 4 1
*/
public static void 杨辉三角形(int row) {

int[][] ints = new int[row][];
//赋值
for (int i = 0; i < ints.length; i++) {
//初始化一维数组
ints[i] = new int[i + 1];
for (int j = 0; j < i + 1; j++) {
if (j == 0 || j == i) {
ints[i][j] = 1;
} else {
ints[i][j] = ints[i - 1][j - 1] + ints[i - 1][j];
}
}

}
遍历二位数组(ints);}

 

 

转载请注明:流年似水 » Java之数组详解

喜欢 (0)or分享 (0)

Warning: copy(https://cn.gravatar.com/avatar/?s=54&d=%2Fwp-content%2Fthemes%2Fyusi1.0%2Fimg%2Fdefault.png&r=g): failed to open stream: HTTP request failed! HTTP/1.1 400 Bad Request in /usr/share/nginx/html/timewentby/wp-content/themes/yusi1.0/functions.php on line 239

Warning: copy(/wp-content/themes/yusi1.0/img/default.png): failed to open stream: No such file or directory in /usr/share/nginx/html/timewentby/wp-content/themes/yusi1.0/functions.php on line 243
发表我的评论
取消评论

表情

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址