java5：数组

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量50 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/generalfuck/article/details/128572213
版权

数组

1. 数组概述

  • 数组是相同类型数据的有序集合
  • 数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成
  • 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们

2. 数组声明创建

  • 首先必须声明数组变量，才能再程序中使用数组

    public class Array_test {
    public static void main(String[] args) {
        /*
        两种声明方式：
        1. 数据类型声明数值（java常用方式）
        2. 在变量中声明数组
         */
          int[] array1;
          array1 = new int[10]; //创建int类型可以储放10个数的array1数组
          int array2[];
          array2 = new int[5]; //创建int类型可以储放10个数的array2数组
    }
}

  • 数组赋值

public class Array_test {
    public static void main(String[] args) {
        int[] array1;
        array1 = new int[10];
        // 给数组赋值
        array1[0] = 1;
        array1[1] = 2;
        System.out.println(array1[0]);
        System.out.println(array1[1]);
        System.out.println(array1[9]);
    }
}

1
2
0
  • 使用length方法查询数组长度
    • 遍历数组并赋值
public class Array_test {
    public static void main(String[] args) {
        //int[] array1;
        //array1 = new int[10];
        //以上两句代码可简写为
        int[] array1 = new int[10];
        // 给数组赋值
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            array1[i] = i;
            sum += array1[i];
        }
        System.out.println(sum);
    }
}

45

3. 数组使用

  • 增强型for循环（for each），省略了下标
public class Array_test {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5};
        for (int array :
                array1) {
            System.out.println(array);
        }
    }
}

1
2
3
4
5
  • 通过函数调用输出数组
public class Array_test {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5};
        printArray(array1);
    }

    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

1 2 3 4 5
  • 数组数值反转
public class Array_test {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5};
        printArray(reverse(array1));
    }
	//排序函数
    public static int[] reverse(int[] array) {
        int[] result = new int[array.length];
        for (int i = 0, j = result.length - 1; i < array.length; i++, j--) {
            result[j] = array[i];
        }
        return result;
    }
    //打印函数
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

5 4 3 2 1

4. 多维数组

public class Array_test {
    public static void main(String[] args) {
        int[][] array = {{1, 2}, {3, 4}, {5, 6}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

1
2
3
4
5
6

5. Arrays类

  • 冒泡排序
import java.util.Arrays;

public class Array_test {
    public static void main(String[] args) {
        int[] a = {0, 212, 245, 43, 1, 34, 12};
		//Arrays.sort(a);
		//System.out.println(Arrays.toString(minToMax(a)));
        showString(minToMax(a));
    }

    public static void showString(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (i == 0) {
                System.out.print("[");
            }
            if (i == a.length - 1) {
                System.out.print(a[i] + "]");
            } else {
                System.out.print(a[i] + ",");
            }
        }
    }

    public static int[] minToMax(int[] a) {
        int max = 0;
        for (int i = 0; i < a.length - 1; i++) {
            boolean flag = true;
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    max = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = max;
                    flag = false;
                }
            }
            if (flag != false) {
                break;
            }
        }
        return a;
    }
}

6. 稀疏数组

  • 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
  • 稀疏数组的处理方式是：
    • 记录数组一共有几行几列，有多少个不通值
    • 把具有不同值的元素和行列及值记录再一个小规模的数组中，从而缩小程序的规模
  • 在这里插入图片描述
public class ArrayTest2 {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        System.out.println("原始数组：");

        // 相当于python：for i in array1:
        for (int[] i : array1) { // 输出每一行数组
            for (int j : i) { // 遍历每行数组的值
                System.out.print(j + "\t");
            }
            System.out.println();

        }
        System.out.println("=======================================");
        // 转换为稀疏数组
        // 1.获取有多少个有效值
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值个数：" + sum);

        // 2.创建一个稀疏数组 的数组
        int[][] array2 = new int[sum+1][3];
        // 记录有效值：11行，11列，sum个有效值
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        // 遍历二维数组，将有效值的 行、列、值 存放再稀疏数组中
        int count = 0; // 记录第几个有效值存放在稀疏数组中的行数
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        // 打印稀疏数组
        System.out.println("稀疏数组：");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(
                    array2[i][0] + "\t"+
                    array2[i][1] + "\t"+
                    array2[i][2] + "\t");
        }

        System.out.println("=======================================");
        System.out.println("稀疏数组还原：");
        // 1.读取稀疏数组
        // 创建一个新数组存放还原后的数组，新数组的行列为稀疏数组的第一行数据
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        // 2.还原值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

