java：容器/集合Collection（List（ArrayList，LinkedList，Vector），Set（HashSet（LinkedHashSet），TreeSet））

/**
* Collection接口  不唯一，无序
* 常用的方法:
* add(Object e) 确保此 collection 包含指定的元素（可选操作）。
* size():获取集合中元素的个数
* remove(Object e):移除元素
* clear():清空集合中元素
* contains(Object e):判断集合中是否包含指定的元素
* isEmpty():判断集合是否为空
* iterator():获取集合对应的迭代器。
* --List接口:不唯一,有序(插入顺序)
* ----ArrayList类:可变长度的数组,本质上是通过数组实现的，在内存中存储空间是连续
* ------优点:随机访问或遍历时效率较高
* ------缺点:插入和删除时需要大量对元素的位置进行移动，效率较低。
* ArrayList常用的构造方法
* ArrayList() 构造一个初始容量为 10 的空列表。
* ArrayList(int initialCapacity) 构造一个具有指定初始容量的空列表。
* 常用的方法:
* add(Object e):将元素添加到集合中。
* add(int index, E element) 将指定的元素插入此列表中的指定位置。
* get(int index) 返回此列表中指定位置上的元素。下标从0开始
* --Set接口:唯一,无序
* Map接口:采用键值对进行存储。
*/

import java.util.ArrayList;
import java.util.List;

public class TestArrayList {
    public static void main(String[] args) {
//        Collection list = new ArrayList();
        List list = new ArrayList();
        //添加元素
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add(,"dd");
        //遍历输出
        for(int i=;i<list.size();i++){
            String string =(String)list.get(i);
            System.out.println(string);
        }
    }
}

*java.util.ArrayList类
*add(Object obj):添加元素
*Object get(int index):获取指定下标位置的元素.
*注意:在调用add方法添加元素时，该元素会向上转型为Object类型，所有使用get方法获取是返回值为Object

import java.util.ArrayList;
import java.util.List;

public class TestArrayList2 {
    public static void main(String[] args) {
        Student student = new Student("zhangsan",);
        Student student2 = new Student("zhangsan2",);
        Student student3 = new Student("zhangsan3",);
        List list = new ArrayList();
        list.add(student);
        list.add(student2);
        list.add(student3);
        //遍历输出
        for(int i=;i<list.size();i++){
            Student stu=(Student)list.get(i);//强制转换
            System.out.println(stu.getName()+"---"+stu.getAge());
        }
        System.out.println("-----------");
        for(Object obj:list){
            Student stu = (Student)obj;
            System.out.println(stu.getName()+"---"+stu.getAge());
        }
     }
}

* java.util.Iterator接口：对 collection 进行迭代的迭代器。
* boolean hasNext() 如果仍有元素可以迭代，则返回 true。
* E next() 返回迭代的下一个元素。

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;
    }

}

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

public class TestIterator {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("zhang");
        list.add("wang");
        list.add("li");
        list.add("zhao");
        //使用迭代器进行遍历
        Iterator<String> iter = list.iterator();
        //判断是否还有下一个元素可迭代
        while(iter.hasNext()){
            String str = iter.next();//获取下一个元素
            System.out.println(str);
        }
        System.out.println("---------老外习惯用for进行迭代--------");
        for(Iterator<String> iter2=list.iterator();iter2.hasNext();){
            String str2 = iter2.next();
            System.out.println(str2);
        }

    }
}

* 泛型:限定集合中元素的类型。一旦对集合使用泛型，该集合中能容纳的元素类型就固定了。
* 语法:List<E> list = new ArrayList<E>();
* 优点:1.可以避免强制转换
* 　　 2.可以消除黄色的警告。

import java.util.ArrayList;
import java.util.List;

