Java基础—集合_数据复写较慢-CSDN博客

本文链接：https://blog.csdn.net/u013704970/article/details/46330877

为什么有这么多的子类呢？

因为数据在计算机的存储方式是多样，所以需要定义不同的集合。由此可知，每个集合中的对象在计算机底层的存贮方式不一样，这个存储方式就是所谓的数据结构。

这些集合的数据结构分别是什么呢？

List和Set的区别：List集合元素是有序的，可以重复，每个元素都有索引；Set集合元素时无序的，不可以重复。
ArrayList：底层数据结构是数组结构，特征：查询快，增删慢，不同步JDK1.2出现的；
LinckedList：底层数据结构是链表数据结构，特征：查询慢，增删快；
Vector：底层数据结构是数据结构，特征：查询、增删都较慢，是同步的，JDK1.0出现。它有一个特有的方法：element()枚举法。
HashSet：底层数据结构是哈希表。HashSet是通过hashCode方法和equals方法来保证元素的唯一性的，所以在使用HashSet存储对象时，需要复写hashCode和equals方法。
TreeSet：底层数据结构是二叉树，可以对Set集合进行排序。排序方式有两种：一种是让对象自身具备排序功能，实现Comparable的接口，复写compareTo方法；第二种方法是让集合具有排序功能，定义一个类实现Comparator接口，复写compare方法，在新建集合时，就将该对象以参数的形式传递。注：排序时，当主要条件相同时，需要判断次要条件。

集合的基本操作

增加：boolean add(E e)
删除：
A、boolean remove(Object o)
B、void clear()//清空集合
获取：
A、int size()//获取Collection的元素数
B、Iterator iterator()//返回在此Collection的元素上进行迭代的迭代器。
判断：
A、boolean contains(Object o)//如果此Collection包含指定元素，返回true；
B、boolean isEmpty()//如果Collection集合为空，则返回true
高级for： for(数据类型变量名：被遍历的对象)
被遍历的对象：集合(Collection)或者数组，不可以修改只可以遍历，一定要有遍历对象。

集合的练习

ArrayList：

/*
ArrayList的练习：
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。


思路：
1、对人描述，将数据封装进人对象。
2、定义容器，将人存入。
3、因为List集合是可以重复的，所以调用add的时候不会判断元素是否相同，
   所以需要手动定义一个功能来判断元素是否相同。remove和contains方法
   才会自动判断元素是否相同。
4、取出。



注：List集合判断元素是否相同，依据是元素的equals方法。



*/
import java.util.*;
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String toString()
    {
        return name+";;"+age;
    }
    //Object中的equals方法是比较地址值，所以需要手动复写equals方法，而且不能用泛型
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            throw new ClassCastException("该类不是人类！");
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
}
class  ArrayListTest
{
    public static void main(String[] args) 
    {
        //定义ArrayList集合
        ArrayList<Person> al = new ArrayList<Person>();
        //想集合中存入对象
        al.add(new Person("xiaozhang",20));
        al.add(new Person("xiaoli",21));
        al.add(new Person("xiaoxia",22));
        al.add(new Person("xiaoxiao",23));
        al.add(new Person("xiaoxue",24));
        al.add(new Person("xiaozhang",20));

         //去除相同元素
        al = SingleElement(al);

        //用迭代器将集合中的元素打印
        Iterator<Person> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().toString());
        }
    }
    //定义去除相同元素的方法
    public static ArrayList<Person> SingleElement(ArrayList<Person> al)
    {
        ArrayList<Person> newAl = new ArrayList<Person>();
        Iterator<Person> it = al.iterator();
        while(it.hasNext())
        {
            //如果直接用next来代替，就会出现判断该元素，添加下一个元素
            Person p = it.next();
            if(!newAl.contains(p))
                newAl.add(p);
        }
        return newAl;
    }
}

LinkedList：

