集合中list、ArrayList、LinkedList、Vector的区别、Collection接口的共性方法以及数据结构的总结

List (链表|线性表)

特点：接口，可存放重复元素，元素存取是有序的，允许在指定位置插入元素，并通过索引来访问元素

1、创建一个用指定可视行数初始化的新滚动列表。默认情况下，不允许进行多项选择。

注意，这是 List(rows, false) 的一种便捷方法。还要注意，列表中的可视行数一旦创建就不能更改。

  public List(int rows)------------------row-----要显示的项数

2、创建一个初始化为显示指定行数的新滚动列表。

注意，如果指定了零行，则会按默认的四行创建列表。还要注意，列表中的可视行数一旦创建就不能更改。

如果 multipleMode 的值为 true，则用户可从列表中选择多项。如果为 false，则一次只能选择一项。

   public List(int rows,boolean multipleMode)-------rows - 要显示的项数。
                                             -------multipleMode - 如果为 true，则允许进行多项选择；否则，一次只能选择一项。

综上所述：如果抛出为throws-----GraphicsEnvironment.isHeadless()，则返回 true。

Set(集)

特点：不可以存放重复元素，元素存取是无序的

Collection（接口）

1、特点：描述的是集合共有的功能（描述所有接口的共性）

2、Collection接口有两个子接口：

List(链表|线性表)

Set(集)

集合整理

Collection

我们需要保存若干个对象的时候使用集合。

List

如果我们需要保留存储顺序, 并且保留重复元素, 使用List.

如果查询较多, 那么使用ArrayList

如果存取较多, 那么使用LinkedList

如果需要线程安全, 那么使用Vector

Set

如果我们不需要保留存储顺序, 并且需要去掉重复元素, 使用Set.

如果我们需要将元素排序, 那么使用TreeSet

如果我们不需要排序, 使用HashSet, HashSet比

TreeSet效率高.

如果我们需要保留存储顺序, 又要过滤重复元素, 那么使用LinkedHashSet

Collection接口的共性方法

增加：

1：add() 将指定对象存储到容器中

add 方法的参数类型是Object 便于接收任意对象

2：addAll() 将指定集合中的元素添加到调用该方法和集合中

删除：

3：remove() 将指定的对象从集合中删除

4：removeAll() 将指定集合中的元素删除

修改

5：clear() 清空集合中的所有元素

判断

6：isEmpty() 判断集合是否为空

7：contains() 判断集合何中是否包含指定对象

8：containsAll() 判断集合中是否包含指定集合

使用equals()判断两个对象是否相等

获取: 9：int size() 返回集合容器的大小

转成数组10： toArray() 集合转换数组

实例练习：

 1 //创建Person类
 2 class Person {
 3     private String name;
 4     private int age;
 5
 6     public Person() {
 7
 8     }
 9
10     public Person(String name, int age) {
11
12         this.name = name;
13         this.age = age;
14     }
15
16     @Override
17     public int hashCode() {
18         return this.name.hashCode() + age;
19     }
20
21     @Override
22     public boolean equals(Object obj) {
23         if (!(obj instanceof Person)) {
24             return false;
25         }
26         Person p = (Person) obj;
27         return this.name.equals(p.name) && this.age == p.age;
28     }
29
30     @Override
31     public String toString() {
32         return "Person :name=" + name + ", age=" + age;
33     }
34
35 }
36
37 public static void main(String[] args) {
38         Person p1 = new Person("李华", 19);
39         Person p2 = new Person("尹乐乐", 20);
40         Person p3 = new Person("洛洛", 18);
41         Collection list = new ArrayList();
42         list.add(p1);
43         list.add(p2);
44         list.add(p3);
45         // isEmpty() 判断集合是否为空
46         boolean empty = list.isEmpty();
47         System.out.println(empty);
48         // 返回集合容器的大小
49         int size = list.size();
50         System.out.println(size);
51          // contains()判断集合何中是否包含指定对象
52         boolean contains = list.contains(p1);
53         System.out.println(contains);
54
55         // remove(); 将指定的对象从集合中删除
56         list.remove(p1);
57
58         // clear() 清空集合中的所有元素
59         list.clear();
60         System.out.println(list);
61
62     }

分析总结:

1：Person类

1：姓名和年龄

