ACAC 集合总结（干货）

package ZongJIe;

/**
 * 1、集合这块主要掌握哪些内容？
 *      1.创建集合对象
 *      2.向集合中添加元素
 *      3，从集合中取出某个元素
 *      4，遍历集合
 *
 */
public class Note01 {
    
    
}

package ZongJIe;

/**
 *   1.创建集合对象
 *   2.向集合中添加元素
 *   3，从集合中取出某个元素
 *   4，遍历集合
 *
 *   LinkedList和ArrayList相似
 */

import java.util.*;

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

        //ArrayList<Integer> it = new ArrayList<>();
        LinkedList<Integer> it = new LinkedList<>();
        it.add(12);
        it.add(123);
        it.add(167);
        System.out.println("获取第一个元素 ： " + it.get(0));
        it.set(0,234);
        System.out.println("替换后输出第一个元素 ： " + it.get(1));

        for(Integer data : it){
    
    
            System.out.println("遍历集合，使用增强for循环 ：" + data);
        }

        System.out.println("迭代器通用的，所有的Collection都能用。。。。");
        Iterator it2 = it.iterator();

        while(it2.hasNext()){
    
    
            System.out.println("使用迭代器遍历: " + it2.next());
        }

        Collections.sort(it);
        for(Integer data : it){
    
    
            System.out.println("Collections工具类排序，遍历集合，使用增强for循环 ：" + data);
        }



        /**
         * 输出结果：
         * 获取第一个元素 ： 12
         * 替换后输出第一个元素 ： 123
         * 遍历集合，使用增强for循环 ：234
         * 遍历集合，使用增强for循环 ：123
         * 遍历集合，使用增强for循环 ：167
         * 迭代器通用的，所有的Collection都能用。。。。
         * 使用迭代器遍历: 234
         * 使用迭代器遍历: 123
         * 使用迭代器遍历: 167
         * Collections工具类排序，遍历集合，使用增强for循环 ：123
         * Collections工具类排序，遍历集合，使用增强for循环 ：167
         * Collections工具类排序，遍历集合，使用增强for循环 ：234
         *
         *
         * 泛型的话ArrayList不能用排序，因为要重写的方法传进去的参数是Object类型的，不是特定的
         * ArrayList<Person> people = new ArrayList<>();
         *   @Override
         *     public int compareTo(Object o) {
         *         return 0;
         *     }
         *
         * 那不用泛型是不是就可以排序了呢？？
         *
         *         ArrayList al = new ArrayList(new Comparator<>() {
         *              @Override
         *              public int compare(T o1, T o2) {
         *                  return 0;
         *              }
         *          });
         *  也不行，原因：数组本就是有下标的，有序的放进去，没有排序的比较
         *  而且也没有实现comparable和Comparator接口，没有排序这一说
         *
         */



    }

}

package ZongJIe;

import java.util.*;

/**
 *   1.创建集合对象
 *   2.向集合中添加元素
 *   3，从集合中取出某个元素
 *   4，遍历集合
 *
 *   排序重写：
 *    1.实现comparable接口
 *    2.建立比较器Comparator接口（可以匿名内部类）
 *
 */
public class TreeSetTest {
    
    
    public static void main(String[] args) {
    
    

        //自动都排序了，没必要在，但是可以颠倒顺序，
        // 不能通过继承String，重写Comparable，因为重写不了，但是可以通过写比较器，改变比较的方式
        // public static final Comparator<String> CASE_INSENSITIVE_ORDER
        //                = new String.CaseInsensitiveComparator();


        TreeSet<String> ss = new TreeSet<>(new Comparator<String>() {
    
    
            @Override
            public int compare(String o1, String o2) {
    
    
                return o2.compareTo(o1);
            }
        });

        ss.add("sfgb");
        ss.add("agfd");
        ss.add("eryg");

        Iterator it = ss.iterator();
        while(it.hasNext()){
    
    
            System.out.println("迭代器遍历：" + it.next());
        }
        for(String data : ss){
    
    
            System.out.println("foreach遍历： " + data);
        }

        //自动都排序了，没必要在，但是可以颠倒顺序，通过写比较器
        List<String> tt = new LinkedList<>(ss);
        Collections.sort(tt);
        Iterator it02 = tt.iterator();
        while(it02.hasNext()){
    
    
            System.out.println("排序后迭代器遍历：" + it02.next());
        }

        /**
         * 这里不能用上面的迭代器对象，因为迭代器没有更新
         * while(it.hasNext()){
         *             System.out.println("排序后迭代器遍历：" + it.next());
         *         }
         */

        TreeSet<Student03> sss = new TreeSet<>();
        sss.add(new Student03(111,"miao"));
        sss.add(new Student03(222,"adfa"));
        sss.add(new Student03(12,"agfad"));
        for(Student03 data : sss){
    
    
            System.out.println("重写comparable接口foreach遍历： " + data);
        }

        TreeSet<Student04> ssss = new TreeSet<>(new Student04Comparator());
        ssss.add(new Student04("miao"));
        ssss.add(new Student04("adfa"));
        ssss.add(new Student04("agfad"));
        for(Student04 data : ssss){
    
    
            System.out.println("重写comparator接口foreach遍历： " + data);
        }



    }
}
class Student03 implements Comparable<Student03>{
    
    

