Java常用集合的创建，添加，取出，遍历等

1、ArrayList 集合

1.1、每个集合对象的创建（new）
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合

import java.util.ArrayList;
import java.util.Iterator;

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
 */
public class ArrayListTest {
    public static void main(String[] args) {
        // 创建ArrayList集合
        ArrayList<String> arrayList = new ArrayList<>();
        // 向集合添加元素
        arrayList.add("zhangsan");
        arrayList.add("lisi");
        arrayList.add("wangwu");
        arrayList.add("zhaoliu");
        // 从集合中取出某个元素
        String i = arrayList.get(1);
        System.out.println(i);
        System.out.println("===============分割线============");
        // 遍历集合 获取迭代器进行集合遍历
        Iterator<String> it = arrayList.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println("\n===============分割线============");
        // 遍历集合 通过迭代器配合for循环遍历
        for(Iterator<String> its = arrayList.iterator() ;its.hasNext();){
            System.out.println("====>"+its.next());
        }
        System.out.println("===============分割线=============");
        // 遍历集合 通过增强for
        for(String fors : arrayList){
            System.out.print(fors+" ");
        }
        System.out.println("\n===============分割线=============");
        // 遍历集合 通过获取长度加for的方式
        for(int j = 0;j < arrayList.size();j++){
            System.out.print(arrayList.get(j)+" ");
        }
    }
}

2、HashMap集合

1.1、每个集合对象的创建（new）
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合

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

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
 */
public class HashMapTest {
    public static void main(String[] args) {
        // 创建 HashMap 集合
        HashMap<Integer,String> hashMap = new HashMap<>();
        // 向集合中添加元素
        hashMap.put(1,"zhangsan");
        hashMap.put(2,"lisi");
        hashMap.put(3,"wangwu");
        hashMap.put(4,"zhaoliu");
        // 从集合中取出某个元素
        String s = hashMap.get(1);
        System.out.println(s);
        // 遍历集合 获取所有的key，然后通过key获取value
        Set<Integer> it = hashMap.keySet();
        for (Integer integer : it) {
            System.out.println(integer + " =" + hashMap.get(integer));
        }
        System.out.println("===============分割线============");
        // 遍历集合 通过 调用 entrySet方法 得到一个 Set
        Set<Map.Entry<Integer, String>> entries = hashMap.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            System.out.println(entry.getKey() + " =" + entry.getValue());
        }
    }
}

3、Properties集合

1.1、每个集合对象的创建（new）
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合

import java.util.Properties;

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
 */
public class PropertiesTest {
    public static void main(String[] args) {
        // 创建 Properties 集合，只支持 String 类型
        Properties properties = new Properties();
        // 向集合中添加元素 基本数据类型自动装箱
        properties.put("你","zhangsan");
        properties.put("好","lisi");
        properties.put("世","wangwu");
        properties.put("界","zhaoliu");
        // 从集合中取出某个元素
        String property = properties.getProperty("你");
        // 遍历 Properties 集合 通过stringPropertyNames()方法获取所有的key
        System.out.println(property);
        for (String key : properties.stringPropertyNames()) {
            System.out.println(key + " ="+ properties.getProperty(key));
        }
    }
}

4、TreeSet集合

1.1、每个集合对象的创建（new）
1.2、向集合中添加元素
1.3、从集合中取出某个元素
1.4、遍历集合
1.5、测试TreeSet集合中的元素是可排序的。
1.6、测试TreeSet集合中存储的类型是自定义的。
1.7、测试实现Comparable接口的方式
1.8、测试实现Comparator接口的方式（最好测试以下匿名内部类的方式）

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/*
    1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
	1.5、测试TreeSet集合中的元素是可排序的。
	1.6、测试TreeSet集合中存储的类型是自定义的。
	1.7、测试实现Comparable接口的方式
	1.8、测试实现Comparator接口的方式（最好测试以下匿名内部类的方式）
 */
public class TreeSetTest {
    public static void main(String[] args) {
        // 创建 TreeSet 集合
        TreeSet<String> treeSet = new TreeSet<>();
        // 向集合中添加元素
        treeSet.add("zhangsan");
        treeSet.add("lisi");
        treeSet.add("wangwu");
        treeSet.add("zhaoliu");
        // 从集合中取出元素 转为 ArrayList 集合通过下标取出
        ArrayList arr = new ArrayList(treeSet);
        System.out.println(arr.get(0));
        System.out.println("===============分割线============");
        // 集合遍历 获取迭代器遍历
        Iterator<String> it = treeSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("===============分割线============");
        // 遍历集合 通过增强for
        for (String s : treeSet) {
            System.out.println(s);
        }
        System.out.println("===============分割线============");
        // 测试TreeSet集合中的元素是可排序的
        TreeSet<Integer> treeSet1 = new TreeSet<>();    // 结果 1 2 3 4
        treeSet1.add(2);
        treeSet1.add(4);
        treeSet1.add(1);
        treeSet1.add(3);
        for (Integer integer : treeSet1) {
            System.out.println(integer);
        }
        System.out.println("===============分割线============");
        //测试TreeSet集合中存储的类型是自定义的
       /* TreeSet<A> treeSet2 = new TreeSet<>();
        treeSet2.add(new A(1));
        treeSet2.add(new A(3));
        treeSet2.add(new A(2));
        treeSet2.add(new A(4));
        //遍历集合
        for (A a : treeSet2) {
            System.out.println(a);
        }*/
        /* 会报
         Exception in thread "main"
         java.lang.ClassCastException: Gather.GatherZoJie.A cannot be cast to java.lang.Comparable
         这个异常，原因是类未实现Comparable接口
        */
        System.out.println("===============分割线============");
        // 测试实现Comparable接口的方式
        TreeSet<B> treeSet3 = new TreeSet<>();
        treeSet3.add(new B(1));
        treeSet3.add(new B(3));
        treeSet3.add(new B(2));
        treeSet3.add(new B(4));
        // B 类以实现 Comparable 接口,同时重写了 toString 方法
        // 遍历
        for (B b : treeSet3) {
            System.out.println(b);
        }
        // 遍历结果是按 重写的compareTo方法的排序方式进行排序
        System.out.println("===============分割线============");
        //测试实现Comparator接口的方式（最好测试以下匿名内部类的方式）
        // 比较器方法
        TreeSet<C> treeSet4 = new TreeSet<>(new Comparator<C>() {
            @Override
            public int compare(C o1, C o2) {
                return o1.age - o2.age;
            }
        });
        treeSet4.add(new C(1));
        treeSet4.add(new C(3));
        treeSet4.add(new C(2));
        treeSet4.add(new C(4));
        // 遍历
        for (C c : treeSet4) {
            System.out.println(c);
        }
        // 输出结果 1 2 3 4 以排序
    }
}
// 自定义类型A
class A{
    int age;
    public A(int age){
        this.age = age;
    }
}
// 自定义类型B,实现 Comparable 接口，重写 compareTo 排序方法
class B implements Comparable<B>{
    int age;
    public B(int age){
        this.age = age;
    }

    @Override
    public int compareTo(B o) {
        return this.age - o.age;
    }

    @Override
    public String toString() {
        return "B{" +
                "age=" + age +
                '}';
    }
}
// 自定义类型A
class C{
    int age;
    public C(int age){
        this.age = age;
    }
    @Override
    public String toString() {
        return "B{" +
                "age=" + age +
                '}';
    }
}

1、HashSet 底层 HashMap
2、TreeSet 底层 TreeMap