原始数组：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
=======================================
有效值个数：2
稀疏数组：
11	11	2	
1	2	1	
2	3	2	
=======================================
稀疏数组还原：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0
不会写code的牛哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java long型数组赋值,Java随记:数组
weixin_33253331的博客
03-13 7590
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。Java语言中提供的数组是用来存储固定大小的同类型元素。声明数组变量结构:1. 数组类型 [] 数组名; 或 dateType [] arrayName; (推荐方式)eg: double [] doubleArr;2.数组类型 数组名 []; 或 dateType arrayName [];eg: do...
java 数组下标 变量_Java基础语法：数组
weixin_39830588的博客
02-13 2344
一、简介描述：数组是相同类型数据的有序集合。其中,每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。基本特点：数组的长度是确定的。数组一旦被创建，它的大小就是不可以改变的。数组元素必须是相同类型，不允许出现混合类型。数组中的元素可以是任何数据类型，包括基本类型和引用类型。数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中...
java基础：数组
lalala_dxf的博客
02-17 3471
数组 二维数组
java基础：数组是否包含某元素
jasonJ_0419的博客
03-30 2809
判断数组是否包含某元素的四种方式
Educoder/头歌JAVA实训——JAVA入门：数组进阶
舟舟的博客
12-18 4278
数组除了基本的使用方式之外，还有很多常用的操作，比如：冒泡排序，选择排序、查找等操作。 本实训我们就来学习数组的一些常用操作方式。
Java基础篇：数组
热门推荐
张维鹏的博客
10-10 3万+
数组是一种线性数据结构，是一个使用连续的内存空间存放相同的数据类型的集合容器，与其他容器相比，数组的区别主要在于性能与保存基本类型的能力。 在Java中，数组是一种效率最高的存储和随机访问对象的方式，通过寻址公式，随机访问的时间复杂可以达到O(1)，但是为了保持空间的连续性，在数组中插入、删除数据时，都需要移动后面数据，该操作的时间复杂度为O(n)。另外，由于空间上连续，所以数组对CPU缓存比较友好，借助CPU的缓存机制，预读数组中的数据，提高访问效率。但是，由于数组是定长
java基础：数组元素的交换
qq_39954916的博客
11-05 1854
package com.atguigu.java2; /* * 数组元素的交换 */ public class ArrayAriTest3 { public static void main(String[] args) { int a=10; int b=6; //方式一(建议)：基本数据类型和引用数据类型都能用 int temp = a; a =b; b= temp; //方式二：只能是基本数据类型中的数值类型可以用，并且可能会损失精度，优点是少用一个变量节省内存 a=...
Java编程：数组遍历的基本案例
Java_Xiaobai11的博客
11-28 2366
数组遍历。，数组获取最值(获取数组中的最大值最小值)，数组排序和二分查找 二分查找需要数组是有序的 二分查找的基本思路： 获取最大和最小索引，求出中间元素的索引mid； 三角（二维数组练习） 分析： A:如果是n行，那么最后一行是n列。 B:每一行的第一列和最后一列的元素是1。 C:判断：若得到查找值key= mid，则满足条件，停止循环输出对应索引； 如得到key>mid，则取后半段，最新小索引为mid+1； 若得到key< mid ,则取前半段，新最大索引为mid-1； 若不存在则输出错误结果；
Java基础：数组去重方法
wangshiqi666的博客
04-18 2549
java去重
java 入门专题： 数组 练习题
DAurora的博客
10-25 1万+
数组专题——练习题： 1、请将1,9,2,5,4,8,3,6,7,10,8存入数组a，然后输出打印； /* *@author MingxuDeng *@version 20202020年10月25日 note : 1、请将1,9,2,5,4,8,3,6,7,10,8存入数组a，然后输出打印； */ public class Demoarr01 { public static void main(String[] args) { int[] a= {1,9,2,5,4,8,3,6,7,10,8
java算法题 : 数组相关问题
03-14
5. Java库中的Arrays.sort()方法：可以直接对整型、字符型、对象数组进行排序。 五、数组与算法题 1. 两数之和：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。这可以通过哈希表实现，时间复杂度为...
Java基础教程：数组和集合
01-05
Java 基础教程：数组和集合 Java 中的数组和集合是两个非常重要的概念，它们用于存储和操作数据。在本文中，我们将详细介绍 Java 中的数组和集合，包括它们的定义、初始化、访问和常见操作。 数组（Array） 数组...
JAVA语言程序设计：数组.ppt
06-23
Java语言中的数组是一种重要的数据结构，它允许程序员存储和操作同一类型的数据集合。在本课件中，我们探讨了数组的定义、初始化、引用以及一些关键特性。 首先，数组是解决大量相同对象管理问题的一种手段。当我们...
Java程序设计基础：数组的概念.pptx
05-26
数组的概念 目录 课程导入 理解数组概念 熟记数组元素（下标变量）与普通变量形式上的差异 能区分一维数组与二维数组 引入 数组的基本概念 问题1：从键盘输入10个学生的成绩，求平均分。 问题2：在上例的基础上，...
数组练习题Subject:数组
10-16
5. 数组元素交换 数组元素交换是数组操作的一种常见需求。在 Subject05 中，我们需要输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。这可以通过使用 Java 中的数组索引和赋值操作来实现。...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 559
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 800
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1090
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 776
@Transactional中使用线程锁导致了锁失效与解决方案
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值