14 - 集合 - List与Set集合的区别

List:
    它是一个有序的集合(元素存与取的顺序相同)
    它可以存储重复的元素            
Set:
    它是一个无序的集合(元素存与取的顺序可能不同)
    
它不能存储重复的元素
    List集合中的特有方法
    void add(int index, Object element) 将指定的元素，添加到该集合中的指定位置上
    Object get(int index)返回集合中指定位置的元素。
    Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素
    Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素
    ArrayList:
    底层数据结构是数组，查询快，增删慢
    LinkedList:
    底层数据结构是链表，查询慢，增删快
    HashSet:
    元素唯一，不能重复
    底层结构是 哈希表结构
    元素的存与取的顺序不能保证一致
    如何保证元素的唯一的？
        重写hashCode() 与 equals()方法
    LinkedHashSet:
    元素唯一不能重复
    底层结构是 哈希表结构 + 链表结构
    元素的存与取的顺序一致

1. List

package cn.itcast.demo;

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

/*
 *  List接口派系, 继承Collection接口
 *    下面有很多实现类
 *  List接口特点: 有序,索引,可以重复元素
 *    实现类, ArrayList, LinkedList
 *    
 *  List接口中的抽象方法,有一部分方法和他的父接口Collection是一样
 *  List接口的自己特有的方法, 带有索引的功能
 */
public class ListDemo {
    public static void main(String[] args) {
        function_2();
    }
    /*
     *  E set(int index, E)
     *  修改指定索引上的元素
     *  返回被修改之前的元素
     */
    public static void function_2(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        
        Integer i = list.set(0, 5);
        System.out.println(i);
        System.out.println(list);
    }
    
    /*
     *  E remove(int index)
     *  移除指定索引上的元素
     *  返回被删除之前的元素
     */
    public static void function_1(){
        List<Double> list = new ArrayList<Double>();
        list.add(1.1);
        list.add(1.2);
        list.add(1.3);
        list.add(1.4);
        
        Double d = list.remove(0);
        System.out.println(d);
        System.out.println(list);
    }
    
    /*
     *  add(int index, E)
     *  将元素插入到列表的指定索引上
     *  带有索引的操作,防止越界问题
     *  java.lang.IndexOutOfBoundsException
     *     ArrayIndexOutOfBoundsException
     *     StringIndexOutOfBoundsException
     */
    public static void function(){
        List<String> list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        System.out.println(list);
        
        list.add(1, "itcast");
        System.out.println(list);
    }
}

package cn.itcast.demo;

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

/*
 *  迭代器的并发修改异常 java.util.ConcurrentModificationException
 *  就是在遍历的过程中,使用了集合方法修改了集合的长度,不允许的
 */
public class ListDemo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        
        //对集合使用迭代器进行获取,获取时候判断集合中是否存在 "abc3"对象
        //如果有,添加一个元素 "ABC3"
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            //对获取出的元素s,进行判断,是不是有"abc3"
            if(s.equals("abc3")){
                list.add("ABC3");
            }
            System.out.println(s);
        }
    }
}

package cn.itcast.demo;

import java.util.LinkedList;

/*
 *  LinkedList 链表集合的特有功能
 *    自身特点: 链表底层实现,查询慢,增删快
 *  
 *  子类的特有功能,不能多态调用
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        function_3();
    }
    /*
     *  E removeFirst() 移除并返回链表的开头
     *  E removeLast() 移除并返回链表的结尾
     */
    public static void function_3(){
        LinkedList<String> link = new LinkedList<String>();
        link.add("1");
        link.add("2");
        link.add("3");
        link.add("4");
        
        String first = link.removeFirst();
        String last = link.removeLast();
        System.out.println(first);
        System.out.println(last);
    
        System.out.println(link);
    }
    
    /*
     * E getFirst() 获取链表的开头
     * E getLast() 获取链表的结尾
     */
    public static void function_2(){
        LinkedList<String> link = new LinkedList<String>();
        link.add("1");
        link.add("2");
        link.add("3");
        link.add("4");
    
        if(!link.isEmpty()){
            String first = link.getFirst();
            String last = link.getLast();
            System.out.println(first);
            System.out.println(last);
        }
    }
    
    public static void function_1(){
        LinkedList<String> link = new LinkedList<String>();
        link.addLast("a");
        link.addLast("b");
        link.addLast("c");
        link.addLast("d");
        
        link.addFirst("1");
        link.addFirst("2");
        link.addFirst("3");
        System.out.println(link);
    }
    
    /*
     *  addFirst(E) 添加到链表的开头
     *  addLast(E) 添加到链表的结尾
     */
    public static void function(){
        LinkedList<String> link = new LinkedList<String>();
        
        link.addLast("heima");
        
        link.add("abc");
        link.add("bcd");
        
        link.addFirst("itcast");
        System.out.println(link);
        
        
    }
}

 

