Java_数组&&java.util.Arrays

想做CTO的任同学...

已于 2023-10-09 11:13:58 修改

阅读量3.1k

点赞数 3

分类专栏： Java 文章标签： java 开发语言

于 2020-05-19 15:33:38 首次发布

本文链接：https://blog.csdn.net/qq_43408367/article/details/106215181

版权

Java 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

文章目录

Java_数组
Java_数组的常见实例

Java_数组

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
在Java这种,数组是用来存储固定大小的同类型元素
Java中数组可以分为两类:
第一类按照维度：一维数组、二维数组、三维数组、…
第二类按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

Java_一维数组的基本概念

当需要在Java程序中记录单个数据内容时，则声明一个变量即可。
当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维数组即可，一维数组本质上就是在内存空间中申请一段连续的存储单元。
数组是相同数据类型的多个元素的容器，元素按线性顺序排列，在Java语言中体现为一种引用数据类型。
数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址，并且数组的长度一旦确定，就不能修改。
可以通过下标的方式访问数组中的每一个元素。需要注意的是：数组的下标从0开始，对于长度为n的数组，下标的范围是0~n-1。
基本类型的数组（数据元素为基本类型）创建后，其元素的初始值如下：

基本类型默认值
byte、short、char、int、long 0
float和double 0.0
boolean false

基本类型	默认值
byte、short、char、int、long	0
float和double	0.0
boolean	false

数组的动态初始化，在定义数组的同时就为数组元素分配空间，数组一旦初始化，其长度是不可变的

语法格式：数据类型[] 数组名称 = new 数据类型[数组的长度];
int [] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
调用：length属性可以获取数组的长度
String names[];
names = new String[3];
// 在定义并用运算符new为数据分配空间后，才可以引用数组中的每个元素；
names[0] = "钱学森";
names[1] = "邓稼先";
names[2] = "袁隆平";

数组的动态初始化
int [] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

String names[];
names = new String[3];
names[0] = "钱学森";
names[1] = "邓稼先";
names[2] = "袁隆平";

静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

int arr1[] = new int[]{ 3, 9, 8};
int[] arr2= {3,9,8};
String names1[] = {"张三","李四","华罗庚"};
// 数组元素的引用方式：`数组名[数组元素下标]`
// names1[1] = "张三";

Java_内存结构

内存结构之栈区：栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开始到结束会有多次变量的声明
内存结构之堆区：JVM会在其内存空间中开辟一个称为“堆”的存储空间，这部分空间用于存储使用new关键字创建的数组和对象。

Java_一维数组样例

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

Java_数组的优缺点

优点：

可以直接通过下标(或索引)的方式访问指定位置的元素，速度很快。

缺点：

数组初始化以后，长度就不可变了，不便于扩展
数组要求内存空间连续，并且长度一旦确定就不能修改。
数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。同时无法直接获取存储元素的个数
数组存储的数据是有序的、可以重复的。---->存储数据的特点单一

数组作为函数的参数

package com.company;
// 数组作为函数的参数传递给方法
// 遍历数组成员
public class Java_07 {
    public static void main(String[] args) {
        printArray(new int[]{3, 1, 2, 6, 4, 2});
    }
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int temp = i+1;
            System.out.println("第"+temp +"个成员"+array[i] + " ");
        }
    }
}

Java_Arrays工具类

java.util.Arrays类即为操作数组的工具类，可以实现对数组中元素的遍历、查找、排序等操作。

常用方法	描述
static String toString(int[] a)	输出数组中的内容
static void fill(int[] a, int val)	将参数指定元素赋值给数组中所有元素
static boolean equals(boolean[] a, boolean[] a2)	判断两个数组元素内容和次序是否相同
static void sort(int[] a)	对数组中的元素进行从小到大排序
static int binarySearch(int[] a, int key)	从数组中查找参数指定元素所在的位置(二分法检索指定的值)

Java_二维数组

二维数组本质上就是由多个一维数组摞在一起组成的数组，二维数组中的每个元素都是一维数组，而一维数组中的每个元素才是数据内容。
多维数组就是看作数组的数组,比如二维数组就是一个特殊的一维数组,二维数组的每一个元素都是一个一维数组
创建一个二维数组str,str是一个三行四列的数组,从最高维开始为每一维分配空间

// 数据类型[][] 数组名称 = new 数据类型[行数][列数]; 
String [][] str = new String[2][3];
str[0][0] = new String("Good");
str[0][1] = new String("Luck");
str[1][0] = new String("to");
str[1][1] = new String("you");
str[1][2] = new String("!");

//数据类型[][] 数组名称 = {{元素1, 元素2，...}, ...};
String [][] str = {{"Good","Good"},{"Luck","Luck"}}

JAVA_数组使用中常见的异常

数组下标越界异常(ArrayIndexOutOfBoundsException):发生情况

	int[] arr = new int[2];
	System.out.println(arr[2]);
	System.out.println(arr[-1]);
	// 访问到了数组中的不存在的脚标时发生。

