1、Collection集合的继承结构图、以及各个集合的特性和数据结构。

java集合设置对象属性 java集合创建方式_泛型

      Map集合的继承结构图

java集合设置对象属性 java集合创建方式_泛型_02

 

2、 关于java.util.Collection接口中常用的方法

         Collection中存放的元素：没有泛型--->Object（老祖宗）的所有子类型

                                                  有泛型--->只能存储某个具体的类型。

Collection中的常用方法

boolean

add(Object o)

向集合中添加元素

int       

size()

获取集合中元素的个数

void

clear()

清空集合

boolean

contains(Object o)

判断当前集合中是否包含o，包含返回true，不包含返回false

boolean        

remove(Object o)

删除集合中的某个元素

boolean

isEmpty()

判断该集合中元素的个数是否为0

Object[ ]

toArray()

把集合转换成数组

  JDK1.8的中文文档：

链接：https://pan.baidu.com/s/1J0pTghuqXDIsPWRe7GZniQ 
提取码：zsbl

3.1、创建没有带有泛型的集合。

// 创建List类型的集合。
        List myList = new LinkedList();
        List myList = new Vector();
        List myList = new ArrayList();


        // 创建Set类型的集合。
        Set set = new HashSet();
        Set set = new TreeSet();

 3.2、引入泛型机制

        引入泛型的好处：


第一：集合中存储的元素类型统一了。 第二：从集合中取出来的元素类型是泛型指定的类型，不需要进行大量的“向下转型”（强制类型转换）。


List<Animal> myList = new ArrayList<Animal>();

没有泛型机制的迭代器写法：

Iterator it = myList.iterator();
        while(it.hasNext()){
            Object obj = it.next();
            // obj中没有move方法，无法调用，需要向下转型！
            Animal a = (Animal)obj;
            a.move();
        }

有了泛型机制的迭代器写法： 

Iterator<Animal> it = myList.iterator();
        while(it.hasNext()){
            // 使用泛型之后，每一次迭代返回的数据都是Animal类型。
            Animal a = it.next();
            // 这里不需要进行强制类型转换了。直接调用。
            a.move();
        }

 3.3、创建带有泛型的集合。

//创建集合对象
        ArrayList<String> list = new ArrayList<>();

        LinkedList<String> list = new LinkedList<>();

        Map<Integer,String> map = new HashMap<>();

        HashSet<String> set = new HashSet<>();

        TreeSet<Integer> ts = new TreeSet<>();

 3.4、附上代码测试集合

3.4.1、ArrayList

遍历方式：迭代器、for下标、增强foreach

package test;

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

/*
	1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
 */
public class ArrayListTest {
    public static void main(String[] args) {
        //创建集合对象
        //ArrayList<String> list = new ArrayList<>();
        LinkedList<String> list = new LinkedList<>();
        //添加元素
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        //从集合中取出某个元素
        //List集合有下标
        String firstElt = list.get(0);
        System.out.println(firstElt);
        //遍历(下标方式)
        for (int i = 0; i < list.size(); i++) {
            String elt = list.get(i);
            System.out.println(elt);
        }
        //遍历(迭代器方式，这个是通用的，所有的Collection都通用。)
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String elt = it.next();
            System.out.println(elt);
        }
        // 遍历(foreach方式)
        for (String s : list){
            System.out.println(s);
        }
    }
}

3.4.2、HashMap

为了保证HashMap的特点：无序不可重复

要进行同时重写hashCode()和equals()方法

注意：Integer、String等类型的hashCode和equals放都已经被SUN写好，无需重写了。

package test;

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) {
        //创建Map集合
        Map<Integer,String> map = new HashMap<>();
        //添加元素
        map.put(1,"zhangsan");
        map.put(9,"lisi");
        map.put(10,"wangwu");
        map.put(2,"king");
        map.put(2,"simth"); // key重复value会覆盖。
        //获取元素个数
        System.out.println(map.size());//4
        //取key是2的元素
        System.out.println(map.get(2)); //simth

        //第一种方式：先获取所有的key，遍历key的时候，通过key获取value
        Set<Integer> keys = map.keySet();
        for (Integer key : keys){
            System.out.println(key + "=" + map.get(key));
        }
        //第二种方式：是将Map集合转换成Set集合，Set集合中每一个元素都是Node
        //这个Node节点中有key和value
        Set<Map.Entry<Integer,String>> nodes = map.entrySet();
        for (Map.Entry<Integer,String> node : nodes){
            System.out.println(node.getKey() + "=" + node.getValue());
        }
    }
}

