Java入门：Day04—数组

最新推荐文章于 2024-06-28 22:00:00 发布
最新推荐文章于 2024-06-28 22:00:00 发布
阅读量168 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43506382/article/details/110151682
版权

Day04—数组

1、定义

数组是一个容器，可以同时存放多个数据；是存储相同数据类型的一组数据的集合

2、一维数组定义

（1）静态初始化：
在创建数组的同时并进行赋值操作。确定数组中的具体内容时使用。

//①数据类型[] 数组名 = new 数据类型[]{元素1，元素2.....};
int[] score = new int[]{77,78,99,56,67};

//②数据类型[] 数组名 = {元素1，元素2.....};
int[] score = {77,78,99,56,67};

（2）动态初始化：
不确定数组中的具体内容时使用

//①数据类型[] 数组名 = new 数据类型[数据的长度];
String[] names = new String[5];

//②数据类型 数组名[] = new 数据类型[数据的长度];
String names[] = new String[5];
//数据类型：空间大小；	数组名：这一组数据的统称；	new：动作；		长度：数组的个数

（3）数组特点：
①数组是一个引用数据类型；

②数组一次存放多个值，数据类型必须相同（统一）；

③数组的长度在程序运行期间不可以改变。

（4）常见问题：

①数组的溢出：访问数组元素时，下标编号不存在，会发生这种索引越界异常。

②空指针异常，不能直接使用未开辟堆内存空间的数组，数组必须进行初始化才可以使用。

（5）foreach循环（增强循环）：
依次从数组取出各个元素，赋值给这个变量，同这个变量进行输出；变量的数据类型和数组一致。

/*
for (数据类型 变量 : 数组或集合){
    }
    */
for(int i:arr){   //例如
}

（6）对数组的操作：
①求数组长度

public class Test1_ArrLength {
    public static void main(String[] args) {
         int[] arr = {4,6,2,9,6,1,12,65,3,34,47};
         int len = arr.length;  //获得arr2数组的长度
         System.out.println("数组的长度为"+len);
    }
}

②遍历数组

public class Test2_Arr {
       public static void main(String[] args) {
            int[] arr = {4,6,2,9,6,1,12,65,3,34,47};
            for(int i = 0; i <arr.length; i++){   //快捷键（数组名.fori）如：arr.fori
                System.out.println(arr[i]);
            }
       }
}

③获取最大、最小值

//foreach方法
    public static void main(String[] args) {
            int[] arr = {4,6,2,9,6,1,12,65,3,34,47};
            int max = arr.length-1;
            int min = arr[0];
            for (int i:arr) {
                if(i > max){
                    max = i;
                }
                if(i < min){
                    min = i;
                }
            }
            System.out.println("最大值为："+max);
            System.out.println("最小值为："+min);
    }

//for循环方法
    public static void main(String[] args) {
            int[] arr = {4,6,2,9,6,1,12,65,3,34,47};
            int max = arr.length-1;
            int min = arr[0];
            for(int i = 0; i < arr.length; i++){
                if(arr[i] > max){
                    max = arr[i];
                }
                if(arr[i] < min){
                    min = arr[i];
                }
            }
            System.out.println("最大值为："+max);
            System.out.println("最小值为："+min);
    }

④数组元素的反转

 public class Test4_ArrReverse {
        public static void main(String[] args) {
            int[] arr = {4,6,2,9,6,1,12,65,3,34,47};
            for (int i = 0; i < arr.length; i++) { //输出未反转前的数组
                System.out.print(arr[i]+"\t");
            }
            System.out.println();
            //数组反转
            int center = arr.length / 2;
            int head = 0; //前下标
            int end = arr.length - 1;//后下标
            for(int i = 0; i < center; i++){  //数据交换
                int temp = arr[head];
                arr[head] = arr[end];
                arr[end] = temp;
                head++;  //往下一个数据走
                end--;
            }
            for (int c  : arr) {  //打印反转后的数组
                System.out.print(c+"\t");
            }
            System.out.println();
       }
}

//简便方法（有缺陷）
    public static void main(String[] args) {
            int[] arr = {4,6,2,9,6,1,12,65,3,34,47};
            for (int i = 0; i < arr.length; i++) { //输出未反转前的数组
                System.out.print(arr[i]+"\t");
            }
            System.out.println();
        
            for (int i = arr.length-1; i >= 0; i--) {
                System.out.print(arr[i]+"\t");
            }
    }

⑤数组元素的查找