空指针异常(NullPointerException)

	int[] arr = null;
	System.out.println(arr[0]);
	arr引用没有指向实体，却在操作实体中的元素时。

Java_System.arraycopy实现数组扩容

Java数组对象的大小是固定不变的,即数组对象是不可扩容的,但是利用数组复制的方法可以变通的实现数组扩容
System.arraycopy()可以复制数组,简单实现数组扩容

package com.company;

import java.util.Arrays;

// 数组扩容
public class Java_09 {
    public static void main(String[] args) {
        String[] name = new String[] { "A", "B", "C" };
        String[] nameK = new String[5];
        nameK[3] = "D";
        nameK[4] = "E";
        // 使用 System.arraycopy 变通的实现数组扩容 复制数组
        System.arraycopy(name, 0, nameK, 0, name.length);
        for (String str : nameK){
            System.out.println("扩容后");
            System.out.println(str);
        }

     
    }
}

Java_Arrays.copyOf()实现数组扩容

使用Arrays.copyOf()将一个数组的值完整覆盖给另一个数组,再设置新的数组大小来是新数组扩容

package com.company;

import java.util.Arrays;
// 使用 Arrays.copyOf实现数组扩容
public class Java_10 {
    public static void main(String[] args) {
        int a[] = {4, 3, 6, 5, 1, 2};
        int b[] = Arrays.copyOf(a, 4);
        int c[] = Arrays.copyOfRange(a, 2, 4 + 1);

        for (int i = 0; i < b.length; i++)
            System.out.print(b[i] + " ");
            System.out.println();

        for (int i = 0; i < c.length; i++)
            System.out.print(c[i] + " ");
            System.out.println();

// Arrays.copyOf的两种方式
//        Arrays.copyOf(array, to_index);
//        Arrays.fill(array, from_index, to_index);
    }
}

Java_数组的常见实例

Java_冒泡排序

package com.company;

import java.util.Arrays;

// 数组的冒泡排序
public class Java_11 {
    public static void main(String[] args) {
        int [] a = {1,3,5,1,5,1,5,54,1,484,1,8,848,5,};
        mySort(a);
    }



    // 数组的冒泡排序
    // 1. 比较数组中,两个相邻元素,如果第一个数比第二个数大,那么交换他们的顺序
    // 2. 每一次比较，都会产生出一个最大，或者最小的数字；
    // 3.下一轮则可以少一次排序！
    // 4.依次循环，直到结束！

    public static void  mySort(int[] arr){
        int num;
        int count = 0;
        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]){
                    num = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = num;
                    count = count +1 ;
                }
            }
            if(count == 0){
                break;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

Java_选择法排序

package com.company;

import java.util.Arrays;

// 选择法排序
public class Java_12 {
    public static void main(String[] args) {
        int arr[]= {23,12,48,56,45};
        for(int i=0;i<arr.length;i++) {
            int tem=i;
            //将数组中从i开始的最小的元素所在位置的索引赋值给tem
            for(int j=i;j<arr.length;j++) {
                if(arr[j]<arr[tem]) {
                    tem=j;
                }
            }
            //上面获取了数组中从i开始的最小值的位置索引为tem，利用该索引将第i位上的元素与其进行交换
            int temp1=arr[i];
            arr[i]=arr[tem];
            arr[tem]=temp1;
        }
        System.out.println(Arrays.toString(arr));
    }

}

Java_直接插入法排序

package com.company;

import java.util.Arrays;

// 直接插入排序 将数组中最大的值放置在最后面
public class Java_14 {
    public static void main(String[] args) {

        int []arr={23,12,48,56,45};
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j - 1] > arr[j]) {//大的放后面
                    int tmp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

Java_使用工具类对数组排序

java.util.Arrays类的sort()方法提供了数组元素排序功能：

import java.util.Arrays;
public class SortTest {
	public static void main(String[] args) {
		int [] numbers = {5,900,1,5,77,30,64,700};
		Arrays.sort(numbers);
		for(int i = 0; i < numbers.length; i++){
			System.out.println(numbers[i]);
		}
	}
}

Java_数组作为函数的参数

数组可以作为参数传递给方法

package com.company;
// 数组作为函数的参数传递给方法
// 遍历数组成员
public class Java_07 {
    public static void main(String[] args) {
        printArray(new int[]{3, 1, 2, 6, 4, 2});
    }
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int temp = i+1;
            System.out.println("第"+temp +"个成员"+array[i] + " ");
        }
    }
}

想做CTO的任同学...

关注

3
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
Java_数组&&java.util.Arrays

当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维数组即可，一维数组本质上就是在内存空间中申请一段连续的存储单元。可以通过下标的方式访问数组中的每一个元素。需要注意的是：数组的下标从0开始，对于长度为n的数组，下标的范围是0~n-1。数组的动态初始化，在定义数组的同时就为数组元素分配空间，数组一旦初始化，其长度是不可变的。数组是相同数据类型的多个元素的容器，元素按线性顺序排列，静态初始化：在定义数组的同时就为数组元素分配空间并赋值。数组为引用数据类型。
复制链接

扫一扫