Java SE：数组

最新推荐文章于 2022-07-21 09:53:59 发布
最新推荐文章于 2022-07-21 09:53:59 发布
阅读量380 收藏
点赞数
分类专栏： Java 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43660536/article/details/115449451
版权
这篇博客详细介绍了Java中一维数组的定义、创建、操作，包括声明、初始化、长度、遍历、比较、拷贝、查找等基本操作，并提供了具体的代码示例。此外，还提及了二维数组的声明和初始化方式以及遍历方法。内容深入浅出，适合初学者学习。
摘要由CSDN通过智能技术生成

Java SE：数组

目录

1.一维数组

1.1 定义

  • 相同数据类型数据的有序集合。
  • 存储多个数据，一段连续内存空间

1.2、基本特点

  1. 其长度是确定的。不可以改变的。

  2. 其元素必须是相同类型。

  3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

  4. 数组属引用数据类型，数组也可以看成是对象。

  5. 有序的 :数组中的每一个空间的序号,从0开始,每次+1–>索引|下标

2、创建数组

2.1 声明数组

  声明数组，就是在声明一个数组类型的变量，变量中并不存在任何的数据。

  • 数据类型[ ] 数组名; ----->建议
  • 数据类型 数组名[ ];
  • 数组中的每一个空间如果没有赋值,存在默认值,由数组的类型决定。
    引用数据类型:null 整数:0 小数:0.0 布尔:false 字符:’ '
type[] arr_name;（推荐使用这中方式） 
type arr_name[];

注意：

  • 声明的时候并没有实例化任何对象。
  • 声明一个数组的时候并没有数组被真正的创建。
  • 构造一个数组，必须指定长度。

2.2 构建数组

  • 动态初始化 : 先创建数组,然后再赋值
数据类型[] 数组名 = new 数据类型[数组的长度];
  • 数据类型: 可以为任意数据类型
  • 数组的长度 : 必须为整数,0或者以上的正整数
int[] a = new int[10];
  • 静态初始化 : 创建数组的同时赋值
数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
数据类型[] 数组名 = {数据1,数据2,数据3...};

type变量名[] = new type[]{元素列表}; 
int[] a = new int[]{1,2,3}; // 注意 [] 里边不能再指定长度了 
简写
int[] a1 = {12,3};

  可以省略为: type变量名[] ={元素列表}; 仅在声明和赋值时可以省略

2.3 .数组的长度length

  数组名.length --> 存储数据的个数(小空间的个数) 表示数组的长度。

//查看 数组长度
System.out.println(arr1.length);

2.4 数组界限（下标）

  • 下标的合法区间：[0, length-1]。从0开始,每次+1
  • 所有数组如果有数据,第一个数据空间下标为0
  • 数组的最后一个数据空间索引为: 数组的长度-1
			//声明数组同时赋值
        String[] arr1=new String[]{"haha","heiehi","hehe","ayyay"};
        char[] arr2 =new char[]{'a','c','d'};
        //先创建数组后赋值
        int[] arr3=new int[3];
        arr3[0]=1;
        arr3[1]=2;
        arr3[2]=3;

2.4 操作数组中的数据:

根据索引操作 数组名[ 索引 ]

//查看地址
System.out.println(arr1);
System.out.println(arr3);
System.out.println(arr4);
//查看数组值
System.out.println(arr1[0]);//打印当前下表的值
System.out.println(arr2[2]);
System.out.println(arr3[1]);
System.out.println(arr4[4]);
System.out.println(Arrays.toString(arr1));//全部打印数组值
//char数组输出为内容
System.out.println(arr2);

注意:

  • 数组的引用同一时刻只能指向一个地址

3、数组的基本操作

3.1 遍历

 获取数组中的所有数据

  • 普通for循环：循环条件i作为数组的索引,确定索引变化的范围

  • 增强for循环–foreach

 for(数据类型 变量名:数组名|容器名){
        变量名 : 存放数据中的每一个数据,不是索引,是数据
    }

foreach更简单,而for循环的遍历更强大

int[] a1=new int[]{1,2,3,4,5};
        String[] arr6 =new String[]{"ab","cd","ef","eh"};

        //for循环遍历
        for (int i = 0; i < a1.length; i++) {
            System.out.println(a1[i]);
        }
        //增强foreach遍历
        for (String s:arr6) {
            System.out.println(s);
        }
3.1.1 练习
/*
 * 数组练习1
 */