3.4.3、HashSet

遍历方式：迭代器、增强foreach

放到HashMap集合key部分的元素其实就是HashSet集合中了。

所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。

        用IDEA集成工具直接生成即可。

当存储的是非Integer、String等类型，是自定义类型时：

package test;

import java.util.*;

/*
	1.1、每个集合对象的创建（new）
	1.2、向集合中添加元素
	1.3、从集合中取出某个元素
	1.4、遍历集合
	1.5、测试HashSet集合的特点：无序不可重复。
 */
public class HashSetTest {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> set = new HashSet<>();

        //添加元素
        set.add("abc");
        set.add("def");
        set.add("king");

        //set集合中的元素不能通过下标取了。没有下标
        //遍历集合(迭代器)
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        //遍历集合（foreach）
        for (String s : set){
            System.out.println(s);
        }

        set.add("king");
        set.add("king");
        set.add("king");
        System.out.println(set.size()); // 3 (后面3个king都没有加进去。)

        set.add("1");
        set.add("10");
        set.add("2");

        for(String s : set){
            System.out.println("---->" + s);
        }

        // 创建Set集合，存储Student数据
        Set<Student> students = new HashSet<>();
        Student s1 = new Student(111,"zhangsan");
        Student s2 = new Student(222,"lisi");
        Student s3 = new Student(111,"zhangsan");
        students.add(s1);
        students.add(s2);
        students.add(s3);

        System.out.println(students.size()); // 2

        //遍历
        for (Student stu : students){
            System.out.println(stu);
        }
    }
}

class Student{
    int no;
    String name;

    public Student() {
    }

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

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

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

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

3.4.4、TreeSet

遍历方式：迭代器、增强foreach

TreeSet集合中存储自定义类型：

        需要实现对存储的自定类型进行（比较）。        

实现比较的两种方式：

        （1）实现Comparable接口。 

class A implements Comparable<A>{

       public int compareTo(A o) {

        }
}

        （2）实现Comparator接口。（比较器）

        采用实现接口的方式：

class BComparator implements Comparator<B>{

    @Override
    public int compare(B o1, B o2) {
         
    }
}

        采用匿名内部类的方式：

TreeSet<B> bTree = new TreeSet<>(new Comparator<B>() {
            @Override
            public int compare(B o1, B o2) {

            }
        });

 

package test;

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集合中存储String、Integer的。这些类都是SUN写好的。）
        //TreeSet<Integer> ts = new TreeSet<>();

        //编写比较器可以改变规则。
        TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1; // 自动拆箱
            }
        });

        //添加元素
        ts.add(1);
        ts.add(100);
        ts.add(10);
        ts.add(10);
        ts.add(10);
        ts.add(10);
        ts.add(0);

        //遍历（迭代器方式）
        Iterator<Integer> it = ts.iterator();
        while(it.hasNext()){
            Integer i  = it.next();
            System.out.println(i);
        }

        //遍历（foreach）
        for (Integer integer : ts){
            System.out.println(integer);
        }

        //TreeSet集合中存储自定义类型
        TreeSet<A> aTree = new TreeSet<>();
        aTree.add(new A(100));
        aTree.add(new A(200));
        aTree.add(new A(500));
        aTree.add(new A(300));
        aTree.add(new A(400));
        aTree.add(new A(1000));

        //遍历
        for (A a : aTree){
            System.out.println(a);
        }

        //TreeSet<B> bTree = new TreeSet<>(new BComparator());
        //匿名内部类的方式
        TreeSet<B> bTree = new TreeSet<>(new Comparator<B>() {
            @Override
            public int compare(B o1, B o2) {
                return o1.i - o2.i;
            }
        });

        bTree.add(new B(500));
        bTree.add(new B(100));
        bTree.add(new B(200));
        bTree.add(new B(600));
        bTree.add(new B(300));
        bTree.add(new B(50));

        for (B b : bTree){
            System.out.println(b);
        }

        Iterator<B> it2 = bTree.iterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
    }
}

//第一种方式：实现Comparable接口。
class A implements Comparable<A>{
    int i;
    public A(int i){
        this.i = i;
    }

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

    @Override
    public int compareTo(A o) {
        //return this.i - o.i; //升序
        return o.i - this.i; // 降序
    }
}


//第二种方式：

class B{
    int i;
    public B(int i){
        this.i = i;
    }

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

//比较器
class BComparator implements Comparator<B>{

    @Override
    public int compare(B o1, B o2) {
        return o1.i - o2.i;
    }
}