List常用方法

目录

• list.addAll
• list.subList()
• list.indexOf()
• list.clear()
• list.equals(list2)
• list.isEmpty
• List定义时添加多条数据
• list.remove(i)
• list.contains()
• list转数组
• 检验List是否存在重复的元素
• Stream操作List
  • List取出对象中某一属性
  • List，将id属性逗号拼接
  • List，将id属性逗号拼接后转换为Strnig类型
  • List转换为另一个List
  • List过滤元素
  • List转换为Map
  • List与List差集
  • List与List交集
  • List与List去重并集
  • List求交集

list.addAll

 list.addAll(list);// 向集合追加一个collection，只可追加collection，由于java不提供collection的实现，由它的下级接口来实现
 list.addAll(4, list);// 与上述含义相同， “4”意为追加元素所放的位置

list.subList()

list.subList(1,3)//返回下标从1到3的数据 ，包括左不包括右 即返回下标为1,2的数据

list.indexOf()

//在集合中查找元素 ，"a"如果有 ,返回所查找元素的下标,如果不存在则返回-1
  list.indexOf("a");

list.clear()

 list.clear();// 调用clear方法清空集合中的所有数据

list.equals(list2)

//该方法去比较两个对象时，首先先去判断两个对象是否具有相同的地址，如果是同一个对象的引用，则直接放回true；如果地址不一样，
//则证明不是引用同一个对象，接下来就是挨个去比较两个字符串对象的内容是否一致，完全相等返回true，否则false。
 list.equals(arr);//false

list.isEmpty

1. 有没有瓶子 list != null
2. 瓶子里有没有水 list.isEmpty()
3. 判断的时候一定要注意先后顺序 如果没有瓶子都没有，直接判断有没有水，是会报nullException的
4. list.add(null)会造成list.isEmpty() 为false,但是list.size()为1， 所以代码里要避免list.add(null)的陷阱 。
5. list==null,它其实是根本没有在堆内是不存在的，没有存储的地址。但是list.size()=0是已经存在地址，但是并没有存相应的元素，当元素的数量增加是，size随之变化。
6. null说明了没有进行初始化，此时要是调用任何的方法的话都会抛出空指针异常，而list.size（）==0表示此list已经new过，但是其中没有存入任何值。
7. isEmpty先获取size的值在判断再返回，list.size则是直接返回属性size的值，相对isEmpty较快。看源码：

 public boolean isEmpty() {
     return size == 0;
 }

例子：我有一个空着的水杯（list），而你没有，那你是null，我的size为0。你想装水需要去买个水杯（new ArrayList();），我就可以直接装水（list.add(水)）。你要是没有杯子直接倒水，水就流出去啦（空指针异常）。所以用做判断的时候经常连用list!=null && list.size()!=0 。
区别： 是否存在，存在的话是否存放元素。因此最先判断是否存在实物，再判断实物中是否存放东西。

List定义时添加多条数据

 List<Integer> requiredCol = new ArrayList<Integer>() {{ add(1);add(2);add(3);add(4); }};

list.remove(i)

list.remove(i);//移除指定位置数据

list.contains()

contains方法的源码是用equals()比较的,也就是说比较的是地址,所以要在类中重写equals()方法.看代码如何实现的
 public boolean equals(Object obj) {
        if(this==obj)//地址相同
            return true;
        else if(obj!=null&&obj instanceof User) {
            User u=(User)obj;
            return this.name.equals(u.name)&&this.pswd.equals(u.pswd);
        }
        else
            return false;
    }

list转数组

  //为了将List转为数组，JDK提供了toArray
        //实现方式一：
        String [] array=(String[]) list.toArray(new String[list.size()]);
        for(String arrays: array) {
            System.out.println(arrays);
        }
        //方式二：
        String [] arr=new String [list.size()];
        list.toArray(arr);
        for(String arrs: arr) {
            System.out.println(arrs);
        }

检验List是否存在重复的元素

//校验list是否存在重复的编码且重复元素是哪个
                List<String> checkCode = new ArrayList<>();
                for (List<String> list : lists) {
                    String code = list.get(1);
                    checkCode.add(code);
                }
                
                HashSet<String> codeSet = new HashSet<>();
                for (String code : checkCode) {
                    boolean b = codeSet.add(code);
                    if (!b) {
                        throw new Exception("文件中存在重复的编码: " + code);
                    }
                }

//只检验是否存在重复元素
	       HashSet<String> set = new HashSet<>(list);
	       Boolean result = set.size() == list.size() ? true : false;

Stream操作List

List取出对象中某一属性

  List<String> ids=list.stream().map(User::getId).collect(Collectors.toList());

List，将id属性逗号拼接

String str = List.stream().map(User::getId).collect(Collectors.joining(","));

List，将id属性逗号拼接后转换为Strnig类型

String str = List.stream().map(Restriction::getId).collect(Collectors.toList()).stream().map(w->w.toString()).collect(Collectors.joining(","));

List转换为另一个List

 List<Employee> employees = persons.stream()
                .filter(p -> p.getLastName().equals("l1"))
                .map(p -> new Employee(p.getName(), p.getLastName(), 1000))
                .collect(Collectors.toList());

List过滤元素

User match = users.stream().filter((user) -> user.getId() == 1).findAny().get();

List转换为Map

Map<Integer, String> result1 = list.stream().collect(
                Collectors.toMap(User::getId, Hosting::getName));

List与List差集

//List1-List2
  List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(Collectors.toList());

List与List交集

  List<String> reduce2 = list1.stream().filter(list2::contains).collect(Collectors.toList());

List与List去重并集

  list1.addAll(list2);
   List<String> reduce3 = list1.stream().distinct().collect(Collectors.toList());

List<List>求交集

 @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public List<Group> findAll() {
        List<Group> all = groupDAO.findAll();
        /*处理小组目前标签*/
        /*对查到的所有小组进行遍历得知该小组所在班级id和小组id,根据这两个id查询到学生集合
         * 根据得到的学生查询到每个学生的标签集合
         *  set1.retainAll(set2);中set1就是交集*/
        for (Group group : all) {
            List<List<Lable>> allCourses=new ArrayList<>();
            String cid = group.getClazzId();
            String gid = group.getId();
            List<User> users = userDAO.queryUserBycg(cid, gid);
            for (User user : users) {
                /*allCourses存放的是集合类型，为该小组内每个学生的标签集合*/
                allCourses.add(user.getLables());
            }
            /*采用reduce方法对标签集合进行交集处理，两两求交集，若有交集则返回交集，若没有交集则返回为空*/
            List<Lable> lables= allCourses.stream().reduce((list1,list2)->{
                list1.retainAll(list2);
                return list1;

            }).orElse(Collections.emptyList());
            group.setLables(lables);
        }
        return all;
    }
---------------------------------------------------------------------------------------------------------
  listA.retainAll(listB);
        if(listA.size()>0){
            System.out.println("这两个集合有相同的交集");
        }else{
            System.out.println("这两个集合没有相同的交集");
        }