2. Set 

package cn.itcast.demo1;

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

/*
 *  Set接口,特点不重复元素,没索引
 *  
 *  Set接口的实现类,HashSet (哈希表)
 *  特点: 无序集合,存储和取出的顺序不同,没有索引,不存储重复元素
 *  代码的编写上,和ArrayList完全一致
 */
public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("cn");
        set.add("heima");
        set.add("java");
        set.add("java");
        set.add("itcast");
        
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("==============");
        
        for(String s : set){
            System.out.println(s);
        }
    }
}

package cn.itcast.demo1;

import java.util.HashSet;

import cn.itcast.demo3.Person;

/*
 *  HashSet集合的自身特点:
 *    底层数据结构,哈希表
 *    存储,取出都比较快
 *    线程不安全,运行速度快
 */
public class HashSetDemo1 {
    public static void main(String[] args) {
        /*HashSet<String> set = new HashSet<String>();
        set.add(new String("abc"));
        set.add(new String("abc"));
        set.add(new String("bbc"));
        set.add(new String("bbc"));
        System.out.println(set);*/
        
        
        //将Person对象中的姓名,年龄,相同数据,看作同一个对象
        //判断对象是否重复,依赖对象自己的方法 hashCode,equals
        HashSet<Person> setPerson = new HashSet<Person>();
        setPerson.add(new Person("a",11));
        setPerson.add(new Person("b",10));
        setPerson.add(new Person("b",10));
        setPerson.add(new Person("c",25));
        setPerson.add(new Person("d",19));
        setPerson.add(new Person("e",17));
        System.out.println(setPerson);
    }
}

package cn.itcast.demo1;

import java.util.LinkedHashSet;

/*
 *   LinkedHashSet 基于链表的哈希表实现
 *   继承自HashSet
 *   
 *   LinkedHashSet 自身特性,具有顺序,存储和取出的顺序相同的
 *   线程不安全的集合,运行速度块
 */
public class LinkedHashSetDemo {
    
    public static void main(String[] args) {
        LinkedHashSet<Integer> link = new LinkedHashSet<Integer>();
        link.add(123);
        link.add(44);
        link.add(33);
        link.add(33);
        link.add(66);
        link.add(11);
        System.out.println(link);
    }
}

package cn.itcast.demo3;
/*
 *  对象的哈希值,普通的十进制整数
 *  父类Object,方法 public int hashCode() 计算结果int整数
 */
public class HashDemo {
    public static void main(String[] args) {
        Person p = new Person();
        int i = p.hashCode();
        System.out.println(i);
    
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        
        /*System.out.println("重地".hashCode());
        System.out.println("通话".hashCode());*/
    }
}

package cn.itcast.demo3;
/*
 *   两个对象  Person  p1 p2
 *   问题: 如果两个对象的哈希值相同 p1.hashCode()==p2.hashCode()
 *        两个对象的equals一定返回true吗  p1.equals(p2) 一定是true吗
 *        正确答案:不一定
 *        
 *        如果两个对象的equals方法返回true,p1.equals(p2)==true
 *        两个对象的哈希值一定相同吗
 *        正确答案: 一定
 */
public class HashDemo1 {

}

package cn.itcast.demo3;

public class Person {
    private String name;
    private int age;

    /*
     *  没有做重写父类,每次运行结果都是不同整数
     *  如果子类重写父类的方法,哈希值,自定义的
     *  存储到HashSet集合的依据
     */
    public int hashCode(){
        return name.hashCode()+age*55;
    }
    //方法equals重写父类,保证和父类相同
    //public boolean equals(Object obj){}
    public boolean equals(Object obj){
        if(this == obj)
            return true;
        if(obj == null)
            return false;
        if(obj instanceof Person){
            Person p = (Person)obj;
            return name.equals(p.name) && age==p.age;
        }
        return false;
    }
    
    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;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person(){}
    
    public String toString(){
        return name+".."+age;
    }
    


}