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

    2020-11-26 21:33:58
    List数组遍历删除 环境 jdk8 junit 单元测试 正解 // 正解1, jdk自带的addAll方法 @Test public void test18() { String[] strs = {"12","34","56","78","90"}; List<String> list = Arrays.asList...

    List数组遍历删除

    环境

    • jdk8
    • junit 单元测试

    正解

    // 正解1, jdk自带的addAll方法
    	@Test
        public void test18() {
            String[] strs = {"12","34","56","78","90"};
            List<String> list = Arrays.asList(strs);
            List<String> list2 = new ArrayList<>();
            list2.addAll(list);
            System.out.println(list);
            for (String s : list) {
                System.out.println(s);
                list2.remove(s);
            }
        }
    
    // 正解2 Hutool的 CollUtil 工具类中addAll方法
    	@Test
        public void test18() {
            String[] strs = {"12","34","56","78","90"};
            List<String> list = Arrays.asList(strs);
            List<String> list2 = new ArrayList<>();
            CollUtil.addAll(list2,list);
            System.out.println(list2);
            for (String s : list) {
                System.out.println(s);
                list2.remove(s);
            }
    	}
    
    boolean b = list1.removeIf(a -> (a % 2) == 0);
            System.out.println(b);
    

    错解

    新手代码踩坑日记

    // 第一错
    	@Test
    	public void test18() {
    	     String[] strs = {"12","34","56","78","90"};
    	     List<String> list = Arrays.asList(strs);
    	     System.out.println(list);
    	     for (String s : list) {
    	         System.out.println(s);
    	         list.remove(s);
    	     }
    	}
    
    报错信息:
    
    [12, 34, 56, 78, 90]
    12
    
    java.lang.UnsupportedOperationException  不支持的操作异常
    	at java.util.AbstractList.remove(AbstractList.java:161)
    	at java.util.AbstractList$Itr.remove(AbstractList.java:374)
    	at java.util.AbstractCollection.remove(AbstractCollection.java:293)
    
    
    // 第二错 : 老子新建个对象来存还是错??? 仔细想想-->TMD谁写的垃圾代码,好像是我写的...
    // 方法栈里面就一个list对象,只是复制一份引用,而remove是直接操作数组内存空间
     	@Test
        public void test18() {
            String[] strs = {"12","34","56","78","90"};
            List<String> list = Arrays.asList(strs);
            List<String> list2 = new ArrayList<>();
            list2 = list;
            System.out.println(list);
            for (String s : list) {
                System.out.println(s);
                list2.remove(s);
            }
        }
    
    直接报错 +1:
    [12, 34, 56, 78, 90]
    12
    
    java.lang.UnsupportedOperationException
    	at java.util.AbstractList.remove(AbstractList.java:161)
    	at java.util.AbstractList$Itr.remove(AbstractList.java:374)
    	at java.util.AbstractCollection.remove(AbstractCollection.java:293)
    
    
    展开全文
  • import java.util.ArrayList; import java.util.Iterator;...import java.util.List; public class ArrayTest {  public static void main(String[] args)  {  List lstint = new ArrayList();  lstint.ad

    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;

    public class ArrayTest
    {
     public static void main(String[] args)
     {


      List<Integer> lstint = new ArrayList<Integer>();
      lstint.add(1);
      lstint.add(2);
      lstint.add(3);

     

      // Iterator遍历一
      Iterator<Integer> iterator = lstint.iterator();
      while (iterator.hasNext())
      {
       int i = (Integer) iterator.next();
       System.out.println(i);
      }

     

      // Iterator遍历二
      for (Iterator<Integer> it = lstint.iterator(); it.hasNext();)
      {
       int i = (Integer) it.next();
       System.out.println(i);
      }

     

      // for循环
      for (int i = 0; i < lstint.size(); i++)
      {
       System.out.println(lstint.get(i));
      }

     

      // for循环加强版
      for (Integer i : lstint)
      {
       System.out.println(i);
      }


     }


    }

    展开全文
  • 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]
    
    
    
    展开全文
  • import java.util.ArrayList; import java.util.Iterator;...import java.util.List; public class ArrayTest { public static void main(String[] args) { List lstint = new ArrayList(); lstint.add(1); l
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class ArrayTest {
    	public static void main(String[] args) {
    
    		List<Integer> lstint = new ArrayList<Integer>();
    		lstint.add(1);
    		lstint.add(2);
    		lstint.add(3);
    
    		// Iterator遍历一
    		Iterator<Integer> iterator = lstint.iterator();
    		while (iterator.hasNext()) {
    			int i = (Integer) iterator.next();
    			System.out.println(i);
    		}
    
    		System.out.println();
    
    		// Iterator遍历二
    		for (Iterator<Integer> it = lstint.iterator(); it.hasNext();) {
    			int i = (Integer) it.next();
    			System.out.println(i);
    		}
    
    		System.out.println();
    
    		// for循环
    		for (int i = 0; i < lstint.size(); i++) {
    			System.out.println(lstint.get(i));
    		}
    
    		System.out.println();
    
    		// for循环加强版
    		for (Integer i : lstint) {
    			System.out.println(i);
    		}
    
    	}
    
    }

    展开全文
  • Java1.8 新特性之数组遍历 数组判空 Optional.ofNullable(变量).orElse(变量为空时给对象赋的值); 数组遍历 list.forEach(l->{System.out.println(l)}) 相对于传统的for循环去遍历数组,java 1.8新特性更加简洁...
  • java两个数组遍历比较

    2020-08-06 21:24:21
    对于两个数组的比较 情况是这样,这几天写一个echarts图表的时候,需要从数据库中获取,但是由于我使用的是Hibernate,里面不能使用连接join,因此,不能将一对多连接时的另一张表里为0的数据取出来,表主要是一个议案...
  • import java.util.Arrays; /** * @Author Miracle Luna * @Date 2019/6/9 23:33 * @Version 1.0 */public class ArrayLambda { public static void main(String[] args) { Integer[] ite...
  • 集合List数组遍历

    2013-03-19 21:24:48
    import java.util.ArrayList; import java.util.Date;... import java.util.List; import java.util.ListIterator; public class Test { public static void main(String[] args) { List list =
  • Lua – Table(数组遍历) lua并不像其他语言一样提供了Array,List,Set,Queue等各种数据结构来完成各种不同数据操作,相比,lua只提供了一种数据结构 – Table,可谓以不变应万变了。 lua的table可以以整数和字符...
  • Python——二维数组遍历操作

    千次阅读 2020-03-05 17:39:18
    一、遍历数组(操作Value) 1.使用二维列表遍历二维数组 python 创建List二维列表 lists = [[] for i in range(3)] # 创建的是多行三列的二维列表 for i in range(3): lists[0].append(i) for i in range(5): ...
  • java JsonArray数组遍历组成新的json对象 jsonArray1 = [{"checked_id":"10002","content_title":"duo1","content":"du11"},{"checked_id":"10002","content_title":"duo1","content":"du12"},{"checked_id":...
  • 例如这种int[][]={{12,2,3,4},{3,5,6},{4,8}}如何输出数组{12,6,8}
  • Java数组遍历与求和

    万次阅读 2017-05-28 14:05:10
    java求二维数组之和
  • [color=red] Java对集合的遍历 List ArryList HashMap LinkedMap JSON 数组等 收藏 Java 遍历各种数据类型使用总结 [/color][color=green]1. List [/color] List list=new ArrayList(); list.add(); // 添加...
  • for(int i = 0; i < list.size(); i++){ userRoleIds[i] = list.get(i) } for (BuyOrderDetail buyOrderDetail : buyOrderDetails) {}
  • Java遍历List数组

    2021-06-02 19:36:49
    Java如何遍历List数组 1.增强for循环 for(String str : list) {//其内部实质上还是调用了迭代器遍历方式,这种循环方式还有其他限制,不建议使用。 System.out.println(str); } 2.普通for循环 for( int i = 0 ; i ...
  • Java 数组遍历访问(普通循环,增强for循环)普通循环增强 for 循环普通循环和增强 for 循环的区别 普通循环 首先我们要知道数组元素下标的合法区间:[0, length-1](即从0开始到数组长度减一)。我们可以通过下标...
  • java循环遍历数组List,Map

    千次阅读 2017-07-16 19:44:34
     ①循环遍历数组有2中方式,遍历一维数组只需要一个for循环,遍历二维数组需要2个for循环。  public static void main(String[] args) {  String arr[][] = new String[][] { { "a" }, { "a", "b" },{ "a",
  • 这篇文章就当成铺垫型的文章,写着写着发现有好多想写的,,关于C#与Java,当然作为铺垫肯定与Lua的下部分介绍有关..... 对于"泛型",先看C#中"泛型"是一个怎么回事,,,,,我感觉名字起错了,应该叫&...
  • Java数组遍历方式

    千次阅读 2019-03-12 10:11:36
    数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同。 Java 语言中提供的数组是...针对以上数组进行遍历,在java中我们常用到的就是for循环 1、这种方法简单粗暴易使用...
  • Java数组--->遍历数组

    2021-07-29 18:41:16
    Java中对Array数组的常用操作(了解即可) 三种方式: for for-each, toString 题目描述 给一个数组:int Arr={{5,7,15},{8,4,11},{3,6,13}}; for循环遍历 通常遍历数组都是使用f
  • java数组创建与遍历

    千次阅读 2014-04-06 22:43:08
    数组遍历 public class Test { public static void main(String[] args) { String[] people=new String[]{"张三","李四","王五"}; for(String p:people){ System.out.println(p); } } } ...
  • java 二维数组遍历

    2020-03-09 18:00:23
    二维数组遍历 概述:一维数组各元素布局直线状,对应一维坐标;二维数组的元素布局平面状,对应二维坐标,即元素布局若干行和若干列。 动态初始化: 例: int a[][] = new int[2][3]; 静态初始化: 例:int...
  • java-数组/数组遍历/反转/二维数组

    千次阅读 2018-05-07 21:21:57
    数组: 相当于一个容器,存放了一组相同类型的数据(数据必须为同一类型) * 数组存放的规则:是以下标(角标)来存放的,并且下标从0开始 *数组的声明规范:数据类型[] 数组名称 = 初始值;(数据类型指的是数组中存放的...
  • (一)JAVA数组的三种声明方式 第一种方式 动态创建,声明并创建内存空间,等待赋值。 int arr [ ] = new int [5] ; public static void main(String[] args) { int arr[] = new int[5]; //等待赋值,默认为零...
  • Java中关于List数组循环遍历删除元素的方法(删除元素提示数组长度异常的解决方法) 有三种方式:迭代、集合倒叙遍历、普通for循环解决方法。 话不多说,直接上例子吧,例子通俗易懂。 public static void main...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 183,506
精华内容 73,402
关键字:

java数组遍历成list

java 订阅