/*
使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出  如同一个杯子。
队列：先进先出 First in First out  FIFO 如同一个水管。
LinkedList特有的方法：                     JDK1.6
void addFirst(E e)//在第一位添加元素       boolean offerFirst(E e)
void addLast（E e）//在末尾添加元素        boolean offerLast(E e)
E getFirt()//获取第一个元素                E peekFirst()
E getLast()//获取最后一个元素              E peekLast()
E removeFirst()//从开头处获取元素并移除    E pollFirst()
E removeLast()//从末尾处获取元素并移除     E pollLast()
*/
import java.util.*;
//定义一个类，将队列数据结构实现的功能封装进来
class DuiLie
{
    private LinkedList<String> link;
    DuiLie()
    {
        link = new LinkedList<String>();
    }
    public void myAdd(String obj)
    {
        link.add(obj);
    }
    public void getObject()
    {
        System.out.println(link.remove());
    }
    public boolean isEmpty()
    {
        return link.isEmpty();
    }
}
//定义一类将堆栈数据结构实现的功能封装进来
class DuiZhan
{
    private LinkedList<String> link ;
    DuiZhan()
    {
        link = new LinkedList<String>();
    }
    public void myAdd(String obj)
    {
        link.add(obj);
    }
    public void getObject()
    {
        System.out.println(link.removeLast());
    }
    public boolean isEmpty()
    {
        return link.isEmpty();
    }
}
class  LinkedListTest
{
    public static void main(String[] args) 
    {
        System.out.println("用linkedList模仿队列数据结构");
        DuiLie dl = new DuiLie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");

        while(!(dl.isEmpty()))
        {
            dl.getObject();
        }
        System.out.println("用linkedList模仿堆栈数据结构");
        DuiZhan dz = new DuiZhan();
        dz.myAdd("java01");
        dz.myAdd("java02");
        dz.myAdd("java03");
        dz.myAdd("java04");

        while(!(dz.isEmpty()))
        {
            dz.getObject();
        }
    }
}

HashSet：

/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。

Set集合中不能有重复的元素，所以add方法在添加之前会判断元素是否已在集合中，
所以只需要复写判断元素是否相同的方法：hashCode和equals。

Set集合判断元素是否相同：先判断hashCode值，如果相同再通过equals判断是否是同一元素，
所以需要这两个的方法。
*/
import java.util.*;
class Student
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String toString()
    {
        return name+";;"+age;
    }
    //复写hashCode方法，为了减少调用equals的概率，最好将hashCode的值设置为判断元素是否
    //相同的条件的值。age*27更能提高效率。
    public int hashCode()
    {
        return name.hashCode()+age*27;
    }
    //复写equals方法，不能用泛型，因为在Object中就没用泛型
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Student))
            throw new ClassCastException("不是学生类，请重新输入！");
        Student s = (Student)obj;
        return this.name.equals(s.name) && this.age == s.age;
    }
}
class HashSetTest
{
    public static void main(String[] args) 
    {
        //用泛型定义集合
        HashSet<Student> hs = new HashSet<Student>();
        //添加对象
        hs.add(new Student("xiaozhang",20));
        hs.add(new Student("xiaoli",19));
        hs.add(new Student("xiaoyang",18));
        hs.add(new Student("xiaoxiao",24));
        hs.add(new Student("xiaozhang",20));

        //用迭代器取出元素
        Iterator<Student> it = hs.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().toString());
        }
    }
}

TreeSet：可以对元素进行排序，不可重复

/*
  将学生对象存储到TreeSet集合中，要求：学生对象有默认的排序方式，按照姓名排序。
  现在要按照年龄来排序。
  分析：定义一个学生类，并实现Comparable接口，复写compareTo方法（需要传入另一个学生对象），
        因为此题不用默认的排序方式对集合排序，所以需要让集合具备排序功能，定义一个类，实现
        Comparator接口，复写compare方法（需要传入两个学生对象）。

  步骤：1、定义学生类；
        2、定义一个比较器；
        3、建立集合，并向其存放学生对象；
        4、取出学生对象。

 注：两种排序方式并存，以比较器为主。排序的时，如果主要条件一样，需要判断次要条件，
     排序的同时，也保证了元素的唯一性。

 其他说明：String、Integer类中，已复写了eqauls、hashCode、compareTo方法，
           所以直接拿来使用就可以了。
*/
import java.util.*;
//定义学生类
class Student implements Comparable<Student>
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String toString()
    {
        return name+"::"+age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    //复写compareTo方法
    public int compareTo(Student s)
    {
        int num = this.name.compareTo(s.name);
        if(num == 0)
            return new Integer(this.age).compareTo(new Integer(s.age));
        return num;
    }
}
//定义比较器，并以参数的形式传递给TreeSet的构造函数
class MyCompare implements Comparator<Student>
{
    public int compare(Student s1,Student s2)
    {
        int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
        if(num == 0)
            return s1.getName().compareTo(s2.getName());
        return num;
    }
}
class TreeSetTest
{
    public static void main(String[] args) 
    {
        //定义集合
        TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());
        //向集合中存储学生对象
        ts.add(new Student("zhangsan",20));
        ts.add(new Student("lisi",21));
        ts.add(new Student("xiaoli",23));
        ts.add(new Student("小斯",24));
        ts.add(new Student("lisi",21));

        //因为只是取出元素，不修改，所以用高级far
        for(Student s : ts)
        {
            System.out.println(s.toString());
        }
    }
}