public class TestFind{
	  public static void main(String[] args) {
            String[] arr = {"张三","李四","王五","徐三","赵四"};
            Scanner input = new Scanner(System.in);
            System.out.print("请输入您要查找的元素：");
            String name = input.next();
            int index = -1;  //定义索引变量（找有没有要查找的元素）
            for (int i = 0; i < arr.length; i++) {
                if(name.equals(arr[i])){  //数组中比较字符串是否相等
                    index = i;
                    break;
                }
            }
            if(index == -1){
                System.out.println("没有您要查找的元素！");
            }else{
                System.out.println("您要查找的元素在"+index);  //输出查询元素的下标
                System.out.println(arr[index]);
            }
      }
}

⑥数组元素的添加

public class Test5_ArrAdd {
      public static void main(String[] args) {
            String[] arr = {"张三","李四","王五","徐三","赵四"};
            Scanner input = new Scanner(System.in);
            System.out.print("请输入您要添加的元素：");
            String name = input.next();
            String[] newArr = null;  //声明一个新数组
            if(arr[arr.length-1] != null){  //说明数组已满
                newArr = new String[arr.length + 2];  //创建新容器
                for (int i = 0; i < arr.length; i++) { //数据迁移（arr的值往newArr里迁移）
                    newArr[i] = arr[i];
                }
                arr = null;  //指向arr数组的指向断开
            }
            //判断空位置
            int index = -1;
            for (int i = 0; i < newArr.length; i++) {
                if(newArr[i] == null){
                    index = i;
                    break;
                }
            }
            if(index != -1){
                newArr[index] = name;
            }else {
                System.out.println("没有位置了！");
            }
            for (String n:newArr) {
                if(n == null){
                    break;
                }
                System.out.print(n+"\t\t");
            }
      }
}

⑦数组元素的删除

public class Test5_ArrDel {
       public static void main(String[] args) {
            String[] arr = {"张三","李四","王五","徐三","赵四"};
            Scanner input = new Scanner(System.in);
            System.out.print("请输入您要删除的元素：");
            String name = input.next();
            int index = -1;  //定义索引变量（找有没有要删除的元素）
            for (int i = 0; i < arr.length; i++) {
                if(name.equals(arr[i])){  //数组中比较字符串是否相等
                    index = i;
                    break;
                }
            }
            System.out.println("******************删除之前*******************");
            for (String a:arr) {
                System.out.print(a+"\t\t");
            }
            if(index !=-1){  //说明有这个元素
                //数据前移
                for (int i = index; i < arr.length-1; i++) {
                    arr[i] = arr[i+1];
                }
                arr[arr.length-1] = null;  //数组最后一个元素置空
                System.out.println("\n******************删除之后*******************");
                for (String a : arr) {
                    if(a == null){
                        break;
                    }
                    System.out.print(a+"\t\t");
                }
            }else{
                System.out.println("没有你要删除的元素！");
      }
}

⑧数组元素的插入

public class Test5_ArrInto {
      public static void main(String[] args) {
            String[] arr = {"张三","李四","王五","徐三","赵四",null};
            Scanner input = new Scanner(System.in);
            System.out.print("请输入您要插入的元素位置：");
            int num = input.nextInt();
            System.out.print("请输入您要插入的元素：");
            String name = input.next();
            //判断空位置
            int index = -1;
            for (int i = 0; i < arr.length; i++) {
                if(arr[i] == null){
                    index = i;
                    break;
                }
            }
            if(index != -1){
                for(int i = arr.length-1; i > num; i--){
                 arr[i] = arr[i-1];
                }
                arr[num] = name;
                for (String n:arr) {
                    System.out.print(n+"\t\t");
                }
            } else {
                System.out.println("没有空位置！");
            }
      }
}

3、排序

（1）冒泡排序：两个相邻的元素依次进行比较，外层循环长度-1，内层循环长度-i -1

public class TestBubbleSort {
    public static void main(String[] args) {
        int[] arr = {92,77,11,89,9,66,26,19,33,6};
        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]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println("输出排序后的数组：");
        for (int j : arr) {
            System.out.print(j+"\t");
        }
    }
}

（2）选择排序：选择一个固定的元素，和其他每个元素进行比较