public class TestArrayList3 {
    public static void main(String[] args) {
        Student student = new Student("zhangsan",);
        Student student2 = new Student("zhangsan2",);
        Student student3 = new Student("zhangsan3",);
        List<Student> list = new ArrayList<Student>();
        list.add(student);
        list.add(student2);
        list.add(student3);
//        list.add(123);
//        list.add("abc");
        //遍历输出
        for(int i=;i<list.size();i++){
            Student stu=list.get(i);//使用泛型后不需要强制转换
            System.out.println(stu.getName()+"---"+stu.getAge());
        }
        System.out.println("-----------");
        for(Student stu:list){
            System.out.println(stu.getName()+"---"+stu.getAge());
        }
     }
}

* List接口
* ----ArrayList类:在内存中存储位置是连续的，线性结构(可变长度的数组),随机访问或遍历效率较高,但插入和删除元素效率较低.
* ----LinkedList类:在内存中存储位置是不连续的，链表结构，插入和删除元素时效率较高,但随机访问或遍历效率较低。
* 常用方法:
* add(Object o):将指定元素添加到此列表的结尾。
* add(int index, E element)在此列表中指定的位置插入指定的元素。
* addFirst(E e) 将指定元素插入此列表的开头。(LinkedList特有的)
* addLast(E e)将指定元素添加到此列表的结尾。(LinkedList特有的)
* getFirst() 返回此列表的第一个元素。
* getLast() 返回此列表的最后一个元素。
* removeFirst() 移除并返回此列表的第一个元素。
* removeLast() 移除并返回此列表的最后一个元素。

LinkedList

public class TestLinkedList {
    public static void main(String[] args) {
//        List list = new LinkedList();
        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add("java");
        linkedList.add("oracle");
        linkedList.addFirst("c");
        linkedList.addLast("html");
        linkedList.removeFirst();//移除第一个元素
        linkedList.removeLast();//移除最后一个元素
        //方法1:通过下标进行遍历
        for (int i = ; i < linkedList.size(); i++) {
            String str = linkedList.get(i);
            System.out.println(str);
        }
        System.out.println("-------------");
        //方法2:通过foreach进行遍历
        for (String string : linkedList) {
            System.out.println(string);
        }
        System.out.println("-------------");
        //方法3:通过iterator进行遍历
        Iterator<String> iter = linkedList.iterator();
        while(iter.hasNext()){
            String string = iter.next();
            System.out.println(string);
        }

    }
}

模拟进栈出栈：

进出统一。

*栈LIFO/FILO:后进先出(Last In First Out),先进后出(First In Last Out)
* 类似于玩具枪的弹夹，第一个压进去的子弹最后一个弹出
*入栈(压栈):将元素添加到栈中。
*出栈(弹栈):将元素从栈的顶部移除。
*队列FIFO:先进先出(First In First Out)

public class MyStack {
    LinkedList linkedList = new LinkedList();
    //入栈:将新元素添加到最后
    public void push(Object obj){
//        linkedList.addLast(obj);
        linkedList.addFirst(obj);
    }
    //出栈:
    public Object pop(){
//        Object obj = linkedList.removeLast();
        Object obj = linkedList.removeFirst();
        return obj;
    }

    public static void main(String[] args) {
        MyStack stack = new MyStack();
        stack.push("aa");
        stack.push("bb");
        stack.push("cc");
        Object obj = stack.pop();
        System.out.println(obj);
        Object obj2 = stack.pop();
        System.out.println(obj2);
        Object obj3 = stack.pop();
        System.out.println(obj3);

    }

}

Vector：

* ---ArrayList:线性结构，非线程安全，效率较高，随机访问或遍历时效率较高，添加和删除时效率较低
* ---Vector:线性结构，与ArrayList相似，Vector是线程安全的用在多线程程序中,相比ArrayList效率较低。
* ---LinkedList:链表结构,添加和删除时效率较高，随机访问或遍历时效率较低

import java.util.List;
import java.util.Vector;

public class TestVector {
    public static void main(String[] args) {
        List<String> vector = new Vector<String>();
        vector.add("java");
        vector.add("oracle");
        vector.add("mysql");
        for (String string : vector) {
            System.out.println(string);
        }
    }
}

