【Java开发指南 | 第十六篇】Java数组及Arrays类

简介: 【Java开发指南 | 第十六篇】Java数组及Arrays类

数组

Java中的数组是一种用来存储固定大小的相同类型元素的数据结构。


数组特点

数组具有以下特点:

1、固定大小: 一旦数组被创建,其大小就不能被改变。


2、相同类型元素: 数组中的所有元素必须是相同的数据类型,可以是基本数据类型(如int、double等)或者是引用数据类型(如对象)。


3、连续内存空间: 数组中的元素在内存中是连续存储的。


4、零索引: 数组的元素是通过索引访问的。数组的索引从零开始,即第一个元素的索引是0,第二个元素的索引是1,以此类推到 arrayRefVar.length-1。


创建数组



dataType[] arrayRefVar;   //声明数组的类型和名称


//char[] myArray;


不能按这种方法创建声明数组:char[10] arr;



2、


dataType arrayRefVar[];

//声明数组的类型和名称
//可以指定其大小
//int[] myArray = new int[5];
public class ice {
    public static void main(String[] args) {
       int arr[] = new int[5];
       for(int i=0;i
        {
            System.out.println(i*2);
        }
    }
}


3、

dataType[] arrayRefVar = {value0, value1, ..., valuek};


//char[] myArrar={'a','b','c','d'}
例如:
public class ice {
    public static void main(String[] args) {
       int[] arr = {'1','2','3','a'};
    }
}


处理数组

数组的元素类型和数组的大小都是确定的,所以当处理数组元素时候,我们通常使用基本循环或者 For-Each 循环。


public class ice {
    public static void main(String[] args) {
       int arr[] = new int[5];
       
        for(int i=0;i
        {
            arr[i]=i*2;
        }//循环进行赋值
       for(int i=0;i
        {
            System.out.println(arr[i]);
        }//循环进行打印
    }
}



多维数组

type[][] typeName = new type[typeLength1][typeLength2];


创建一个两行三列的二维数组 a :


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


访问二维数组中第二行第一列的元素:


int t=a[1][0];


Arrays类

java.util.Arrays 类能方便地操作数组,它提供的所有方法都是静态的。


排序(Sorting):


sort(T[] a): 对指定数组进行排序,使用默认的比较器。

import java.util.Arrays;
public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        Arrays.sort(arr);
        for(int i=0;i
        {
            System.out.println(arr[i]);
        }
    }
}



sort(T[] a, Comparator c): 对指定数组根据指定比较器进行排序。

parallelSort(T[] a): 对指定数组进行并行排序,使用默认的比较器。

parallelSort(T[] a, Comparator c): 对指定数组进行并行排序,使用指定的比较器。

搜索(Searching):


binarySearch(T[] a, T key): 在指定数组中搜索指定的元素,返回元素的索引。数组必须是有序的。

import java.util.Arrays;


public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        Arrays.sort(arr);
        int t=Arrays.binarySearch(arr,543);
        System.out.println(t);
    }
}


binarySearch(T[] a, int fromIndex, int toIndex, T key): 在指定范围内的数组中搜索指定的元素,返回元素的索引。数组必须是有序的。

比较(Comparing):

equals(T[] a, T[] a2): 比较两个数组是否相等。

deepEquals(Object[] a1, Object[] a2): 深度比较两个数组是否相等。

填充(Filling):


fill(T[] a, T val): 将指定数组的所有元素替换为指定值。

fill(T[] a, int fromIndex, int toIndex, T val): 将指定范围内的数组元素替换为指定值。

转换为列表(Converting to List):


asList(T... a): 将指定数组转换为 List。
import java.util.Arrays;
import java.util.List;
public class ice {
    public static void main(String[] args) {
        Integer[] arr = {1,12,543,235,2,13,122,43}; // 使用 Integer 类型的数组
        List a = Arrays.asList(arr);
        System.out.println(a);
    }
}


注意:列表不能直接复制给数组,因为基本数据类型不能作为泛型的参数。


/*无法输出正确列表*/
import java.util.Arrays;
import java.util.List;
public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        List a = Arrays.asList(arr);
        System.out.println(a);
    }
}



数组的输出(Array Output):


toString(T[] a): 返回数组的字符串表示形式。
import java.util.Arrays;
public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        String a = Arrays.toString(arr);
        System.out.println(a);
    }
}



数组的复制(Array Copying):

