Java学习路程之LinkedHashSet、TreeSet和Map

一.LinkedHashSet
1.LinkedHashSet 有序 去重

public class Day15 {
    public static void main(String[] args) {
        LinkedHashSet<String> set = new LinkedHashSet();
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        Iterator<String> iterator = set.iterator();
        //迭代器循环
        while(iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);a b c d
        }
        利用set集合去除ArrayList集合中的重复元素(操作原ArrayList),ArrayList 保存a a, b b, c c
        //利用set集合去除ArrayList集合中的重复元素(操作原ArrayList),ArrayList 保存a a, b b, c c
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("c");
        //创建HashSet集合
        HashSet<String> hashSet = new HashSet<>();
        //将ArrayList中的元素全部放入HashSet集合中,去重
        hashSet.addAll(arrayList);
        //清空arrayList集合
        arrayList.clear();
        //将去重的元素放入arrayList集合中
        arrayList.addAll(hashSet);
        System.out.println(arrayList);//[a, b, c]
    }
}

二.TreeSet
1.TreeSet 无序 无下标 不重复
功能: 排序(默认升序) 去重
2.排序的步骤:
1).实现compareable接口
2).实现接口中的方法
3).重写排序规则

    //创建TreeSet保存四个数字
    TreeSet<Integer> treeSet = new TreeSet<>();
    treeSet.add(4);
    treeSet.add(6);
    treeSet.add(2);
    treeSet.add(9);
    //去重 排序以升序
    System.out.println(treeSet);//输出:[2, 4, 6, 9]

public class Day15 {
    public static void main(String[] args) {
        //声明集合保存四个字符串,按字符串长度排序
        //comparator  比较器  接口 编写比较接口
        //将比较的规则直接传入到treeSet的构造方法中
        //比较系统的类要重写一个类实现Comparator接口,重写比较规则,在创建集合时调用
        TreeSet<String> treeSet = new TreeSet<>(new CompareString());
        treeSet.add("hahd");
        treeSet.add("ha");
        treeSet.add("kafjd");
        treeSet.add("wtad");
        System.out.println(treeSet);//[ha, hahd, wtad, kafjd]
    }
}
//比较字符串长度的类实现接口
class CompareString implements Comparator<String>{
    //重写比较规则
    @Override
    public int compare(String o1, String o2) {
        int num = o1.length() - o2.length();
        return num = num == 0 ? 1 : num;
    }
}

在一个集合ArrayList中存储了无序并且重复的字符串
要求: 排序,而且还不能去除重复(用比较器),主要按字符串长度比较 次要按字符串比

public class Day15 {
    public static void main(String[] args) {
        TreeSet<String> treeSet  = new TreeSet<>(new StringSort());
        treeSet.add("af");
        treeSet.add("geaf");
        treeSet.add("af");
        treeSet.add("agf");
        treeSet.add("ggae");
        System.out.println(treeSet);
    }
}
//主要按字符串长度比较 次要按字符串比规则
class StringSort implements Comparator<String>{
    //重写比较规则
    @Override
    public int compare(String o1, String o2) {
        //比较长度相等
        int num = o1.length() - o2.length();
        //长度相等时比较字符
        int rel = num == 0 ? o1.compareTo(o2) : num;
        //字符相等时赋值1否则为rel
        return rel == 0 ? 1 : rel;
    }
}

键盘接收一个字符串, 对其中所有字符进行排序 要求保留重复的

public class Day15 {
    public static void main(String[] args) {
        System.out.println("请输入一个字符串");
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        //字符串转数组
        char[] charArray = str.toCharArray();
        TreeSet<Character> treeSet = new TreeSet<>();
        for (int i = 0; i < charArray.length; i++) {
            //遍历数组将元素放入集合中
            treeSet.add(charArray[i]);
        }
        System.out.println(treeSet);
    }
}
//字符比较
class CharSort implements Comparator<Character>{

    @Override
    public int compare(Character o1, Character o2) {
        int num = o1.compareTo(o2);
        return num = num == 0 ? 1 :num;
    }

}

程序启动后, 可以从键盘输入接收多个整数,直到输入quit时结束输入,把所有输入的整数降序排列打印.

public class Day15 {
    public static void main(String[] args) {
        System.out.println("请输入整数,以quit结束输入");
        Scanner scanner = new Scanner(System.in);
        TreeSet<Integer> treeSet = new TreeSet<>(new CompareNum());
        while (true) {
            String string = scanner.nextLine();
            //判断是否结束循环
            if (string.equals("quit")) {
                break;
            }
            //字符串转整数
            int num = Integer.parseInt(string);
            //将整数存入集合
            treeSet.add(num);
        }
        System.out.println(treeSet);
    }
}
//比较数字
class CompareNum implements Comparator<Integer>{

    @Override
    public int compare(Integer o1, Integer o2) {
        int num = o1 - o2;
        return num = num == 0 ? 1 : num;
    }
}

键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)
录入的学生信息格式(姓名,语文成绩,数学成绩,英语成绩)
按照总分从高到低输出到控制台。输出学生所有信息