public class ArrayTest03 {
    public static void main(String[] args) {
        int[] i1=new int[]{1,2,3,4,5};
        char [] c1 =new char[]{'a','b','c','d','e'};

        ArrayTest03 a = new ArrayTest03();
        //遍历
        a.test1(i1);
        //遍历char数组
        a.test2(c1);
        //最大值，最小值
        a.test3(i1);
        int [] i2=getMaxMin(i1);
        //倒序遍历
        a.test04(i1);

    }

    //A:遍历int类型的数组 依次输出每个数组元素
    public  void test1(int[] ints){
        for (int i = 0; i < ints.length; i++) {
            System.out.print(ints[i]+"  ");
        }
    }

    //B:遍历字符数组
    public void test2(char[] chars){
        for (char s:chars) {
            System.out.print(s+"  ");
        }
    }
    //C:最值:获取数组中的最大值和最小值
    public void test3(int[] ii){
        int max=0;
        int min=0;
        for (int i:ii) {
            if (max<=i)
                max=i;
            if (min>=i)
                min=i;
        }
        System.out.println("最大值："+max);
        System.out.println("最小值："+min);
    }
    public static int[] getMaxMin(int[] arr){
        //存储数组中的最大值
        int max = arr[0];
        int min = arr[0];

        for(int i:arr){
            if(i>max){
                max = i;
            }
            if(i<min){
                min = i;
            }
        }
        return new int[]{min,max};
    }

    //D:逆序:倒叙输出数组元素
    public void test04(int[] ints){
        for (int i = ints.length-1; i >=0 ; i--) {
            System.out.print(ints[i]+"  ");
        }
    }


}

3.2 数组比较

  java.util.Arrays 类是 JDK 提供的一个工具类，用来处理数组的各种方法，而且每个方法基本上都是静态方法，能直接通过类名Arrays调用。

其中 equals( [ ] , [ ] ) 方法则是用来比较两个数组内容是否相同

  注意：使用 equals()方法，调用的是Object中的方法。比较的是两个地址值

//比较数组值是否相等
        int[] a= new int[]{1,2,3};
        int[] b= new int[]{1,2,3};
        int[] c= new int[]{1,2,3,4};
        System.out.println(Arrays.equals(a,b));//true
        System.out.println(Arrays.equals(a,c));//false

3.3 元素拷贝

  Arrays工具类中提供了一系列 public static Object[] copyOf(Object[] original, int newLength) 的方法，可以拷贝原数组中指定长度的元素到一个新的数组并返回。

//拷贝
Arrays.copyOf(想拷贝数组,长度);
//还可以指定起始位置和截止位置。
System.arraycopy(类型[] 数组名, 开始下标, 结束下标);

String[] s = {"Mircosoft","IBM","Sun","Oracle","Apple"}; 
String[] sBak = new String[6]; 
System.arraycopy(s,0,sBak,0,s.length);

3.4 元素查找

  • 顺序查找。
  • 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
    • 二分查找法实质上是不断地将有序数据集进行对半分割，并检查每个分区的中间元素。

3.5 练习

ublic class ArrayTest05 {
    public static void main(String[] args) {
        int [] arr =new int[]{-127,-244,0,0,1,4,4,100,100,127,127};
        System.out.println(getSub(arr,0));;
        char[] chars=new char[]{'1','a','A','B','C'};
        System.out.println(change(chars));
    }

    /*1.数组元素查找(查找指定元素第一次在数组中出现的索引)
     * 若存在:返回这个元素的下标
     * 若不存在:返回-1
     */
    public static int getSub(int[] i,int a){
        for (int j = 0; j < i.length; j++) {
            if (a==i[j]){
                return j;
            }
        }
        return -1;
    }

//2.将一个存放了大写字母的数组转换成存放小写字母的数组返回
    public static char[] change(char[] arr){
        for(int i=0;i<=arr.length-1;i++){
        //如果字符不是A~Z之间的字符不变
            if(arr[i]>='A' && arr[i]<='Z'){
                arr[i]+=32;
            }
        }
         return arr;
}

}

4、数组异常

在使用数组时候，常遇到的一些异常：

  • 1.空指针异常
    NullPointerException
    数组 引用没有指向一个数组对象，指向为空null
  • 2.数组索引越界异常
    ArrayIndexOutOfBoundsException
    索引为负数 索引>=长度