public class TestSelectSort {
    public static void main(String[] args) {
        int[] arr = {92,77,11,89,9,66,26,19,33,6};
        for (int i = 0; i < arr.length-1; i++) {   //一次
            for (int j = 1+i; j < arr.length; j++) {  //一遍
                if(arr[i] < arr[j]){  //比较
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("输出排序后的数组：");
        for (int j : arr) {
            System.out.print(j + "\t");
        }
    }
}

（3）插入排序：将一组元素分成已排序和未排序两个区间，将未排序区间插入到已排序区间完成排序

public class TestInsertSort {
    public static void main(String[] args) {
        int[] arr = {92,77,11,89,9,66,26,19,33,6};
        for (int i = 0; i < arr.length; i++) {  //比较次数
            int data = arr[i];  //变量
            int index = i;  //下标
            while(index > 0){
                if(data > arr[index-1]){
                    arr[index] = arr[index-1]; //赋值
                }else{
                    break;
                }
                index--;
            }
            arr[index] = data;  //插入数据
        }
        System.out.println("输出排序后的数组：");
        for (int i : arr) {
            System.out.print(i+"\t");
        }
    }
}

4、二维数组

（1）定义：
描述多行多列的结构，表结构。 一维数组中嵌套一维数组，形成二维数组。

（2）动态初始化

数据类型[][] 数组名 = new 数据类型 [行的长度][列的长度];
int[][] x = new int [2][3];

数据类型 数组名[][] = new 数据类型 [行的长度][列的长度];
int x[][] = new int [2][3];

（2）静态初始化

数据类型[][] 数组名 = new 数据类型[][]{{元素1，元素2.....},{元素1，元素2.....}};
int[][] x = new int [][]{{1,2,3},{2,3,4},{3,4,5}};

数据类型[][] 数组名 = {{元素1，元素2.....},{元素1，元素2.....}};
int[][] x = {{1,2,3},{2,3,4},{3,4,5}};

5、Arrays类

（1）binarySearch（查询，底层使用二分查询，必须有序）返回元素在数组的下标

public class TestBinarySearch {
    public static void main(String[] args) {
        int[] arr = {9, 2, 3, 1, 5, 6, 4, 8, 7};
        //排序
        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]){
                    int num = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = num;
                }
            }
        }
        System.out.print("输出排序后的数组：");
        for (int i : arr) {
            System.out.print(i + "\t");
        }
        System.out.println("\n查询的元素下标为：" + Arrays.binarySearch(arr,7));//第一个参数数组，查询的元素
    }
}

（2）sort(数组) 排序 升序。

public class TestSort {
    public static void main(String[] args) {
        int[] arr = {92,77,11,89,9,66,26,19,33,6}; //无序
        System.out.println("排序前的数组 ："+ Arrays.toString(arr));
       /* Arrays.sort(arr,2,5);//给选定范围排序，起始位置包括，结束没有包括*/
        Arrays.sort(arr);  //升序排序（降序只能手写）
        System.out.println("排序后的数组 ："+Arrays.toString(arr));
    }
}

（3）fill(数组，值) 替换。

public class TestFill {
    public static void main(String[] args) {
        int[] arr = {92,77,11,89,9,66,26,19,33,6}; //无序
        System.out.println("替换前的数组 ："+ Arrays.toString(arr));
        Arrays.fill(arr, 2,5,100);  //将下标2——5的元素替换为100
        System.out.println("替换后的数组 ："+Arrays.toString(arr));
    }
}

（4） equals(数组，数组) 比较

public class TestEquals {
    public static void main(String[] args) {
        String[] arr1 = {"apple", "banana", "orange"};
        String[] arr2 = {"apple", "banana", "orange"};
        System.out.println(Arrays.equals(arr1,arr2));
    }
}

（5）copyOf(数组，长度) 复制

