精华内容
下载资源
问答
  • java 多维数组遍历

    2015-10-27 14:18:00
    java 多维数组遍历顺序的性能问题 ps:下图为java多维数组内存分布原理。出自:http://math.hws.edu/javanotes/c7/two-dimensional-array.png 出自:http://www.importnew.com/16742.html 转载于:...

    java 多维数组遍历的顺序的性能问题

    ps:下图为java多维数组内存分布原理。出自:http://math.hws.edu/javanotes/c7/two-dimensional-array.png

     

    出自:http://www.importnew.com/16742.html

     

    转载于:https://www.cnblogs.com/xxyfhjl/p/4914086.html

    展开全文
  • java数组遍历的三种方式

    千次阅读 2020-11-08 02:36:36
    1.for循环遍历 通常遍历数组都是使用for循环来...java5之后,Java提供了一种更简洁的循环:foreach循环,这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组时,无须获得数组和集合长度,无须根据索引来访问数组

    题目描述

    给一个数组:

     int Arr[][]={{5,7,15},{8,4,11},{3,6,13}};
    

    使用显示数组 for,for-each,和toString

    1.for循环遍历

    通常遍历数组都是使用for循环来实现。遍历一维数组很简单,遍历二维数组需要使用双层for循环,通过数组的length属性可获得数组的长度。

    程序:

    package 数组;
    public class for遍历二维数组 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int Arr[][]={{5,7,15},{8,4,11},{3,6,13}};
    		for (int i = 0; i < Arr.length; i++) {
    			for (int j = 0; j < Arr[i].length; j++) {
    				System.out.print(Arr[i][j]+" ");
    			}
    		}
    	}
    }
    
    

    运行结果:

    5 7 15 8 4 11 3 6 13

    for循环本质就是把数组中的每个数据打印出来。

    2.foreach语句遍历

    遍历数组就是获取数组的每个元素。通常遍历数组都是使用for循环来实现的,但是for循环不够简洁,下面我们简要介绍一下使用foreach语句来实现遍历数组的方法。
    java5之后,Java提供了一种更简洁的循环:foreach循环,这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组时,无须获得数组和集合长度,无须根据索(下标)引来访问数组元素,foreach循环自动遍历数组和集合的每一个元素。

    语法格式:

    for(type element: array)
    {
        System.out.println(element);
    }
    

    注:

    foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。foreach 语句用于循环访问集合以获取所需信息,但不应用于更改集合内容以避免产生不可预知的副作用。
    因此不要对foreach的循环变量赋值。
    例如:

    public static void main(String [] args){
    int [] arr={1,2,3,4,5};
           for(int a:arr){
                a=0;
                System.out.print(a);
           }
           System.out.print(“\n”+a[0]);
    }
    

    运行结果:

    00000
    1

    从上面结果可以看出,由于在foreach循环中对数组进行赋值,结果导致不能正确遍历数组元素。而且当再次访问第一个数组元素时,发现数组元素依然没有改变。

    程序:

    package 数组;
    public class foreach遍历二维数组 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int Arr[][]= {{5,7,15},{8,4,11},{3,6,13}};
    		System.out.println("数组中的元素是 ");
    		int i=0;
    		for(int x[]: Arr) {//行
    			i++;
    			int j=0;
    			for(int e:x) {//列
    				j++;
    				if(i==Arr.length&&j==x.length) {
    					System.out.print(e);//输出最后一个元素,后面不加逗号
    				}else
    					System.out.print(e+"、");
    			}
    			
    		}		
    	}
    }
    

    运行结果:

    数组中的元素是
    5、7、15、8、4、11、3、6、13

    3.Arrays工具类中toString静态方法遍历

    利用Arrays工具类中的toString静态方法可以将一维数组转化为字符串形式并输出。
    已知打印一维数组的API为System.out.println ( Arrays.toString ();,其参数为数组名或数组指针,其支持的数据类型有很多,如:int[]、char[]、byte[]等。

    3.1.程序:

    package 数组;
    
    import java.util.Arrays;
    
    public class toString遍历二维数组 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int Arr[][]={{5,7,15},{8,4,11},{3,6,13}};
    	    System.out.println("Arr:"+Arrays.toString(Arr));
    	    int b[][]={{5,7,15},{8,4,11},{3,6,13}};
    	    System.out.println("Arr:"+Arrays.deepToString(b));
    	}
    }
    

    运行结果:

    Arr:[[I@15db9742, [I@6d06d69c, [I@7852e922]
    Arr:[[5, 7, 15], [8, 4,11], [3, 6, 13]]

    注释:

    注: *Arr:[[I@15db9742, [I@6d06d69c, [I@7852e922]*	
    这种输出结果是因为:Arr是一个二维数组。相当于一个长度为3的数组,但是这个数组的元素还是是数组。
    当执行Arrays.toString的时候相当于遍历数组,并且输出数组的元素,但是这个数组的元素是数组,所以这里输出的是数组元素的地址。
    

    3.2.Arrays.deepToString()与Arrays.toString()的区别

    • Arrays.deepToString()主要用于数组中还有数组的情况,而Arrays.toString()则相反,对于Arrays.toString()而言,当数组中有数组时,不会打印出数组中的内容,只会以地址的形式打印出来。

    - 示例:

    public class test {
    
      public static void main(String[] args) {
    
          int a[] = {1, 2, 3};
          System.out.println(Arrays.toString(a));
          int b[][] = {{1, 2, 3}, {4, 5, 6}};
          System.out.println(Arrays.toString(b));
          System.out.println(Arrays.deepToString(b));
      }
    }
    

    - 结果:

    [1, 2, 3]
    [[I@14ae5a5, [I@7f31245a]
    [[1, 2, 3], [4, 5, 6]]

    3.3.Arrays 类

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

    具有以下功能:

    1. 给数组赋值:通过 fill 方法。
    2. 对数组排序:通过 sort 方法,按升序。
    3. 比较数组:通过 equals 方法比较数组中元素值是否相等。
    4. 查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
      具体说明请查看下表:
    序号 方法和说明
    1 ***public static int binarySearch(Object[] a, Object key)***用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
    2 ***public static boolean equals(long[] a, long[] a2)***如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
    3 ***public static void fill(int[] a, int val)***将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
    4 ***public static void sort(Object[] a)***对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。

    3.4. Java中对Array数组的常用操作

    示例:

    import java.util.*;
    public class ArrayPrint {
    	
    	public static void main(String[] args){
        //声明数组
        String [] arr;
        int arr1[];
          
        //初始化数组
        int arr2[]=new int[]{1,2,3,4,5};
        String[] array1={"马超","马云","关羽","刘备","张飞"};
        String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};      
        String[] array=new String[5];
           
        //查看数组的长度
        int length=array1.length;
        System.out.println("length:  "+array1.length);
          
        //输出数组
        System.out.println(array1);     //结果:[Ljava.lang.String;@32f22097
        System.out.println("arr2:  "+Arrays.toString(arr2));
          
        //遍历数组
        for (int i = 0; i < array1.length; i++) {
        	     System.out.println(array1[i]);
        }
        
        //int数组转成string数组
        int[]  array3={1,2,3,4,5,6,7,8,9,0};
        String arrStrings=Arrays.toString(array3);
        System.out.println("arrStrings:"+arrStrings);
          
        //从array中创建arraylist
        ArrayList <String> arrayList=new ArrayList<String>(Arrays.asList(array1));
        System.out.println("arrayList:"+arrayList);
          
        //数组中是否包含某一个值
        String a="马超";
        if (Arrays.asList(array1).contains(a)) {
            System.out.println("马超在这里");
        }
          
        //将数组转成set集合
        Set<String> set=new HashSet<String>(Arrays.asList(array2));
        System.out.println("set:"+set);
          
        //将数组转成list集合
        List<String> list_1=new ArrayList<String>();
        for (int i = 0; i < array2.length; i++) {
            list_1.add(array2[i]);
        }
        System.out.println("list_1:"+list_1);
        
        String[] arrStrings2={"1","2","3"};
        List<String > list2=Arrays.asList(arrStrings2);
        System.out.println("list2:"+list2);
          
          
        //Arrays.fill()填充数组
        int[] arr3=new int[5];
        Arrays.fill(arr3, 10);  //将数组全部填充10
        System.out.println("arr3:"+arr3);
        for (int i = 0; i < arr3.length; i++) {
            System.out.println("arr3[i]:"+arr3[i]);
        }
          
        //数组排序
        int[] arr4 = {3, 7, 2, 1, 9};
        Arrays.sort(arr4);
        System.out.println("arr4:"+arr4);
        for (int i = 0; i < arr4.length; i++) {
            System.out.println("arr4[i]:"+arr4[i]);
        }
          
        int[] arr5 = {3, 7, 2, 1, 9,3,45,7,8,8,3,2,65,34,5};
        Arrays.sort(arr5, 1, 4);  //从第几个到第几个之间的进行排序
        for (int i = 0; i < arr5.length; i++) {
            System.out.println("arr5[i]:"+arr5[i]);
        }
          
          
        //复制数组
        int[] arr6 = {3, 7, 2, 1};
        int[] arr7=Arrays.copyOf(arr6, 10);  //指定新数组的长度
          
        int[] arr8=Arrays.copyOfRange(arr6, 1, 3); //只复制从索引[1]到索引[3]之间的元素(不包括索引[3]的元素)
        for (int i = 0; i < arr8.length; i++) {
            System.out.println(arr8[i]);
        }
          
        //比较两个数组
        int[] arr9 = {1, 2, 3, 4,5,6,7,8,9,0};
        boolean arr10=Arrays.equals(arr6, arr9);
        System.out.println(arr10);
      
        //去重复
        //利用set的特性
        int[] arr11 = {1, 2, 3, 4,5,6,7,8,9,0,3,2,4,5,6,7,4,32,2,1,1,4,6,3};
        Set<Integer> set2=new HashSet<Integer>();
        for (int i = 0; i < arr11.length; i++) {
            set2.add(arr11[i]);
        }
            System.out.println(set2);
        int[] arr12 = new int[set2.size()];
        int j=0;
        for (Integer i:set2) {
            arr12[j++]=i;
        }
        System.out.println(Arrays.toString(arr12));
    }
    }
    
    

    打印结果:

    打印结果:
    length:  5
    [Ljava.lang.String;@7852e922
    arr2:  [1, 2, 3, 4, 5]
    马超
    马云
    关羽
    刘备
    张飞
    arrStrings:[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
    arrayList:[马超, 马云, 关羽, 刘备, 张飞]
    马超在这里
    set:[小猪, 牙哥, 黄渤, 黄磊, 孙红雷, 张艺兴]
    list_1:[黄渤, 张艺兴, 孙红雷, 小猪, 牙哥, 黄磊]
    list2:[1, 2, 3]
    arr3:[I@4e25154f
    arr3[i]:10
    arr3[i]:10
    arr3[i]:10
    arr3[i]:10
    arr3[i]:10
    arr4:[I@70dea4e
    arr4[i]:1
    arr4[i]:2
    arr4[i]:3
    arr4[i]:7
    arr4[i]:9
    arr5[i]:3
    arr5[i]:1
    arr5[i]:2
    arr5[i]:7
    arr5[i]:9
    arr5[i]:3
    arr5[i]:45
    arr5[i]:7
    arr5[i]:8
    arr5[i]:8
    arr5[i]:3
    arr5[i]:2
    arr5[i]:65
    arr5[i]:34
    arr5[i]:5
    7
    2
    false
    [0, 32, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    [0, 32, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    
    
    展开全文
  • 增强for循环实现数组遍历代码: package cn.tedu.demo; public class Demo { //增强for循环实现数组遍历 public static void main(String[] args) { int[] ages = new int[]{1,4,2,45,0}; for(int a : ages){ ...

    增强for循环实现数组遍历代码:
    package cn.tedu.demo;
    public class Demo {
    //增强for循环实现数组遍历
    public static void main(String[] args) {
    int[] ages = new int[]{1,4,2,45,0};
    for(int a : ages){
    System.out.print("–>"+a);
    }
    }
    }
    输出:–>1–>4–>2–>45–>0

    增强for循环实现数组遍历图:
    在这里插入图片描述

    展开全文
  • Java 多维数组遍历

    千次阅读 2016-07-18 23:22:43
    数组Java中的一种容器对象,它拥有多个单一类型的值。当数组被创建的时候数组长度就已经确定了。在创建之后,其长度是固定的。下面是一个长度为10的数组: 1 2 3 4 public ...

    多维数组

    数组是Java中的一种容器对象,它拥有多个单一类型的值。当数组被创建的时候数组长度就已经确定了。在创建之后,其长度是固定的。下面是一个长度为10的数组:

    1
    2
    3
    4
    public class ArrayDemo {
        private int arraySize=10;
        public int[] arrayOfIntegers = new int[arraySize];
    }

    上面的代码是一维数组的例子。换句话说,数组长度只能在一个方向上增长。很多时候我们需要数组在多个维度上增长。这种数组我们称之为多维数组。为简单起见,我们将它称为2维数组。当我们需要一个矩阵或者X-Y坐标系的时候,二维数组是非常有用的。下面就是一个二维数组的例子:

    1
    2
    3
    4
    5
    6
    public class TheProblemOf2DArray {
        private static final int ARR_SIZE=10;
        public static void main(String[] args) {
            int arr[][]=new int[ARR_SIZE][ARR_SIZE];
        }
    }

    想象一下,一个二维数组看起来就像一个X-Y坐标系的矩阵

    然而,可能让Java开发者们感到惊讶的是,Java实际上并没有二维数组。

    在一个真正的数组中,所有的元素在内存中都存放在连续的内存块中,但是在Java的二维数组并不是这样。Java中所有一维数组中的元素占据了相邻的内存位置,因此是一个真正的数组。

    在Java中,当我们定义:

    1
    2
    3
    int singleElement // 表示一个int变量
    int[] singleDArray // 表示一个int变量数组(一维)
    int[][] twoDArray // 表示一个int变量数组的数组(二维)

    这意味着,在上面的例子中,二维数组是一个数组的引用,其每一个元素都是另一个int数组的引用。

    这张图片清楚解释了这个概念。

    由于二维数组分散在存储器中,所以对性能有一些影响。为了分析这种差异,我写了一个简单的Java程序,显示遍历顺序的重要性

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    package arrayTraverse;
    /**
     * 二维数组的问题
     *
     * 我们在初始化一个任意大小的2维数组。(为简化分析我们使用二维方阵)我们将用两种不同方式迭代同一个数组,分析结果
     * 两种迭代方式的性能差距很大
     * @author mohit
     *
     */
    public class TheProblemOf2DArray {
        //数组大小:数组越大,性能差距越明显
        private static final int ARR_SIZE=9999;
        public static void main(String[] args) {
            //新数组
            int arr[][]=new int[ARR_SIZE][ARR_SIZE];
            long currTime=System.currentTimeMillis();
            colMajor(arr);
            System.out.println("Total time in colMajor : "+(System.currentTimeMillis()-currTime)+" ms");
            //新数组,与arr完全相同
            int arr1[][]=new int[ARR_SIZE][ARR_SIZE];
            currTime=System.currentTimeMillis();
            rowMajor(arr1); // this is the only difference in above
            System.out.println("Total time in col : "+(System.currentTimeMillis()-currTime) +" ms");
        }
     
        /**
         * 下面的代码按列为主遍历数组
         * 即在扫描下一行之前先扫描完本行
         *
         */
        private static void colMajor(int arr[][]) {
            for(int i=0;i<ARR_SIZE;i++){
                for (int j=0;j<ARR_SIZE;j++){
                    //See this, we are traversing j first and then i
                    arr[i][j]=i+j;
                }
            }
        }
     
        /**
         * 如果我们转换内外循环
         * 程序就以行为主顺序遍历数组
         * 即在扫描下一列之前先扫描完本列
         * 这意味着我们访问数组时每次都在访问不同的行(因此也在访问不同的页)
         * 代码微小的改变将导致这个程序花费更多的时间完成遍历
         */
        private static void rowMajor(int arr[][]) {
            for(int i=0;i<ARR_SIZE;i++){
                for (int j=0;j<ARR_SIZE;j++){
                /*看这个,我们先遍历j,然后遍历i,但是对于访问元素来说
                 * 它们在更远的位置,所以需要花费的更多
                 */
                arr[j][i]=i+j;
                }
            }
        }
    }

    下面是示例的结果:

    重复上面的例子,它始终给出类似的结果,不过时间差可能会有所不同。

    原文链接: dzone 翻译: ImportNew.com LynnShaw

    译文链接: http://www.importnew.com/16742.html


    本文由 ImportNew - LynnShaw 翻译自 dzone

    展开全文
  • 数组的一些特性java数组要求所有的元素具有相同的数据类型,因此一个数组只能存储一种数据类型的数据,而不能存储多种数据类型的数据。比如你这个数组是int类型的数组,那这个数组就不能存储boolean float...
  • Java多维数组遍历

    2015-10-01 00:24:56
    数组Java中的一种容器对象,它拥有多个单一类型的值。当数组被创建的时候数组长度就已经确定了。在创建之后,其长度是固定的。下面是一个长度为10的数组: public class ArrayDemo { private int arraySize=10; ...
  • 学习Java的同学注意了!!! 学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入Java学习交流群,群号码:456544752 我们一起学Java数组Java中的一种容...
  • java多维数组遍历

    2015-10-05 12:56:22
    数组Java中的一种容器对象,它拥有多个单一类型的值。当数组被创建的时候数组长度就已经确定了。在创建之后,其长度是固定的。下面是一个长度为10的数组: 1 2 3 4 public ...
  • 5.二维数组遍历 二、数组排序 1.冒泡排序 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。 走访...
  • 二维数组是一个数组的引用,其每一个元素都是另一个int数组的引用。一个二维数组看起来就像一个X-Y坐标系的矩阵。也可以称为矩阵。   由于二维数组分散在存储器中,所以对性能有一些影响。测试程序: 1 2...
  • 数组遍历代码

    2020-11-09 19:23:19
    public class jaChu { public static void main(String[] args) { //顺序是从零开始数的 int[] a ={1,2,3,4,5,6,7,8};...//遍历数组,记得是length-1. for (int i = 0; i <= a.length-1; i++) { Sys
  • (三)数组(一)数组的概述定义数组(Array),是多个相同类型数据一定顺序排列 的集合,并使用一个名字命名,并通过编号的方式 对这些数据进行统一管理。数组相关概念:数组名 下标(或索引) 元素 数组的长度数组特点...
  • 遍历循环中执行顺序问题 **问题描述:**要求输出正确工资条(对象字段的toString方法),但因 执行顺序问题导致salary字段未能成功被赋值(为初始值0)。 1.1. 错误顺序:先输出staff2对象(toString),再执行...
  • java二维数组遍历与元素查找

    千次阅读 2018-03-06 22:00:36
    java二维数组 格式 数据类型 [ ][ ] arrayName = new 数据类型[一维数组的个数][每个一维数组的长度] 例如: int [ ][ ] array = new int [2][3]; int [ ][ ] arr = {{2,3,4},{4,5,6}} 属性方法 二维数组的...
  • for循环传统方法数组遍历 一维数组: int[] array = {1,2,3}; for(int i=0;i&amp;amp;amp;lt;array.length;i++){ System.out.print(array[i]); } 二维数组: int[][] array = {{1,2,3},{4,5...
  • 数组和枚举,创建数组,遍历数组,排序,二分法查找**数组是相同类型变量按顺序组成的一种复合数据类型**,称这些相同的变量为数组的元素或单元。数组通过数组名加索引来使用数组的元素。 **数组属于引用型变量**,创建...
  • 数组是一组顺序存储的同一类型的固定数据结构,每个Java数组都包含一个length的变量,用来存数组的当前大小。 数组的作用:可以一下定义多个相同类型的变量,存多个值。 定义数组用 [] 标识,数组变量的缺省值是...
  • 事实上,广义上来讲,PHP就是C语言应用在Web上的一个模板,PHP中smarty模板用得比较多,就好比JSP是Java ...PHP使用了一些机制, 使得可以在O(1)的时间复杂度下实现数组的增删, 并同时支持线性遍历和随机访问。 P...
  • 数组:是多个相同类型数据一定顺序排列的集合,并使用一个名字命名,并通过编号的方式对这些数据进行统一的管理。 数组的常见概念 数组名 下标(或索引或角标) 元素 数组的长度 数组的特点 数组是有序排列的 ...
  • 二维数组回形遍历java

    2020-06-10 14:36:55
    给定一个 rowrow 行 colcol 列的整数数组 array,要求从 array[0][0] 元素开始,回形从外向内顺时针顺序遍历整个数组 输入描述 输入的第一行上有两个整数,依次为 rowrow 和 colcol。 余下有 rowrow 行,每行包含 ...
  • Java数组遍历数组

    2017-07-31 21:32:24
    分配空间时是连续的空间,按顺序 声明一个数组就是在内存空间划出一串连续的空间 数组名,即标识符,是连续空间的首地址 元素下标标明了元素在数组中的位置,从0开始 数组中的每个元素都可以通过下标来访问 ...
  • 【LeetCode 0-Start】[数组]特定顺序遍历二维数组 文章目录前言一、[中等]54. 螺旋矩阵java代码二、[中等]59. 螺旋矩阵 IIjava代码三、[中等]498. 对角线遍历java代码 前言 特定顺序遍历二维数组 题目序号: 54、...
  • public class shuzu { public static void main(String[] args) { // TODO Auto-generated method stub int [] a = {2,0,2,0}; int i = 0; System.out.print("["); for (i=0;... System.out.prin
  • 示例:数组的遍历 class ArrayDemo ... //数组遍历 public static void main(String[] args) { //int[] arr = new int[3]; int[] arr = new int[]{1,2,6,4,7,8,3}; for (int x=0;x;x++ ) {

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,070
精华内容 58,428
关键字:

数组遍历按顺序java

java 订阅