Java基础01~16 集合总结查漏补缺

List集合可重复，有序，其有序只是根据索引有序，其值不一定有序，相当于数组，排序需要自己写方法
Set集合不可重复
HashSet 不可重复，无序，别强求有序
LinkedHashSet 不可重复，有序，其有序是插入数据顺序的有序，而不是按值来排序
TreeSet 不可重复，有序，其有序是因其有内部的CompareTo方法,基本类型按值大小排序，复杂引用类型需要重新CompareTo方法来进行比较
具体分析看上一个查漏补缺

一、List并发错误解决方法

第一种 普通for循环
从list.size()-1开始倒着循环，插入 删除数据都不会有问题

package exam;

import java.util.ArrayList;
import java.util.ListIterator;

public class Work01 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(1);
        list.add(1);
        list.add(0);
        for (int i = list.size()-1; i >=0; i--) {
            if(list.get(i)==1){
                list.remove(i);
            }
        }
        System.out.println(list);
    }

}

从0开始正着循环 插入数据没问题，删除数据需要增加一句i--;代码

 for (int i = 0; i < list.size(); i++) {
            if(list.get(i)==1){
                list.remove(i);
                i--;
            }
        }
        System.out.println(list);

使用专属迭代器 ListIterator 进行遍历，注意是使用iter (迭代器名)调用 删除 remove 插入add 改值 set
插入时往后插， 而不是使用 list(集合名) 调用方法

ListIterator<Integer> iter = list.listIterator();
        /*while (iter.hasNext()){
            if(iter.next()==1){
                iter.remove();
            }
        }*/
        /*while (iter.hasNext()){
            if(iter.next()==2){
                iter.add(3);
            }
        }*/
        while (iter.hasNext()){
            if(iter.next()==1){
                iter.set(3);
            }
        }

        System.out.println(list);

删除数据使用removeall()方法 去除交集

        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list.removeAll(list1);
        System.out.println(list);

二、TreeSet的CompareTo 多属性自定义比较方法

第一种方式是直接在声名集合是在方法参数匿名接口类Comparator，并重写compare()方法
第二种方式是在集合存储的对象类中连接实现Comparable接口，重写compareTo()方法

0是认为相同不存储，大于0 则正序存储，小于0 则逆序存储

那个属性优先级高就先判断那个属性不相等，return 比较值
超过两个第二个判断条件就是第一级属性相等&&第二级属性不相等，return 第二级属性比较值
String compareTo方法自动重写了，先比较第一个字符，按Ascii码表比大小，相同一直比下去

return o1.getName().compareTo(o2.getName());

package exam;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package exam;

import java.text.Collator;
import java.util.Comparator;
import java.util.Locale;
import java.util.Objects;

public class Person implements Comparable{
    private String name;
    private int h;
    private int age;

    public Person() {
    }

    public Person(String name, int h, int age) {
        this.name = name;
        this.h = h;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getH() {
        return h;
    }

    public void setH(int h) {
        this.h = h;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return h == person.h &&
                age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, h, age);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", h=" + h +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        Person o1 = (Person) o;
        //compareTo 比较中文 按第一个中文拼音的第一字母比较
        Comparator<Object> com = Collator.getInstance(Locale.CHINA);
        if (this.name != o1.name ) {
            return ((Collator) com).compare(this.name,o1.getName());
            //return this.name.compareTo(o1.name);
        }else if(this.name ==o1.name && this.age !=o1.age){
            return this.age-o1.age;
        }else {
            return this.h-o1.h;
        }
    }
}

比较中文字符 ，按第一个中文拼音的第一字母比较

//compareTo 比较中文 按第一个中文拼音的第一字母比较
 		Person o1 = (Person) o;
        Comparator<Object> com = Collator.getInstance(Locale.CHINA);
         return ((Collator) com).compare(this.name,o1.getName());
            //return this.name.compareTo(o1.name);

package exam;

import java.util.*;

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

        Set<Student> set = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //0是认为相同不存储，大于0 则正序存储，小于0 则逆序存储
                //那个属性优先级高就先判断那个属性不相等，return 比较值
                //超过两个第二个判断条件就是第一级属性相等&&第二级属性不相等，return 第二级属性比较值
                if (o1.getAge()!=o2.getAge()){
                    return o1.getAge()-o2.getAge();
                }else {
                    //String compareTo方法自动重写了，先比较第一个字符，按Ascii码表比大小，相同一直比下去
                    return o1.getName().compareTo(o2.getName());
                }
            }
        });
        set.add(new Student("张三",20));
        set.add(new Student("李四",20));
        set.add(new Student("王五",19));
        set.add(new Student("李柳",18));
        set.add(new Student("王萌萌",20));
        set.add(new Student("李四",20));
        for (Student student : set) {
            System.out.println(student);
        }
        Set<Person> set1 = new TreeSet<>();
        set1.add(new Person("谢顺",170,18));
        set1.add(new Person("谢顺",170,17));
        set1.add(new Person("谢顺",160,18));
        set1.add(new Person("谢顺",160,17));
        set1.add(new Person("张三",170,18));
        set1.add(new Person("啊三",170,18));
        set1.add(new Person("啊如三",170,18));
        set1.add(new Person("安如三",170,18));
        set1.add(new Person("黄天良",170,18));
        for (Person person : set1) {
            System.out.println(person);
        }



    }
}