    int age;
    String name;

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

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

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

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

    @Override
    public int compareTo(Student03 o) {
    
    
        return this.age - o.age;
    }
}
class Student04 {
    
    
    String name;

    public Student04(String name) {
    
    
        this.name = name;
    }

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

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

    @Override
    public int hashCode() {
    
    
        return Objects.hash(name);
    }
}
class Student04Comparator implements Comparator<Student04>{
    
    

    @Override
    public int compare(Student04 o1, Student04 o2) {
    
    
        return o1.name.compareTo(o2.name);
    }
}

package ZongJIe;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;

/**
 *   1.创建集合对象
 *   2.向集合中添加元素
 *   3，从集合中取出某个元素
 *   4，遍历集合
 *   5.测试特点：无序不可重复
 *
 *   HashSet相当于HashMap中put方法里的key，要重写hashCode方法
 *   否则就不是无序不可重复了
 *
 *
 */
public class HashSetTest {
    
    
    public static void main(String[] args) {
    
    

        HashSet<String> hashSet = new HashSet<>() ;
        hashSet.add("gsa");
        hashSet.add("awef");
        hashSet.add("fgd");
        hashSet.add("fgd");


        System.out.println("底层是HashMap，没有下标，所以没有get方法");
        System.out.println("直接输出hashSet： " + hashSet);

        //遍历，不能用下标，可以用迭代器
        Iterator it = hashSet.iterator();
        while(it.hasNext()){
    
    
            System.out.println("迭代器方法遍历：" + it.next());
        }

        for(String data : hashSet){
    
    
            System.out.println("foreach方法遍历：" + data);
        }



        //测下hashCode的方法重写不重写的区别
        HashSet<Student> ss  = new HashSet<>();
        ss.add(new Student(111,"miao"));
        ss.add(new Student(111,"miao"));

        Iterator it02 =  ss.iterator();
        while(it02.hasNext()){
    
    
            System.out.println("HashSet集合里的元素： " + it02.next());
        }
        System.out.println("不重写的hashCode，应该是1，不能重复的，集合长度为： " + ss.size());
        System.out.println("这是因为没有重写hashCode方法，HashMap中put方法返回k的哈希值不同");
        System.out.println("一直是这样的话，就变成数组了，就没有链表的结构了");


        HashSet<Student02> ss02 = new HashSet<>();
        ss02.add(new Student02(111,"maio"));
        ss02.add(new Student02(111,"maio"));

        Iterator it03 =  ss02.iterator();
        while(it03.hasNext()){
    
    
            System.out.println("HashSet02集合里的元素： " + it03.next());
        }
        System.out.println("重写后的hashCode，这是应该是1，则长度为： " + ss02.size());



    }
}
class  Student{
    
    
    int no;
    String name;

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

    @Override
    public String toString() {
    
    
        return "no : " + no + " name : " + name;
    }


}
class Student02{
    
    
    int no;
    String name;

    public Student02(int no, String name) {
    
    
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
    
    
        return "no : " + no + " name:" + name;
    }

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

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

package ZongJIe;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 *   1.创建集合对象
 *   2.向集合中添加元素
 *   3，从集合中取出某个元素
 *   4，遍历集合
 *      两种方法：keySet（） 和 entrySet（）
 *
 *
 *
 */

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

        Map<Integer,String> is = new HashMap<>();
        is.put(1,"asfda");
        is.put(2,"rger");
        is.put(3,"ehtgr");
        is.put(2,"sgfvds");//key重复，value会覆盖

        System.out.println("元素的长度 ： " + is.size());
        System.out.println("取得key为2的元素：" + is.get(2));//这个2不是下标

        //遍历  keySet()方法
        Set<Integer> ss = is.keySet();
        for(Integer key : ss){
    
    
            System.out.println(key + " = " + is.get(key));
        }

        //遍历 将map集合转换为set集合，set集合每个元素时node，这个节点中有key和value

        Set<Map.Entry<Integer,String>> sss = is.entrySet();
        for(Map.Entry<Integer,String> node: sss){
    
    
            System.out.println("key :" + node.getKey() + " value : " + node.getValue());
        }


    }
}

package ZongJIe;

import java.util.Properties;

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

        //全是String类型的参数
        Properties pro = new Properties();
        pro.setProperty("uuu","adgfa");
        pro.setProperty("sdf","sgfsdth");

        System.out.println(pro.getProperty("uuu"));
        System.out.println(pro.getProperty("sdf"));
    }
}