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());

        }

    }

}

巴特西

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

最新文章

热门文章