public class TestCopyOf {
    public static void main(String[] args) {
        int[] arr = {92,77,11,89,9,66,26,19,33,6};
        int[] arr2 = {1,2,3,4,5};
        int[] arr1 = Arrays.copyOf(arr, arr.length);
        System.out.println("原数组：" + Arrays.toString(arr));
        System.out.println("原样复制后的数组arr1："+Arrays.toString(arr1));
        System.arraycopy(arr,2,arr2,1,3);  //把arr数组下标为2开始的数依次插入arr2数组下标为1——3范围内
        System.out.println("复制后的数组arr2："+Arrays.toString(arr2));
    }
}
Gloria_hr
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java输出字符串中最长的数字串
橘白呀啊的博客
04-14 1291
文章目录题目描述解题思路代码如下总结 题目描述 读入一个字符串str，输出字符串str中的连续最长的数字串 输入： abcd12345ed125ss123456789 输出： 123456789 以下是本篇文章正文内容，下面案例可供参考 解题思路 定义一个当前的字符串和长度，再定义一个最大的字符串和长度，遍历字符串str 当是数字时，将数字append字符串中，长度+1，当前的数字集合大于最大数字个数时，将当前存放的数字串(curNum)和数字串长度(maxLen)赋给记录最长的数字串(ma.
javscirpt 数组的方法
YM123456999的博客
12-24 694
isArray（） join() push()和pop() shift() 和 unshift() sort() reverse() concat() slice() splice() indexOf()和 lastIndexOf() （ES5新增） forEach() （ES5新增） map() （ES5新增） filter() （ES5新增） every() （ES5新增） some() （ES5新增） reduce()和 reduceRight() （ES5新增） 1.isArray 数组自带的方法
day04--Java数组
成功在于坚持！
03-20 87
1.数组 1.1什么是数组【理解】 数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。 1.2数组定义格式【记忆】 1.2.1第一种 数据类型[] 数组名 示例： int[] arr; double[] arr; char[] arr; 1.2.2第二种 数据类型 数组名[] 示例： int arr[]; double arr[]; char arr[]; 1.3数组动态初始化【应用】 1.3.1什么是动态初始化 数组动态初始...
Java入门day03--数组
qq_44110124的博客
02-20 235
一、数组 数组--相同类型数据的有序集合 数组的声明和创建: 声明-----在类型后面加[]:int[] nums-----首选/在变量后面加[]:int nums[]; 创建---nums=new int[10] 二、内存分析 堆：存放new的对象和数组--可被所有线程共享，不会被别的类和对象引用 栈：存放基本变量类型和具体的数据--引用对象的变量（引用在堆里的具体地址） 方法区：可以被所有线程共享--包含所有class、static变量； 声明数组--在栈里面创建一个空间 创建数组并赋值
Java入门基础学习资料day03-04
10-22
day04【 Idea、方法】 day05【数组】 day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day...
Java入门基础学习资料day11
10-22
day04【 Idea、方法】 day05【数组】 day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day...
day002 JAVA语法基础-数组入门.doc
08-16
day002 JAVA语法基础-数组入门.doc
Java入门基础学习资料day09-10
10-22
day04【 Idea、方法】 day05【数组】 day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day...
Java入门基础学习资料day07-08
10-22
day04【 Idea、方法】 day05【数组】 day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day...
Java的异常处理体系
落日的博客
06-28 822
ControllerAdvice 注解用于定义全局控制器建议，在 Spring MVC 中，控制器建议由控制器中的 @ExceptionHandler 方法、@InitBinder 方法和 @ModelAttribute 方法组成。①、CheckedException （检查异常 必须在代码中显式处理 使用try catch捕获 或者 在方法上使用 throws 抛出 除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常 ）
idea配置外置gradle
蔡定努
06-28 213
路径： /Users/caidingnu/save/gradle-8.5/init.d/ init.gradle。下载gradle包，解压。idea 配置文件修改。
Android10 SystemUI系列 需求定制（二）隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等
fighting_2017的博客
06-25 85
SystemUI 所包含的界面和模块比较多，这一节主要分享一下状态栏通知图标和通知栏的定制需求：隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等来熟悉一下Systemui。
multiprocessing.Queue 多个进程生产和多个进程消费怎么处理
qh0526wy的博客
06-24 229
在主进程中，我们创建了多个消费者和生产者进程，并将它们启动。生产者进程将数据放入队列，消费者进程从队列中取出数据并处理。生产者进程完成后，我们向队列发送。进行多个生产者和多个消费者的场景时，队列可以很好地协调这些进程。这个模式允许多个生产者并发地向队列中放入数据，同时多个消费者并发地从队列中取出并处理数据，直到所有生产者完成生产，消费者接收到结束信号。函数，分别用于从队列中获取数据和向队列中放入数据。来确保队列可以在多个进程之间共享。方法等待队列中的所有任务完成时很有用。在这个示例中，我们创建了一个队列。
计算机等级考试-Java考试大纲
weixin_54454406的博客
06-27 84
二级Java语言程序设计考试大纲。
RocketMQ快速入门：事务消息原理及实现（十）
最新发布
55555的博客
06-28 288
最后一句话总结一下，rocketmq的事务消息，是通过half消息（即二阶段提交）+回查机制来实现的。
JVM 相关知识整理
杨杨杨~~的博客
06-20 856
如果您觉得有用的话，记得给，写作不易啊^ _ ^。而且听说，实在白嫖的话，那欢迎常来啊!!!
分布式kettle调度管理平台简介
sharehoo的博客
06-28 461
分布式kettle调度管理系统，采用微服务前后端分离方式开发，前端采用vue2，页面美观，系统可扩展性强，兼容主流kettle版本，无入侵源码，实时支持升级版本。
面试-java多线程与并发
TOMORROW6COME的博客
06-23 285
进程是资源分配的最小单位，线程是CPU调度的最小单位。进程让操作系统的并发性成为可能，线程让进程的内部并发成为可能。Thread.start()创建子线程，再在子线程中调用Thread中实现好的run方法去执行相应的业务逻辑。源码中start使用start0()方法调用JVM_StartThread()方法。这里其实就是Thread.start()方法会创建出子线程！进程是抢占处理机的调度单位，线程属于某个进程，共享其资源。Runnable是个接口(只有个抽象的run方法)。start方法会创建新的线程。
day02-Java基础语法.pdf
12-13
在"day02-Java基础语法.pdf"中，本章节主要介绍了Java语言的基础语法，重点涵盖以下几个关键知识点： 1. **运算符**： - **算术运算符**：包括加 (+)，减 (-)，乘 (*), 除 (/), 取余 (%), 这些运算符用于处理整数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值