集合从入门到精通

java集合入门和深入学习，看这篇就差不多了

1、linkedhashset怎么保证存取有序的？

2、ArrayList如果在for循环下执行remove方法，会不会有问题？

答：会的。remove有两个重载方法，一个参数是具体存储的值，这个方法是不会的；另一个方法的参数是索引值，这个方法会出现索引越界问题。

存取有序的顺序是栈和队列的那个顺序？

一、集合概括

集合的最大目的就是存和取。

二、ArrayList集合

2.1、ArrayList的相关方法如下：

 @Test
    public void sss(){
        ArrayList arrayList = new ArrayList();
        arrayList.add("a");
        arrayList.add("b");

        //判断有几个元素
        int size = arrayList.size();
        //判断该ArrayList是否为空
        boolean empty = arrayList.isEmpty();
        //移除指定元素
        //boolean b = arrayList.remove("b");


        ArrayList arrayList2 = new ArrayList();
        arrayList2.add("c");
        //像另外一个ArrayList添加一个ArrayList
        arrayList.add(arrayList2);

        System.out.println(arrayList.toString());
    }

三、LinkedList集合

3.1、LinkedList集合演示栈的数据的存和取的顺序

package com.xiaoshitou.classtest;

import java.util.LinkedList;

/**
 * 利用LinkedList来模拟栈
 * 栈的特点：先进后出
 * @author Beck
 *
 */
public class MyStack {
    private LinkedList<String> linkList = new LinkedList<String>();
    
    // 压栈
    public void push(String str){
        linkList.addFirst(str);
    }
    
    // 出栈
    public String pop(){
        return linkList.removeFirst();
    }
    
    // 查看
    public String peek(){
        return linkList.peek();
    }
    
    // 判断是否为空
    public boolean isEmpty(){
        return linkList.isEmpty();
    }
}

package  好好学java;



public class Test {
    public static void main(String[] args) {
        // 测试栈
        StackTest stack = new StackTest();
        stack.push("我是第1个进去的");
        stack.push("我是第2个进去的");
        stack.push("我是第3个进去的");
        stack.push("我是第4个进去的");
        stack.push("我是第5个进去的");
        // 取出
        while (!stack.isEmpty()){
            String pop = stack.pop();
            System.out.println(pop);
        }
        // 打印结果
        /*我是第5个进去的
        我是第4个进去的
        我是第3个进去的
        我是第2个进去的
        我是第1个进去的*/
    }
    

}

3.2、LinkedList演示队列的数据的存和取的顺序

package  好好学java;

import java.util.LinkedList;

/**
 * 利用linkedList来实现队列
 * 队列: 先进先出
 * @author Beck
 *
 */
public class QueueTest {
    private LinkedList<String> link = new LinkedList<String>();
    
    // 放入
    public void put(String str){
        link.addFirst(str);
    }
    
    // 获取
    public String get(){
        return link.removeLast();
    }
    
    // 判断是否为空
    public boolean isEmpty(){
        return link.isEmpty();
    }
}
package  好好学java;

public class Test {
    public static void main(String[] args) {
        // 测试队列
        QueueTest queue = new QueueTest();
        
        queue.put("我是第1个进入队列的");
        queue.put("我是第2个进入队列的");
        queue.put("我是第3个进入队列的");
        queue.put("我是第4个进入队列的");
        
        // 遍历队列
        while (!queue.isEmpty()){
            String str = queue.get();
            System.out.println(str);
        }
        // 打印结果
        /*我是第1个进入队列的
        我是第2个进入队列的
        我是第3个进入队列的
        我是第4个进入队列的*/

    }
    

}

四、集合Set

4.1、Set集合是怎么保证元素唯一的？

那哈希表是怎么来保证元素的唯一性的呢，哈希表是通过hashCode和equals方法来共同保证的。

哈希表的存储数据过程（哈希表底层也维护了一个数组）：既然底层是数组，为什么查询不快呢？不是有数组就有索引吗？

根据存储的元素计算出hashCode值，然后根据计算得出的hashCode值和数组的长度进行计算出存储的下标；如果下标的位置无元素，那么直接存储；如果有元素，那么使用要存入的元素和该元素进行equals方法，如果结果为真，则已经有相同的元素了，所以直接不存；如果结果假，那么进行存储，以链表的形式存储。

4.2、HashSet

演示HashSet来存储自定义对象：

package  好好学java;

public class Person {
    // 属性
    private String name;
    private int age;
    
    // 构造方法
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    
    // 要让哈希表存储不重复的元素，就必须重写hasCode和equals方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : 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;
        Person other = (Person) 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 String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    // getter & setter
   
    ...
    
}

package  好好学java;

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

public class Test {
    public static void main(String[] args) {
        // 利用HashSet来存取自定义对象 Person
        Set<Person> set = new HashSet<Person>();
        
        set.add(new Person("张三", 12));
        set.add(new Person("李四", 13));
        set.add(new Person("王五", 22));
        set.add(new Person("张三", 12));
        
        // 遍历
        for (Person p : set){
            System.out.println(p);
        }
        // 结果：向集合中存储两个张三对象，但是集合中就成功存储了一个
        /*Person [name=王五, age=22]
        Person [name=李四, age=13]
        Person [name=张三, age=12]*/
    }
    

}

向HashSet集合中存储自定义对象时，要想保证存储的自定义元素对象唯一时，必须在自定义类中重写hashCode和equals方法。

4.3、LinkedHashSet

存取有序（存储的顺序是怎么样的？取的顺序就是怎么样的？），不可重复

4.4、TreeSet

保证元素唯一的两种方式

第一种方式：实现Comparable接口，重写CompareTo方法

注意：重写后的方法，要自己编写其方法体。

第二种方式：创建TreeSet对象时，传入Comparable的匿名内部类

注意：这里和第一种一样，要自己编写其方法体。如果向TreeSet存入自定义对象时，自定义类没有实现Comparable接口，或者没有传入Comparator比较器时，会出现ClassCastException异常

五、Map集合

Map在存储的时候，将键值传入Entry，然后存储Entry对象

其中下面有HashMap，LinkedHashMap和TreeMap

5.1、HashMap

5.2、LinkedHashMap

存取有序

5.3、TreeMap