2：重写hashCode和equals方法

1、如果不重写，调用Object类的equals方法，判断内存地址，为false

2、如果是Person类对象，并且姓名和年龄相同就返回true

3、如果不重写，调用父类hashCode方法，如果equals方法相同，那么hashCode也要相同，需要重写hashCode方法

3：重写toString方法

注：不重写，直接调用Object类的toString方法，打印该对象的内存地址

注：list、ArrayList、LinkedList、Vector的区别

1、List:元素是有序的(怎么存的就怎么取出来，顺序不会乱)，元素可以重复（角标1上有个3，角标2上也可以有个3）因为该集合体系有索引。

List：特有的方法，凡是可以操作角标的方法都是该体系特有的方法。

2、ArrayList：1、底层的数据结构使用的是数组结构（数组长度是可变的百分之五十延长）。

2、特点：是查询很快，但增删较慢，线程不同步（数组查询快的原因是：数组的内存空间地址是连续的）。

3、ArrayList底层维护了一个Object[] 用于存储对象，默认数组的长度是10，当默认的或者指定的容量不够存储对象的时候，容量自动增长为原来的容量的1.5倍。

4、单线程效率高。

实例：去除ArrayList集合中重复元素

1：存入字符串元素

2：存入自定义对象元素（如Perosn对象）

原理：

循环遍历该集合，每取出一个放置在新的集合中，放置之前先判断新的集合是否以包含了新的元素。

 public class Demo2 {
     public static void main(String[] args) {
         ArrayList arr = new ArrayList();
         Person p1 = new Person("jack", 20);
         Person p2 = new Person("rose", 18);
         Person p3 = new Person("rose", 18);
         arr.add(p1);
         arr.add(p2);
         arr.add(p3);
         System.out.println(arr);
         ArrayList arr2 = new ArrayList();
         for (int i = 0; i < arr.size(); i++) {
             Object obj = arr.get(i);
             Person p = (Person) obj;
             if (!(arr2.contains(p))) {
                 arr2.add(p);
             }
         }
         System.out.println(arr2);
     }
 }
 
 class Person {
     private String name;
     private int age;
 
     public Person() {
 
     }
 
     public Person(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() {
         return this.name.hashCode() + age * 37;
     }
 
     @Override
     public boolean equals(Object obj) {
         if (!(obj instanceof Person)) {
             return false;
         }
         Person p = (Person) obj;
 
         return this.name.equals(p.name) && this.age == p.age;
     }
 
     @Override
     public String toString() {
         return "Person@name:" + this.name + " age:" + this.age;
     }
 
 }

3、LinkedList：底层的数据结构是链表结构（特点是查询较慢，增删较快）。

特有方法：addFirst(E e)、getFirst(E e) 、removeFirst(E e)

如果集合中没有元素，获取或者删除元素抛：NoSuchElementException

4、Vector：1、底层是数组数据结构线程同步（数组长度是可变的百分之百延长），（无论查询还是增删都很慢，被ArrayList替代了）

2、多线程安全的，所以效率低。

3、特有的方法：

void addElement(E obj) 在集合末尾添加元素

E elementAt( int index) 返回指定角标的元素

Enumeration elements() 返回集合中的所有元素，封装到Enumeration对象中测试此枚举是否包含更多的元素。

E nextElement() 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

Enumeration 接口： boolean hasMoreElements()

注：1、可以使用该集合去模拟出队列(先进先出) 或者堆栈(后进先出) 数据结构，堆栈(后进先出)。

2、有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。

数据结构

1：栈（1.6）

先进后出

push()

pop()

2：队列（双端队列1.5）

先进先出

offer()

poll()

3：返回逆序的迭代器对象 descendingIterator() 返回逆序的迭代器对象

   //迭代
   import java.util.Iterator;
   import java.util.LinkedList;
 
   public class Demo3 {
       public static void main(String[] args) {
           LinkedList list = new LinkedList();
           list.add("微信");
           list.add("微博");
          list.add("淘宝");
          list.add("京东");
          list.add("阿里巴巴");
          Iterator it = list.iterator();
                 // Iterator it = list.descendingIterator();//逆序迭代
          while (it.hasNext()) {
              String next = (String) it.next();
              System.out.println(next);
          }
      }
  }