int[] arr = {};
//arr  = null;//==NullPointerException==
System.out.println(arr.length);
System.out.println(arr[0]);//ArrayIndexOutOfBoundsException

5、一维数组练习

/*
    定义一个数组,存储班级所有的学生

    使用数组存储自定义引用数据类型的数据(自定义的类Student..)

        1.构建学生类javabean
        2.创建学生对象
        3.构建数组,存储学生对象
        4.遍历,操作..
 */
public class ArrayDemo06 {
    public static void main(String[] args) {
        //2.创建学生对象
        Student s1 = new Student(101,"张三",18,175);
        Student s2 = new Student(102,"李四",17,170);
        Student s3 = new Student(100,"王五",19,175.5);
        Student s4 = new Student(103,"赵六",20,175.5);
        Student s5 = new Student(104,"孙七",29,175);
        Student s6 = new Student(105,"周八",22,180);
        Student s7 = new Student(106,"吴九",23,180);

        //3.构建数组,存储学生对象
        Student[] arr = {s1,s2,s3,s4,s5,s6,s7};

        //遍历
        /*for(Student s:arr){
            System.out.println(s);
            System.out.println(s.getAge()+","+s.getName());
        }*/

        //身高数组
        //getHeight(arr);
        getStature(arr);
        //最高身高
        //getMaxHe(arr);

    }
    //统计:获取班级所有同学的升高,存在的身高值(去重),最终把出现的数值打印展示
        public static void getHeight(Student[] arr){
            //身高数组，默认值为0；
            double[] h=new double[10];
            int j=0;
            //循环Student数组，
            for (Student i: arr ) {
                boolean b=false;
                //循环对比身高
                for (int a = 0; a <= j; a++) {
                    //判断身高是否和数组有重复，有count+1
                    if (i.getHeight() == h[a]){ b=true;}
                }
                //判断count=0；等于0没有重复，输出
                if (b == false){ h[j++]=i.getHeight();}
            }
            //循环身高数组
            for(int z=0;z<=j;z++){
                //将默认值0不输出
                /*if (h[z] != 0.0) {
                    System.out.println(h[z]);
                }*/
            }
        }

        //方法2  找到身高最高的同学姓名(有几个打印|统计几个)
    public static void getStature(Student[] arr){
        double []height1=new double[7];
        double []height2=new double[7];
        int count=0;
        for (Student s: arr) {
            height1[count]=s.getHeight();
            count++;
        }
        one:for(int i=0;i<height1.length;i++){
            int jount=0;
            two:for(int j=0;j<i-1;j++){
                if(height1[i]==height1[j]){
                    jount++;
                    //continue one;//直接比较下一个数
                }
            }
            if ( jount==0 ) height2[i]=height1[i];
        }
        for (double d:height2){
            if(d!=0.0){
                System.out.println(d);
            }
        }
    }


    //2.找到身高最高的同学姓名(有几个打印|统计几个)
    public static void getMaxHe(Student[] arr){
        //添加默认最大值为数组0位数
        double max=arr[0].getHeight();
        //循环比较最大值
        for (Student i: arr ) {
            if (max<=i.getHeight()){
                max=i.getHeight();
            }
        }
        //循环输出跟最大值相等的Student数值信息。
        for (int a=0;a < arr.length;a++) {
            if (max==arr[a].getHeight()){
                System.out.println(arr[a]);
            }
        }
    }
}

6、二维数组

数组中放数组

6.1、声明

  • 数据类型[ ] [ ] 数组名; -->推荐
  • 数据类型 数组名[ ] [ ];
  • 数据类型[ ] 数组名[ ];
//声明
        int[][] ar ;

6.2 初始化

  • 动态初始化:

    • 在构建外层数组对象之后,直接构建内层的每一个小数组

      数据类型[][] 数组名 = new 数据类型[整数n外层数组长度][整数m内层每一个小数组长度];

    • 先构建外层数组对象,再构建内层的每一个小数组

       数据类型[][] 数组名 = new 数据类型[整数n外层数组长度][];

      ​ 构建内层的每一个小数组 : 就是一维数组的构建方式

  • 静态初始化:

    • 创建数组的同时赋值
    数据类型[][] 数组名 = new 数据类型[][]{{1,2,3},{4,5},{6}...};
    数据类型[][] 数组名 ={{1,2,3},{4,5},{6}...};