copyOf(T[] original, int newLength): 将指定数组的前几个元素复制到一个新数组中,新数组的长度为指定长度。
import java.util.Arrays;
import java.util.List;
public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        int[] brr=Arrays.copyOf(arr,3);
        System.out.println(Arrays.toString(brr));
    }
}



copyOfRange(T[] original, int from, int to): 将指定数组的指定范围的元素复制到一个新数组中。
import java.util.Arrays;
import java.util.List;
public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        int[] brr=Arrays.copyOfRange(arr,3,6);
        System.out.println(Arrays.toString(brr));
    }
}


数组的填充(Array Padding):


copyOfRange(T[] original, int from, int to): 将指定数组的指定范围的元素复制到一个新数组中,并使用指定值填充不足的部分。



目录
相关文章
|
2天前
|
设计模式 安全 Java
Java中的单例模式是一种设计模式,它保证一个类只有一个实例,并提供一个全局访问点
Java单例模式确保类仅有一个实例,并提供全局访问点。常见实现包括: - 饿汉式:静态初始化,线程安全。 - 懒汉式:延迟初始化,需同步保证线程安全。 - 双重检查锁定:优化懒汉式,减少同步开销。 - 静态内部类:延迟加载,线程安全。 - 枚举:简洁线程安全,不适用于复杂构造。 - 容器实现:如Spring框架,用于依赖注入。选择依据需求,如延迟加载、线程安全和扩展性。
32 10
|
2天前
|
存储 Java 关系型数据库
基于Servlet和JSP的Java Web应用开发指南
【6月更文挑战第23天】构建Java Web应用,Servlet与JSP携手打造在线图书管理系统,涵盖需求分析、设计、编码到测试。通过实例展示了Servlet如何处理用户登录(如`LoginServlet`),JSP负责页面展示(如`login.jsp`和`bookList.jsp`)。应用基于MySQL数据库,包含用户和图书表。登录失败显示错误信息,成功后展示图书列表。部署到Tomcat服务器测试功能。此基础教程为深入Java Web开发奠定了基础。
|
1天前
|
Java
2016届蓝桥杯大赛软件类国赛Java大学B组 愤怒小鸟 数学模拟
2016届蓝桥杯大赛软件类国赛Java大学B组 愤怒小鸟 数学模拟
16 4
|
1天前
|
Java
2022蓝桥杯大赛软件类国赛Java大学B组 左移右移 空间换时间+双指针
2022蓝桥杯大赛软件类国赛Java大学B组 左移右移 空间换时间+双指针
13 3
|
1天前
|
Java
2021蓝桥杯大赛软件类国赛Java大学B组 完全日期 复杂遍历搜索
2021蓝桥杯大赛软件类国赛Java大学B组 完全日期 复杂遍历搜索
9 2
|
1天前
|
Java
Java中,有两种主要的方式来创建和管理线程:`Thread`类和`Runnable`接口。
【6月更文挑战第24天】Java创建线程有两种方式:`Thread`类和`Runnable`接口。`Thread`直接继承受限于单继承,适合简单情况;`Runnable`实现接口可多继承,利于资源共享和任务复用。推荐使用`Runnable`以提高灵活性。启动线程需调用`start()`,`Thread`直接启动,`Runnable`需通过`Thread`实例启动。根据项目需求选择适当方式。
9 2
|
3天前
|
Java 编译器 API
Java数组(如果想知道Java中有关数组的知识点,那么只看这一篇就足够了!)
Java数组(如果想知道Java中有关数组的知识点,那么只看这一篇就足够了!)
|
1天前
|
Java
2023届蓝桥杯大赛软件类国赛Java大学B组 互质 数论
2023届蓝桥杯大赛软件类国赛Java大学B组 互质 数论
4 1
|
1天前
|
Java
2023蓝桥杯大赛软件类省赛Java大学B组G题 买二增一 队列的简单应用
2023蓝桥杯大赛软件类省赛Java大学B组G题 买二增一 队列的简单应用
7 1
|
2天前
|
设计模式 安全 Java
Java单例模式确保类仅有一个实例,提供全局访问点。常见实现包括
【6月更文挑战第23天】Java单例模式确保类仅有一个实例,提供全局访问点。常见实现包括: 1. 饿汉式:静态初始化时创建实例,线程安全。 2. 懒汉式:首次请求时创建,需同步保障线程安全。 3. 双重检查锁定:优化懒汉式,减少同步开销。 4. 静态内部类:延迟加载,线程安全。 5. 枚举:简洁线程安全,但构造受限。 6. 容器实现:如Spring框架,适用于依赖注入。选择依据需求如延迟加载、线程安全等。
10 1