Set:

*Set接口:无序，唯一(不重复)
*----HashSet:采用hash表(散列表)方式进行存储数据。
* 优点:查询，添加，删除速度较快。
* 缺点:无序(添加顺序)
*常用的构造方法:
* HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
* HashSet(int initialCapacity) 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。
*常用的方法:
* add(E e)如果此 set 中尚未包含指定元素，则添加指定元素。
* clear() 从此 set 中移除所有元素。
* contains(Object o) 如果此 set 包含指定元素，则返回 true。
* iterator() 返回对此 set 中元素进行迭代的迭代器。
* size()返回此 set 中的元素的数量（set 的容量）。
* remove(Object o)如果指定元素存在于此 set 中，则将其移除。

public class TestHashSet {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("java");
        set.add("mysql");
        set.add("html");
        set.add("java");//添加时会去掉重复项
        System.out.println("共有"+set.size()+"个元素");
        //遍历1:通过for-each遍历
        for(String str:set){
            System.out.println(str);
        }
        System.out.println("---------------");
        Iterator<String> iter = set.iterator();
        while(iter.hasNext()){
            String str = iter.next();
            System.out.println(str);
        }
    }
}

*如果向set结合添加对象时，想将内容相同的重复项去掉，需要重写hashCode()和equals()
*hashCode()和equals()的关系
*在向Set集合中添加元素时 ，先调用hashCode()方法获取当前对象的hash码,
*根据对象的hash码与集合中对象的hash码进行比较,如果hash码相同在调用equals()方法进行比较内容是否相同。
*如果hash码不同，将不再调用equals方法。
*如果equals相同，hash码肯定相同;hash码相同，equals结果不一定相同。

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;
    }

    /**
     * 重写Object中的hashCode方法
     */
    @Override
    public int hashCode() {
        System.out.println("hashCode.....");
        final int prime = ;
        int result = ;
        result = prime * result + age;
        result = prime * result + ((name == null) ?  : name.hashCode());
        return result;
    }

    /**
     * 重写Object中equals方法:用于比较两个对象的内容是否相同
     */
    @Override
    public boolean equals(Object obj) {
        System.out.println("equals.....");
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())//类型不同
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

}

import java.util.HashSet;
import java.util.Set;

public class TestHashSet2 {
    public static void main(String[] args) {
        Student stu1 = new Student("zhangsan",);
        Student stu2 = new Student("zhangsan2",);
        Student stu3 = new Student("zhangsan",);
        Set<Student> set = new HashSet<Student>();
        set.add(stu1);
        set.add(stu2);
        set.add(stu3);
        for (Student student : set) {
            System.out.println(student.getName()+"---"+student.getAge());
        }
    }
}

LinkedHashSet:

*Set接口:唯一，无序(插入顺序)
*--HashSet:采用的哈希表的方式进行存储
*----LinkedHashSet:哈希表+链表结构进行存储。有序(添加顺序)。
*常用的构造方法
*LinkedHashSet() 构造一个带默认初始容量 (16) 和加载因子 (0.75) 的新空链接哈希 set
*LinkedHashSet(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的新空链接哈希 set。
*常用的方法:
* add(Object a):添加元素
* remove(Object a):移除指定的元素
* contains(Object a):是否包含指定的元素
* size():获取元素的个数。
* iterator():返回一个迭代器

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class TestLinkedHashSet {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<String>();
        set.add("java");
        set.add("struts");
        set.add("hibernate");
        set.add("spring");
//        System.out.println(set);
        for (String string : set) {
            System.out.println(string);
        }
        System.out.println("-----------------");
        Iterator<String> iter = set.iterator();
        while(iter.hasNext()){
            String string = iter.next();
            System.out.println(string);
        }
    }
}

TreeSet:

* TreeSet类:采用的二叉树(红黑树)的方式存储，有序(大小顺序|自然顺序)。
* 原理:当向TreeSet容器添加元素时，会将当前元素的值与根节点/父节点的值进行比较，
* 如果比根节点/父节点的值大，保存在右子节点上。
* 如果比根节点/父节点的值小，保存在左子节点上。
* 优点:有序，查询速度比List要快(折半查找)。
* 常用的构造方法:
* TreeSet() 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
* TreeSet(Comparator<? super E> comparator)构造一个新的空 TreeSet，它根据指定比较器进行排序。
* 常用的方法:
* add(Object o):添加元素
* remove(Object o):移除元素
* contains(Object o) 如果此 set 包含指定的元素，则返回 true。
* size():返回 set 中的元素数（set 的容量）。
* iterator():返回在此 set 中的元素上按升序进行迭代的迭代器

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet {
    public static void main(String[] args) {
        Set<Integer> treeSet=new TreeSet<Integer>();
        treeSet.add();
        treeSet.add();
        treeSet.add();
        treeSet.add();
        //遍历:for-each
        for (Integer integer : treeSet) {
            System.out.println(integer);
        }
        System.out.println("--------------------");
        //遍历2:使用迭代器
        Iterator<Integer> iter = treeSet.iterator();
        while(iter.hasNext()){
            Integer i = iter.next();
            System.out.println(i);
        }

    }
}

根据内部Coparable接口定义的方法比较：

重写compareTo

public class Student implements Comparable<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 int hashCode() {
        final int prime = ;
        int result = ;
        result = prime * result + age;
        result = prime * result + ((name == null) ?  : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    /**
     * 定义比较规则:
     * 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数
     */
    @Override
    public int compareTo(Student o) {
//        if(age>o.age){
//            return 1;
//        }else if(age==o.age){
//            return 0;
//        }else{
//            return -1;
//        }
        return age-o.age;
    }

}

import java.util.TreeSet;
/**
 * TreeSet:使用元素的自然顺序对元素进行排序，
 * 或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
 *  TreeSet():构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。插入该 set 的所有元素都必须实现 Comparable接口
 *
 */
public class TestTreeSet {
    public static void main(String[] args) {
        TreeSet<Student> treeSet = new TreeSet<Student>();
        Student stu1 = new Student("zhangsan",);
        Student stu2 = new Student("zhangsan2",);
        Student stu3 = new Student("zhangsan3",);
        treeSet.add(stu1);
        treeSet.add(stu2);
        treeSet.add(stu3);
        for (Student student : treeSet) {
            System.out.println(student.getName()+"---"+student.getAge());
        }
    }
}

实现Comparator接口，定义比较器比较

import java.util.Comparator;

public class TeacherComparator implements Comparator<Teacher> {
    /**
     * 比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
     */
    @Override
    public int compare(Teacher arg0, Teacher arg1) {
        return -(arg0.getWorkOfYear()-arg1.getWorkOfYear());
    }

}

public class Teacher {
    private String name;
    private int workOfYear;//工作年限

    public Teacher(String name, int workOfYear) {
        this.name = name;
        this.workOfYear = workOfYear;
    }

    public Teacher() {
        super();
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getWorkOfYear() {
        return workOfYear;
    }
    public void setWorkOfYear(int workOfYear) {
        this.workOfYear = workOfYear;
    }

}

import java.util.TreeSet;
/**
 * TreeSet(Comparator<? super E> comparator)  构造一个新的空 TreeSet，它根据指定比较器进行排序
 */
public class TestTreeSet2 {
    public static void main(String[] args) {
        TreeSet<Teacher> treeSet = new TreeSet<Teacher>(new TeacherComparator());
        Teacher t1 = new Teacher("aa", );
        Teacher t2 = new Teacher("bb", );
        Teacher t3 = new Teacher("cc", );
        treeSet.add(t1);
        treeSet.add(t2);
        treeSet.add(t3);
        for (Teacher teacher : treeSet) {
            System.out.println(teacher.getName()+"---"+teacher.getWorkOfYear());
        }
    }
}