//动态
ar = new int[2][2];
//赋值
ar[0][0] = 14;

			//先构建外层数组对象,再构建内层的每一个小数组
        double[][] ar2 = new double[2][];
        //构建内层的每一个小数组
        ar2[0] = new double[3];
        ar2[1] = new double[]{1.1,2.2};

//静态初始化
int[][] ar3 = new int[][]{{1,2,3},{4,5},{6}};
//简化写法
int[][] ar4 = {{1,2,3},{1,2},{1}};
System.out.println(ar4);
//获取
System.out.println(ar4[0][0]);
System.out.println(ar4[0][1]);

6.3 二维数组遍历

  • 双重循环嵌套遍历

  • 普通for与foreach之间任意嵌套

public class ArrayDemo08 {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6}};

        //foreach--foreach
        for(int[] i:arr){
            //i是每一个内层小数组
            for(int j:i){
                //j是内层小数组中的每一个数据值
                System.out.print(j+" ");
            }
        }

        System.out.println("\n-----------------------------------");
        //普通嵌套增强
        for(int i=0;i<=arr.length-1;i++){
            for(int j:arr[i]){
                System.out.print(j+" ");
            }
        }

        System.out.println("\n-----------------------------------");
        for (int[] a:arr) {
            for (int i = 0; i < a.length; i++) {
                System.out.print(a[i]+" ");
            }
        }
        System.out.println("\n-----------------------------------");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
        }
    }
}
忄凝^
关注
专栏目录
Java练习题8
FreeSpider
10-20 747
/第二题：分析以下需求,并用代码实现 1.定义String getStr()方法 功能描述： 获取长度为5的随机字符串，字符串由随机的5个大小写字母组成 2.在main方法中调用上述方法，并打印结果/ /*大写：65-90 小写：97-122*/ import java.util.Random; public class randomStr { public static void m...
学习-Java数组之一维字符数组之大小写转换
m0_65420451的博客
09-09 2025
实现一维字符数组的大小写转换，将数组中的大写字母转化为小写字母，小写字母转化为大写字母，最后输出转换后的字符数组。
以任意指定的字符分割一个字符串，然后保存在字符串数组中
07-13
以任意指定的字符分割一个字符串，然后保存在字符串数组中
Java数组基础
weixin_47968954的博客
07-21 181
Java数组及遍历
将大写字母转换为小写字母（将该字符串中的大写字母转换成小写字母，之后返回新的字符串。）
be_gin_ner的博客
03-25 6831
将该字符串中的大写字母转换成小写字母，之后返回新的字符串。 示例 1： 输入: "Hello" 输出: "hello" 示例 2： 输入: "here" 输出: "here" 示例 3： 输入: "LOVELY" 输出: "lovely" 通过ASCII码标的所在位置来判断是否为大写字母，并将其通过加32对应到其小写字母的位置。 public class test0325 { pub...
Java SE：数组详解与C/C++风格声明
- 创建数组：使用`new`关键字和指定的数据类型，如`double[] myList = new double[10];`，创建一个包含10个double类型的元素的数组。 数组在Java编程中广泛用于处理大量数据，简化代码组织，提高效率。无论是基础...
21天学会Java之(Java SE第八篇):数组、冒泡排序法、二分法查找
01-20
数组 数组的定义 数组是相同类型数据的有序集合，数组描述的是相同类型...数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。 数组声明 在声明数组变量
JAVA基础：数组拷贝与编程入门
Java的版本历史包括JDK1.0至JDK1.5，以及后续的Java SE6等，每个版本都引入了新的特性和改进，如J2EE、J2SE和J2ME的划分，展示了Java在不同领域的适应性和扩展性。此外，Java的许可证策略也反映了开源社区的接纳，如...
Java基础：数组赋值与输出详解
学习Java SE技术时，基础至关重要，包括熟悉语法、控制结构、异常处理和数据结构。同时，查阅官方文档（DOC文档）和不断解决问题的能力也是提高技能的关键。与其他开发者交流，避免孤立学习，可以更快地提升编程技巧...
Java基础：数组声明与空间开辟指南
在Java基础课程中，声明和开辟数组空间是编程中的基础知识。首先，让我们理解声明数组的过程。在Java中，当你需要定义一个整数类型的数组时，可以使用以下语句： ```java int score[] = null; ``` 这里的`null`并...
// 输入一行字符串，该字符串中所有大写字母改为小写字母，然后存放在一个新数组中，最后输出原字符串和转换后的字符串
C语言100题
06-02 2298
// 输入一行字符串，该字符串中所有大写字母改为小写字母，然后存放在一个新数组中，最后输出原字符串和转换后的字符串
LeetCode刷题 | 将数组中的大写字母转换成小写字母
weixin_45615071的博客
03-31 1445
题目描述 实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。 示例 输入: “Hello” 输出: “hello” 知识点回顾 A-Z的ASCII值为65~90 a-z的ASCII值为97~122 代码示例 char * toLowerCase(char * str){ int i = 0; while(str[i] != '\0') { if(str[i] <= 90
将一个数组的1至26的数转换成对应的小写字母a-z，其他的数用"？"表示
csulfy的博客
11-15 6769
 将一个数组的1至26的数转换成对应的小写字母a-z，其他的数用"？"表示，如 int [] arr = {1,2,3,67}; 则转换后的数组为 {a,b,c,?} public class Main { public static void main(String[] args) { int arr[] = { 1, 2, 3, 4, 5, 6, 45, 6, 7 }; so
实现函数 ToLowerCase() ，该函数接收一个字符串参数 str ，并将该字符串中的大写字母转换成小写字母， 之后返回新的字符串。
qq_43404121的博客
02-05 2143
利用大写字母’A’~'Z’的ASCII码值为65-90,小写字母的ASCII码值为97-122两者之间相差32，因此遍历字符串如果是大写字母就给其加上32就可以将其转化成小写字母。 ```cpp class Solution { public: string toLowerCase(string str) { int i,length=str.size(); ...
数组的一些经典练习回顾
m0_46168848的博客
05-10 131
数组的一些经典练习 import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; /**1. 数组元素查找(查找指定元素第一次在数组中出现的索引) * 若存在:返回这个元素的下标 * 若不存在:返回-1 * * 参数： int[] arr,int i * 返回值: 索引 int * 2. 数组元素去除0元素 * 原数组: 4,2,8,0,1,5,0,7,10 *
【Java练习】实现函数 ToLowerCase() ，该函数接收一个字符串参数 str ，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串 。
zhangxxin的博客
01-17 803
学习目标： 目标：快速掌握 Java 入门知识 学习内容： 本文内容：使用java语言实现：实现函数 ToLowerCase() ，该函数接收一个字符串参数 str ，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串 。 文章目录学习目标：学习内容：实现思路：实现代码：运行结果： 实现思路： 首先使用toCharArray()方法将字符串存放到char数组中，查阅ASSII表可知，对应大小写字母数值相差32 ，使用for循环将数组每一个元素加上32，可将大写字母转化为小写字母，最后使用Arr
Java SE MyBatis框架(详解)
忄凝^的博客
04-25 1420
Java SE MyBatis框架 目录Java SE MyBatis框架通用框架1.lib2、src2.1、mybatis.xml2.2、DateBase.properties2.3、log4j.properties2.4、generatorConfig.xml2.5、mapper包2.6、pojo包2.7、utils包1、框架介绍2、Mybatis特点My Batis功能架构图:3、Mybatis环境搭建3.1、新建Java项目3.2、导入jar包3.3、Mybatis配置文件3.3.1、dtd3.3.
JavaSE 发展史及HelloWorld
忄凝^的博客
03-23 583
csdn: JavaSE 发展史及HelloWorld 目录JavaSE 发展史及HelloWorld1、语言的发展2、Java发展史2.1 发展2.2 Java各版本2.3 Java特点及优势3、Java运行机制3.1 JVM虚拟机3.2 JRE运行环境3.3 JDK Java开发工具包4、java开发与环境搭建4.1 安装4.2 测试4.3 设置环境变量5、常见DOS命令6、HelloWorld6.1.java的执行流程6.2**HelloWrold实现步骤**7、常见问题 1、语言的发展 机器语.
Java SE Function接口&Lambda
忄凝^的博客
04-15 559
Java SE Function接口&Lambda 目录Java SE Function接口&Lambda1、Lambda表达式2、函数式接口2.1 四大内置函数接口2.2、Consumer （1参无回值）2.3、Supplier T get() 无参有回值2.4、Function1、Lambda表达式   Lambda表达式是一个匿名函数， 我们可以把Lambda表 达式理解为是一段可以传递的代码（将代码像数据一样 进行传递） 。 1、语法 ( 形参列表 )->{ 操作集合 }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值