精华内容
下载资源
问答
  • 主要介绍了Java map存放数组并取出值代码详解的相关内容,小编觉得挺不错的,这里给大家分享一下,需要的朋友可以参考。
  • 首先采用用动态初始化初始一个固定长度的数组 int[] a=new int[3]; 每一个数组中的元素都有一个角标也称索引,数组中元素的变化大多都是通过角标来实现的,类似于每一个... 通过这些代码来将数组中的元素存入并输出。

                                    首先采用用动态初始化初始一个固定长度的数组

                                                            int[] a=new int[3];

    每一个数组中的元素都有一个角标也称索引,数组中元素的变化大多都是通过角标来实现的,类似于每一个房间的门牌号,是每一个元素的身份标识。下面的取出和添加都是通过角标来实现。

    一、取出

    int[] a= new int[3];

    int number1 = a[0];

    int number2 = a[1];

    int number3 = a[2];

    int number4 = a[3];

    后面方括号里面的内容就是元素的角标。元素number1的角标就是0,以此类推。

    System.out.println(number1);

    System.out.println(number2);

    System.out.println(number3);

    System.out.println(number4);

    通过这些代码就能将数组中各个元素取出,我们可以发现他们都是0,默认数值为零

    二、存入

    a[0] = 1;

    a[1] = 2;

    a[2] = 3;

    a[3] = 4;

    System.out.println(number1);

    System.out.println(number2);

    System.out.println(number3);

    System.out.println(number4);

    通过这些代码来将数组中的元素存入并输出。

    展开全文
  • 对于入门选手,首先肯定会想到用二维数组,二维数组的实质其实就是一个一维数组,只不过数组里面存的是其他数组的首地址,通过引用指向其他数组。需要注意的是,学生成绩需要用户手动输入,这需要使用...

    aaee5e0417de9c29dcda7d9d616c179c.png

    今天练习的时候遇到一个题目,题目需求是这样的:

    需求说明:

    根据3个班各5名学生某门课程的成绩,正确使用二维数组计算如图所示3个班各自的总成绩

    598b067e2895429f9e8e4e7844bb2a74.png

    分析:

    要实现这个功能需要存储两个信息:

    • 一个是班级信息,一个是学生成绩信息,对于入门选手,首先肯定会想到用二维数组,二维数组的实质其实就是一个一维数组,只不过数组里面存的是其他数组的首地址,通过引用指向其他数组。
    • 需要注意的是,学生成绩需要用户手动输入,这需要使用到Java的Scanner类,通过该类的对象调用nextInt()(接收整型数据),next()(接收字符串类型),具体用法如下:
    import java.util.Scanner;//导入类
     Scanner sc=new Scanner(System.in);//实例化Scanner对象
     int studentScore=sc.nextInt();//接收用户输入的Int型数据

    只需要用到两个for循环进行嵌套,用户依次输入数据存入数组;

    下面是具体的代码:

    import java.util.Scanner;
    public class Test08 {
        public static void main(String[] args) {
            int[][] scores=new int[3][5];
            Scanner sc=new Scanner(System.in);
            int sum=0;
            for (int i = 0; i <scores.length ; i++) {
                System.out.println("********第"+(i+1)+"个班********");
                for(int j=0;j<scores[i].length;j++){
                    System.out.print("请输入第"+(j+1)+"个同学的成绩:");
                    int studentScore=sc.nextInt();
                    scores[i][j]=studentScore;
                }
            }
            System.out.println("********成绩统计********");
            for (int i = 0; i <scores.length ; i++) {
                for(int j=0;j<scores[i].length;j++){
                    sum+=scores[i][j];
                }
                System.out.print((i+1)+"班总成绩:"+sum);
                System.out.println();
                sum=0;
            }
        }
    }

    下面是运行结果截图:

    ********第1个班********
    请输入第1个同学的成绩:50
    请输入第2个同学的成绩:60
    请输入第3个同学的成绩:70
    请输入第4个同学的成绩:80
    请输入第5个同学的成绩:90
    ********第2个班********
    请输入第1个同学的成绩:10
    请输入第2个同学的成绩:20
    请输入第3个同学的成绩:30
    请输入第4个同学的成绩:40
    请输入第5个同学的成绩:50
    ********第3个班********
    请输入第1个同学的成绩:20
    请输入第2个同学的成绩:30
    请输入第3个同学的成绩:40
    请输入第4个同学的成绩:50
    请输入第5个同学的成绩:60
    ********成绩统计********
    1班总成绩:350
    2班总成绩:150
    3班总成绩:200
    Process finished with exit code 0
    ​

    本人小白一个,尚在努力学习中,想交流学习心得、看更多每日学习小文章,可关注我的微信公众号【Java菜鸟的进阶之路】一起交流成长!

    文章链接:

    Java中关于二维数组的理解与使用​mp.weixin.qq.com
    a358b6343e2695822f0ac6e1b4f1da15.png
    展开全文
  • 原二维数组 稀疏数组 package ShangGuiGu.sparseArray;...import java.io.*; public class SparseArrayTest { /** * 将稀疏数组存盘 * @param sparseArray */ public static void saveToFile(int[][] spar...

    原二维数组
    在这里插入图片描述
    稀疏数组
    在这里插入图片描述

    package ShangGuiGu.sparseArray;
    
    import java.io.*;
    
    public class SparseArrayTest {
    
        /**
         * 将稀疏数组存盘
         * @param sparseArray
         */
        public static void saveToFile(int[][] sparseArray){
            FileWriter fileWriter=null;
            try {
                fileWriter= new FileWriter(new File("D:\\sparseArray.data"));
                for (int[] array : sparseArray) {
                    fileWriter.write(array[0]+"\t"+array[1]+"\t"+array[2]);
                    fileWriter.write("\r\n");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 从磁盘中读取稀疏数组
         * @return
         */
        public static int[][] readFromFile(){
            int[][] sparseArray2=null;
            boolean isNotRead=false;
            BufferedReader bufferedReader=null;
            try {
                bufferedReader=new BufferedReader(new FileReader(new File("D:\\sparseArray.data")));
                String lineStr=null;
                int curCount=0;
                while ((lineStr=bufferedReader.readLine())!=null){
                    String[] tempStr=lineStr.split("\t");
                    if(!isNotRead){
                        sparseArray2=new int[Integer.parseInt(tempStr[2])+1][3];
                        sparseArray2[curCount][0]=Integer.parseInt(tempStr[0]);
                        sparseArray2[curCount][1]=Integer.parseInt(tempStr[1]);
                        sparseArray2[curCount][2]=Integer.parseInt(tempStr[2]);
                        curCount++;
                        isNotRead=true;
                    }else {
                        sparseArray2[curCount][0]=Integer.parseInt(tempStr[0]);
                        sparseArray2[curCount][1]=Integer.parseInt(tempStr[1]);
                        sparseArray2[curCount][2]=Integer.parseInt(tempStr[2]);
                        curCount++;
                    }
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return sparseArray2;
        }
    
        public static void main(String[] args) {
            int row=8,column=8;
            int[][] sourceArray=new int[row][column];
            sourceArray[1][2]=5;
            sourceArray[1][3]=4;
            sourceArray[2][5]=1;
            sourceArray[2][7]=4;
            sourceArray[7][1]=9;
            //遍历原二维数组
            System.out.println("----------原二维数组如下-----------");
            int count=0;
            for (int[] array : sourceArray) {
                for (int i = 0; i <array.length ; i++) {
                    System.out.printf("%d  ",array[i]);
                    if (array[i]>0){
                        count++;
                    }
                }
                System.out.println();
            }
            int[][] sparseArray=new int[count+1][3];
            sparseArray[0][0]=row;
            sparseArray[0][1]=column;
            sparseArray[0][2]=count;
            //转为稀疏数组
            System.out.println("------------稀疏数组如下------------");
            int cur=0;
            for (int i = 0; i < row; i++) {
                for (int j = 0; j < column; j++) {
                    if(sourceArray[i][j]>0){
                        cur++;
                        sparseArray[cur][0]=i;
                        sparseArray[cur][1]=j;
                        sparseArray[cur][2]=sourceArray[i][j];
                    }
                }
            }
            //遍历稀疏数组
            for (int[] array : sparseArray) {
                System.out.printf("%d %d %d\n",array[0],array[1],array[2]);
            }
    
            /**
            * 将稀疏数组存盘
            */
            saveToFile(sparseArray);
            /**
             *从磁盘中读取稀疏数组
             */
            int[][] sparseArray2=readFromFile();
    
            //转化为二维数组
            int row2=sparseArray2[0][0];
            int column2=sparseArray2[0][1];
            int[][] sourceArray2=new int[row2][column2];
            for (int i = 1; i < sparseArray2.length; i++) {
                sourceArray2[sparseArray2[i][0]][sparseArray2[i][1]]=sparseArray2[i][2];
            }
            //遍历二维数组
            System.out.println("-----------原二维数组如下-----------");
            for (int[] array : sourceArray2) {
                for (int i = 0; i <array.length ; i++) {
                    System.out.printf("%d  ",array[i]);
                    if (array[i]>0){
                        count++;
                    }
                }
                System.out.println();
            }
    
    
    
        }
    }
    

    运行结果如下
    在这里插入图片描述

    展开全文
  • Java中将JSON字符串数组存入MongoDB 使用inserMany()直接批量插入JSON字符串数组时,需要将JSON字符串数组转换成BasicBSONList 或者 BasicDBList 类型的集合,然后使用循环遍历将集合中的对象转成Document 类型,另...

    Java中将JSON字符串数组存入MongoDB

    • 使用inserMany()直接批量插入JSON字符串数组时,需要将JSON字符串数组转换成BasicBSONList或者BasicDBList 类型的集合,然后使用循环遍历将集合中的对象转成Document类型,另存入一个list,然后把该list传入inserMany()方法即可。
    		MongoCollection collection1= MongoDButils.getCollection("admin","userinfo");
            //存有三个对象的JSON格式的list
            String json="[{\"uid\":1,\"sn\":\"123456\",\"password\":\"123456\",\"status\":0},
     					{\"uid\":1,\"sn\":\"123456\",\"password\":\"123456\",\"status\":0},	
     					{\"uid\":1,\"sn\":\"123456\",\"password\":\"123456\",\"status\":0}]";
            BasicBSONList dblist= (BasicBSONList) JSON.parse(json);
            List<Document> list1= new ArrayList<>();
            Iterator it1=dblist.iterator();
            while (it1.hasNext()) {
                //将 BasicBSONList 中的JSON转成 Document 类型放入新的list
                Document dc=new Document((Map<String, Object>) it1.next());
                list1.add(dc);
            }
            collection1.insertMany(list1);
    
    展开全文
  • 数组写入写出文件 将数组写入写出文件 将数组写入文件 读取文件到数组
  • Operation类构造数组Data[],Data的元素可以实例化为不同的类型 package train; class Data<T>{//泛型类,可以实例化各种类型的对象 private T data; public Data(T data){ this.setData(data); } ...
  • java数组

    千次阅读 2019-07-18 20:59:36
    java数组 数组是什么呢? 数组是一种最简单的复合数据类型,它是有序数据的集合,数组中的每个元素具有相同的数据类型,可以用一个统一的数组名和不同的下标来唯一确定数组中的元素。根据数组的维度,可以将其分为一...
  • Java数组的定义及常用方法

    万次阅读 2021-01-23 16:14:24
    数组:一组相同类型的数据集合,长度固定 方式1: 先声明数组(定义数组):尚未开辟内存空间 再创建数组:在内存中,根据数组长度,开辟一块"连续"的内存空间,并完成初始化(默认值) 数据类型 默认值 整数 0 ...
  • Java 语言是典型的静态语言,因此 Java 数组是静态的,即当数组被初始化之后,该数组 所占的内存空间、数组长度都是不可变的。Java 程序中的数组必须经过初始化才可使用。所谓初始化,即创建实际的数组对象,也就是...
  • 1.Java数组是静态的 Java是静态语言,所以Java的数组也是静态的,即:数组被初始化后,长度不可变 静态初始化:显式指定每个数组元素的初始值,系统决定数组长度 String[] books = new String[]{"疯狂Java讲义",...
  • JAVA实现将数组存入二叉树中

    千次阅读 2016-09-07 14:21:09
    在工作中,当我们面临在使用内存存储数据的时候,只使用hashmap存储,可能...下面一起来看看,如何用java实现二叉树的存储结构,下面只是一个简单的例子,如果读者需要使用复杂的结构的话,可以按自己的需要自行实现;
  • Java 数组缩容

    2021-05-29 15:36:07
    // 数组扩容,数组一旦被创建不可被改变 // 若要缩容则需要新建数组 Scanner scanner = new Scanner(System.in); System.out.println("数据缩容:"); System.out.println("请先输入五个数字"); int[] num = ...
  • package practice; public class ElementExtraction { public static void main(String[] args) { ... System.out.println("数组元素:"); int qualify = 0; // 统计合格数字个数的累加变量 for (int i = 0; i
  • Java有序数组插入数据的三种方法

    千次阅读 2019-01-13 11:23:59
    Java中的数组比起C的数组还是比较方便的,做边界检测不会那么麻烦。 现在整理一下Java中有序(假设是从小到大)数组插入数据的三种方式,其中一种方式是直接调用static方法——Arrays.sort(数组名); 另外两种方法比较...
  • Java 中对象数组的简单存入与取出

    千次阅读 2019-11-14 10:49:52
    最近在写将画出来的几个图形存入对象数组中,然后通过滑杆调节图形大小,通过逐个读取数组重绘图形。 先建一个图形类,图形的属性有起始坐标 x,y,以及宽和高w,h,以及图形的名字name: public class picSave { ...
  • 第一种:方式:最开始想到的是利用Set集合的不可重复性进行元素过滤 public static Object[] oneClear(Object[] arr...第二种:方式:要想保持原数组的顺序就使用有顺序、不重复特点的链表的哈希集合 public static Obje
  • java数组中重复元素的去重方式①数组转集合转数组偷懒的方法方式②创建一个临时数组存放去重后的数组 方式① 数组转集合转数组 方式一,我们就先说最简单,最常用的,数组 转 集合 转 数组 public static void main...
  • 1、将数组包保存到磁盘文件中: private static void intDataToFileOut(int[][] sparseArray, File file) { FileWriter out = null; try { ... //二维数组按行存入到文件中 for (int i = 0; i <
  • Java数组的遍历与求和

    万次阅读 2017-05-28 14:05:10
    java求二维数组之和
  • package practice; public class IntervalInterception { public static void main(String[] args) { int arr[] = { 1, 3, 14, 5, -1, -5, 16, 6, -8, 5, 4, 7, -6, -7, 12, 5 }; int first = 0;...
  • 最近无意中看到一个问题,提到循环数组时,是否在循环体中使用length会影响时间复杂度。由于看了没保存,现在找不到在哪了,大概意思就如下面的代码。只记得这个问题是基于C语言提出的,所以我很好奇java语言中,...
  • java再体验之键盘输入,数组 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本语法知识。 新的...
  • Java 数组 与 循环遍历

    千次阅读 2017-09-20 16:27:48
    Java 数组 与 循环遍历
  • java数组中存储对象

    千次阅读 2020-03-18 11:19:01
    java数组中存储对象 /*一、数组描述 在现实世界中,数组并不仅仅可以存储像我们以前所描述的基础数据类型,它还可以存储对象(当然,在Java语言中实际存储的是对象的引用。)下图描述了数组存储对象的原理: */...
  • Java数组去重的多种方法

    万次阅读 2017-08-22 21:02:45
    /* 数组去重 1:遍历数组,将元素依次添加进结果集中,如果结果集中已经存在,则不再...3:先将原数组排序,在与相邻的进行比较,如果不同则存入数组 4:利用HashSet集合无序不可重复的特性进行元素过滤 5:TreeSe
  • Java 数组元素倒序的三种方式

    千次阅读 2018-12-14 10:18:04
    数组元素反转有多种实现方式,这里介绍常见的三种. 直接数组元素对换 @Test public void testReverseSelf() throws Exception { System.out.println("use ReverseSelf"); String[] strings = { &...
  • Java数据存储——数组

    2020-10-28 21:04:12
    Java数据存储——数组 需要明确容器的长度 int[] b = new int[2]; int [] b = new int[]{0,2,4}; 多维数组的创建 inta[][] = new int [2][3];//规则多维数组 int a[][] new int [2][];//不规则多维数组 数组的...
  • import java.util.ArrayList; import java.util.List; public class ElementTransfer { public static void main(String[] args) { /** * 方法一 */ int[] oldArr = { 1, 3, 4, 5, 0, 0, 6, 6, 0, 5...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,865
精华内容 37,946
关键字:

java数组存入数组

java 订阅