C# 修改list所有对象中的某字段
 
语法糖：ForEach（批量修改时候方便）
 最简单的方法就是用ForEach
 
 List<MyObject> myObject = new List<MyObject>();
 myObject.ForEach(w => w.MyBool = true);
 
上面代码就是吧我们myObject 对象集合中所有的MyBool都更改为true
 
案例：
 环境 dotnet Core 2.1
 
案例下载地址：https://download.csdn.net/download/qq_36051316/10749269
 核心代码放在其他环境上一样通用
 
using System;
using System.Collections.Generic;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //声明一个对象集合
            List<MyObject> myObject = new List<MyObject>();
            //循环添加对象到集合内
            for (int i = 1; i < 20; i++)
            {
                MyObject woei = new MyObject
                {
                    MyInt = i,
                    MyBool=false
                };
                myObject.Add(woei);

            }
            //开始输出第一次
            Console.WriteLine("开始输出第一次：");
            //循环输出发现我们的数据中MyBool全是false
            foreach (var item in myObject)
            {
                Console.WriteLine($"int:{item.MyInt},bool：{item.MyBool}");
            }
            //通过更改后，改成true
            myObject.ForEach(w => w.MyBool = true);
            Console.WriteLine("开始输出第二次：");
            //第二次输出：循环输出发现我们的数据中MyBool全是true
            foreach (var item in myObject)
            {
                Console.WriteLine($"int:{item.MyInt},bool：{item.MyBool}");
            }

        }
    }

    public class MyObject
    {
        public int MyInt { get; set; }
        public bool MyBool { get; set; }
    } 
}

// 1.排序，带参数类型
list.sort((String s1, String s2) -> s1.compareTo(s2));
list.sort(( LibraryDO lib1, LibraryDO lib2) -> lib2.getId().compareTo(lib2.getId()));
// 使用默认方法排序
Collections.sort(list, Comparator.comparing(LibraryDO::getId)); //升序
Collections.reverse(list); // 倒序排列
//随机打乱顺序
Collections.shuffle(list);
//更多排序
//默认ASC排序）
List<LibraryDO> collect = users.stream().sorted(Comparator.comparing(LibraryDO::getId)).collect(Collectors.toList());
//DESC排序）
List<LibraryDO> collect = users.stream().sorted(Comparator.comparing(LibraryDO::getId).reversed()).collect(Collectors.toList());

// 2.数组去重
List<String> collect = list.stream().distinct().collect(Collectors.toList());
// 数组去重转换为字符串
String joining = list.stream().distinct().collect(Collectors.joining(",")); 
// 根据对象属性去重
List<LibraryDO> lib = list.stream().collect(Collectors.collectingAndThen(
					Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(LibraryDO::getId))), ArrayList<LibraryDO>::new));

// 4.获取对象某一属性返回list
List<String> collect= list.stream().map(LibraryDO::getId).collect(Collectors.toList());
// 获取对象某一属性返回数组
Integer[] array = list.stream().map(LibraryDO::getId).collect(Collectors.toList()).stream().toArray(Integer[]::new);
// 获取对象某一属性返回数组过滤非空
Integer[] array = list.stream().map(LibraryDO::getId).filter(x -> x !=null).collect(Collectors.toList()).stream().toArray(Integer[]::new);
//5.修改对象属性值
List<LibraryDO> lib = list.stream().map(p -> {p.setId(p.getId() + 1);return p;}).collect(Collectors.toList())
/**
 * LibraryDO 对象
 */
public class LibraryDO implements Serializable {
	//ID
	private Integer id;
	//图书馆名称
	private String libName;
	//网址
	private String libUrl;
}



 
排序
 https://www.cnblogs.com/woyaobianfei/p/9187127.htm

1.许多时候我们得到的List并不是我们最终要输出的，所以我们还需要进行排序，下面自己写代码进行排序
 
分类一： int属性进行排序
 
  代码： 
 