public class Day15 {
    public static void main(String[] args) {
        System.out.println("请输入姓名,语文成绩,数学成绩,英语成绩");
         Scanner scanner = new Scanner(System.in);
         TreeSet<Student> treeSet = new TreeSet<>(new Student());
         for (int i = 0; i < 5; i++) {
            String string = scanner.nextLine();
            //以,分割字符串
            String[] array = string.split(",");
            //将成绩转为整数
            int chinese = Integer.parseInt(array[1]);
            int math = Integer.parseInt(array[2]);
            int english = Integer.parseInt(array[3]);
            //创建学生对象
            Student student = new Student(array[0], chinese, math, english);
            //将学生放入集合
            treeSet.add(student);
        }
         System.out.println(treeSet);
    }
}

//创建人类
class Person implements Comparable<Person>{
    private String name;
    private int age;
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        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 String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int compareTo(Person o) {
        // TODO Auto-generated method stub
        //重写排序规则
        //以年龄排序(升序)
        int num = this.age - o.getAge();
        return num;
    }
}

//学生类
//学生信息格式(姓名,语文成绩,数学成绩,英语成绩)
public class Student implements Comparator<Student>{
    private String name;
    private int chinese;
    private int math;
    private int english;
    private int sum;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int chinese, int math, int english) {
        super();
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
        //计算总分
        this.sum = this.chinese + this.math + this.english;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getChinese() {
        return chinese;
    }
    public void setChinese(int chinese) {
        this.chinese = chinese;
    }
    public int getMath() {
        return math;
    }
    public void setMath(int math) {
        this.math = math;
    }
    public int getEnglish() {
        return english;
    }
    public void setEnglish(int english) {
        this.english = english;
    }
    public int getSum() {
        return sum;
    }
    public void setSum(int sum) {
        this.sum = sum;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", chinese=" + chinese + ", math=" + math + ", english=" + english + ", sum="
                + sum + "]";
    }
    //重写排序规则,按照总分排,并且不能去重
    @Override
    public int compare(Student o1, Student o2) {
        // TODO Auto-generated method stub
        int num = o1.sum - o2.sum;
        return num = num == 0 ? 1 : num;
    }
}

三.Map
1.map是双列集合的父接口
特点:
1).以键值对形式来存储数据 key—value
2)健值唯一(健值不能重复)
2.hashSet和hashMap的关系:
hashSet 依赖 hashMap,实际上向hashSet中添加元素是向hashMap的key列添加元素

public class Day15 {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        //添加键值对元素
        //put方法的返回值是该键被覆盖的value的值
        Integer put = map.put("张三", 18);
        Integer put2 = map.put("李四", 21);
        Integer put3 = map.put("王五", 16);
        Integer put4 = map.put("王五", 30);

        System.out.println(map);
        System.out.println(put);
        System.out.println(put2);
        System.out.println(put3);
        System.out.println(put4);
    }
}

Map的方法:
HashMap<String, Integer> hashMap = new HashMap<>();
        Integer put = hashMap.put("张三", 18);
        Integer put2 = hashMap.put("李四", 21);
        Integer put3 = hashMap.put("王五", 16);
        Integer put4 = hashMap.put("麻子", 25);
        //判断是否包含key
        boolean b1 = hashMap.containsKey("李四");
        System.out.println(b1);
        //判断是否包含value
        boolean b2 = hashMap.containsValue(21);
        System.out.println(b2);
        //取出所有key的set集合
        Set<String> keySet = hashMap.keySet();
        System.out.println(keySet);
        //取出所有value的集合
        Collection<Integer> values = hashMap.values();
        System.out.println(values);
        //通过key将整个键值对删除
        Integer remove = hashMap.remove("李四");
        System.out.println(remove);
        //清空hasMap
        hashMap.clear();
        System.out.println(hashMap);

        通过迭代器遍历map
        HashMap<Person, String> hashMap = new HashMap<>();
        hashMap.put(new Person("李四", 18), "山西");
        hashMap.put(new Person("张三", 20), "陕西");
        hashMap.put(new Person("王五", 22), "新疆");
        hashMap.put(new Person("王五", 22), "新疆");
        Set<Person> keySet = hashMap.keySet();
        Iterator<Person> iterator = keySet.iterator();
        while (iterator.hasNext()) {
            Person key = iterator.next();
            String value = hashMap.get(key);
            System.out.println(key +" = "+ value);
        }

        //利用Entry对象遍历Map
        //Entry对象中分装了一对键值对对象 key---value
        HashMap<String, Integer> hashMap = new HashMap<>();
        Integer put = hashMap.put("张三", 18);
        Integer put2 = hashMap.put("李四", 21);
        Integer put3 = hashMap.put("王五", 16);
        //获取所有entry对象的set集合
        Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();
        //取出迭代器
        Iterator<Entry<String, Integer>> iterator = entrySet.iterator();
        //遍历所有entry对象
        while (iterator.hasNext()) {
            //取出集合中的每一个entry对象
            Entry<String, Integer> entry = iterator.next();
            Integer value = entry.getValue();
            String key = entry.getKey();
            System.out.println(key +" = "+ value);
        }