集合间有趣的小例子

第一种  ：list2创建新对象
 List<String> list1=new ArrayList<>();
        list1.add("1");
        list1.add("2");
        List<String>list2=new ArrayList<>(list1);
        list2.add("3");
        System.out.println(list1.size());//2
        System.out.println(list2.size());//3
第二种：list2直接赋值list1
       list1.add("1");
        list1.add("2");
        List<String>list2=list1;
        list2.add("3");
        System.out.println(list1.size());//3
        System.out.println(list2.size());//3
第三种：list2中 引用类型
        List<Student> list1 = new ArrayList<>();
        Student s1 = new Student();
        s1.setAge(1);
        s1.setName("第一个");
        list1.add(s1);
        List<Student> list2 = new ArrayList<>(list1);
        Student s3 = new Student();
        list2.add(s3);
        list2.get(0).setName("ccccccc");
        System.out.println(list1.get(0));//Student(name=ccccccc, age=1)
        System.out.println(list2.get(0));//Student(name=ccccccc, age=1)
        System.out.println(list1.size());//1
        System.out.println(list2.size());//2
第三种：list非引用类型
List<String> list1 = new ArrayList<>();
        list1.add("1");
        List<String> list2 = new ArrayList<>(list1);
        list2.set(0, "updated");
        System.out.println(list1.get(0));//1

为什么引用类型，非引用类型在list2中修改数据，得到的list1中数据不同【一个跟随list2变动，一个不变动】？

先复习概念：

对象：每个对象都是某个类（class）的一个实例（instance），类即类型的意思，对象 就是类的实例

对象引用：处理数据/对象 借助 指向一个对象的引用    【一个是实例，一个是引用 概念上就不一样】

举例： Person  per=new Pserson('小黑'); 

1.创建对象的关键字  new

2. per 就是指向  new出来的对象  的引用

p1=per;p2=per   多个引用都指向了同一个对象/小黑！

p1= new Person('小白'); 一个引用可以指向多个对象，但是实际使用时最后还是指向一个对象！ p1指向对象小黑，但最后程序启动输出结果会发现最后还是指向 对象小白。

上述问题 java中都是值传递！

但是 值传递分为两类

1.数值         调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数       

2.地址值        在调用函数时将实际参数的 地址/引用 直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数

区别简单概括：是否创建副本；是否改变原始对象

Java中的对象传递，如果是修改引用，是不会对原来的对象有任何影响的，但是如果直接修改共享对象的属性的值，是会对原来的对象有影响的。

这样讲不太正确，但是方便理解！

List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("java");
//迭代器
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            if(s.equals("java")){
                list.add("javaee");//ConcurrentModificationException（并发修改异常）
        //exceptedModeCount = modCount
            }
        }
写这个例子原因：太久了，固化想着迭代中不允许list.remove(e).没想到——迭代期间不允许直接修改集合list.add(e)也不可以的！！ 【防止并发修改导致的数据不一致性或迭代器失效】
1.此时可以用for循环代替迭代，进行添加
2.ListIterator允许在迭代过程中对列表进行添加、修改和删除操作。操作与普通Iterator相同

集合排序的方法

自然排序  int compareTo

public class Student implements Comparable<Student> {
//关键代码 ——重写方法
@Override
    public int compareTo(Student s) {
//        return -1;//降序
//        return 0;//元素重复
//        return 1;//升序

        int flag = this.age - s.age;    //this在前为升序，在后为降序
        int flag2 = flag == 0 ? this.name.compareTo(s.name) : flag;		//String类自带compareTo方法  //年龄一致时，看名称排序
        return flag2;
    }
}

比较器排序Comparator的使用 int compare

    TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int flag = s1.getAge() - s2.getAge();
                int flag2 = flag == 0 ? s1.getName().compareTo(s2.getName()) : flag;
                return flag2;
            }
        });
//
        personList.sort((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()));

Map集合遍历方式

1.获取所有键的集合。用keySet()方法

  //遍历
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键
        for (String key : keySet) {
            //根据键去找值
            String value = map.get(key);
            System.out.println(key + "," + value);
        }

2.获取所有 键值对 对象的集合  Set<Map.Entry<K,V>> entrySet()：

   //遍历
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> me : entrySet) {
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
 

3.java8的Lambda

map.forEach((key, value) -> System.out.println(key + ": " + value));