List<Student> list = new ArrayList<Student>();
         
         //创建3个学生对象，年龄分别是20、19、21，并将他们依次放入List中
         Student s1 = new Student();
         s1.setAge(20);
         s1.setName("P02C004194");
         Student s2 = new Student();
         s2.setAge(19);
         s2.setName("P02C003191");
         Student s3 = new Student();
         s3.setAge(21);
         s3.setName("P02C002190");
         list.add(s1);
         list.add(s2);
         list.add(s3);
         
         System.out.println("排序前："+list);
          Collections.sort(list, new Comparator<Student>(){
  
             /*
              * int compare(Student o1, Student o2) 返回一个基本类型的整型，
              * 返回负数表示：o1 小于o2，
              * 返回0 表示：o1和o2相等，
              * 返回正数表示：o1大于o2。
              */
             public int compare(Student o1, Student o2) {
             
                 //按照学生的年龄进行升序排列
                if(o1.getAge() > o2.getAge()){
                   return 1;
                }
                 if(o1.getAge() == o2.getAge()){
                     return 0;
                 }
                 return -1;
             }
         }); 
         System.out.println("排序后："+list);
     }
 }
 class Student{
     
     private int age;
     
     private String name;
  
     public int getAge() {
         return age;
     }
  
     public void setAge(int age) {
         this.age = age;
     }
     
     
     public String getName() {
         return name;
     }
 
    public void setName(String name) {
         this.name = name;
     }
 
    @Override
     public String toString() {
         return "Student [age=" + age + ", name=" + name + "]";
     }
     
 }
 
 
 
 
 
二、按照String类型进行排序：
 
   其余都不变只是排序方法的修改，    
 
Collections.sort(list, new Comparator<Student>(){
             public int compare(Student o1, Student o2) {
                 //按照学生的姓名进行升序排列
                 if(o1.getName().compareTo(o2.getName())==0){
                     return 1;
                 }else{
                     return o1.getName().compareTo(o2.getName());
                 }    }
         }); 
 
  按照降序排序：
 
Collections.sort(list, new Comparator<Student>(){
             public int compare(Student o1, Student o2) {
                 //按照学生的姓名进行降序排列
                 if(o1.getName().compareTo(o2.getName())==0){
                     return 1;
                 }else{
                     return o2.getName().compareTo(o1.getName());
                 }    }
         }); 
 
 
 
 

public static void main(String[] args) throws Exception  {
    String str="reject.Person";
    try {
        /**
         * 通过反射调取方法修改参数，应用场景比较多
         */
        //获取反射对象
        Class<?> name = Class.forName(str);
        //获取实例，因为newInstance方法得到的是object类型的，所以需要强转
        Person instance = (Person) name.newInstance();
        //instance.setName("高淇");
        //通过反射对象获取一般方法
        Method method = name.getMethod("setName", String.class);
        //利用反射中的invoke方法激活通过反射调取的方法，里面的参数是实例对象和方法参数
        method.invoke(instance, "高淇");
        System.out.println(instance.getName());
        /**
         * 通过反射调取属性，修改属性参数。
         */
        //通过反射获取反射对象
        Class<?> name1 = Class.forName(str);
        //通过反射获取某个声明的属性
        Field declaredField = name1.getDeclaredField("name");
        //一般属性私有化，通过setAccessible方法，可以免去安全访问环节，对象可以直接访问。
        declaredField.setAccessible(true);
        //通过set方法，修改属性，里面的参数是实例对象和修改后的参数。
        declaredField.set(instance, "gaoqi");
        System.out.println(instance.getName());


    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

 
案例
 
//将JsonArry转换为list
                 List<UserMFlowDetail> list=JSONObject.parseArray(jsonArray.toString(),UserMFlowDetail.class);
                 WaterUser waterUser=waterUserMag.getObjectById(dbUserMFlow.getPeriod());
                 Class<?> name = Class.forName("com.centit.njjs.yshgl.po.WaterUser");
                 list.forEach(item->{
                     try {
                         Field declaredField = name.getDeclaredField(item.getModifiedField());
                         declaredField.setAccessible(true);
                         if("chargeType".equals(item.getModifiedField())){//判断list集合下遍历对象的属性:是否是chargeType
                             declaredField.set(waterUser, "2");
                         }else{
                             declaredField.set(waterUser, item.getNewCon());
                         }
                     } catch (NoSuchFieldException e) {
                     //NoSuchFieldException错误是由于没有对应字段造成的，或者当属性为私有时获取Field用的方法不是getDeclaredField
                         e.printStackTrace();
                     } catch (IllegalAccessException e) {
                         e.printStackTrace();
                     }
                     waterUserMag.mergeObject(waterUser);//保存对象
                 });