Java集合

一.集合概念

　　Java中的集合是工具类，可以存储任意数量具有共同属性的对象。

　　1.使用场景：

　　　　无法预测存储数据的数量；

　　　　同时存储具有一对一关系的数据；

　　　　需要进行数据的增删；

　　　　数据重复问题。

　　2.集合框架的体系结构：

二.List(列表)

　　1.List相关概念：

　　　　List是元素有序并且可以重复的集合，称为序列；

　　　　List可以精确的控制每个元素的插入位置，或删除某个位置的元素；

　　　　List的两个主要实现类是ArrayList（和数组相似，内存上连续的存储空间）和LinkedList（链表）。

　　2.ArrayList和LinkedList：

　　　　2.1ArrayList：

　　　　　　ArrayList底层是由数组实现的；动态增长，以满足应用程序的需求；在列表尾部插入或删除数据非常有效；更适合查找和更新元素；ArrayList中的元素可以为null。

方法摘要
boolean	add(E e)            将指定的元素添加到此列表的尾部。
void	add(int index, E element)            将指定的元素插入此列表中的指定位置。
boolean	addAll(Collection<? extends E> c)            按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
boolean	addAll(int index, Collection<? extends E> c)            从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
void	clear()            移除此列表中的所有元素。
Object	clone()            返回此 ArrayList 实例的浅表副本。
boolean	contains(Object o)            如果此列表中包含指定的元素，则返回 true。
void	ensureCapacity(int minCapacity)            如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
E	get(int index)            返回此列表中指定位置上的元素。
int	indexOf(Object o)            返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
boolean	isEmpty()            如果此列表中没有元素，则返回 true
int	lastIndexOf(Object o)            返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
E	remove(int index)            移除此列表中指定位置上的元素。
boolean	remove(Object o)            移除此列表中首次出现的指定元素（如果存在）。
protected  void	removeRange(int fromIndex, int toIndex)            移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
E	set(int index, E element)            用指定的元素替代此列表中指定位置上的元素。
int	size()            返回此列表中的元素数。
Object[]	toArray()            按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
<T> T[]	toArray(T[] a)            按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
void	trimToSize()            将此 ArrayList 实例的容量调整为列表的当前大小。

　　

package com.swpu;

import java.util.Date;

public class Notice {
    private int id;
    private String title;
    private String ctrator;
    private Date createTime;
    public Notice(int id, String title, String ctrator, Date createTime) {
        super();
        this.id = id;
        this.title = title;
        this.ctrator = ctrator;
        this.createTime = createTime;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getCtrator() {
        return ctrator;
    }
    public void setCtrator(String ctrator) {
        this.ctrator = ctrator;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
    

}

package com.swpu.test;

import java.util.ArrayList;
import java.util.Date;

import com.swpu.Notice;

public class NoticeTest {
    public static void main(String[] args) {
        Notice notice1 = new Notice(1, "哈哈1", "LYQ1", new Date());
        Notice notice2 = new Notice(2, "哈哈2", "LYQ2", new Date());
        Notice notice3 = new Notice(3, "哈哈3", "LYQ3", new Date());
        ArrayList arraylist=new ArrayList();
        //添加
        arraylist.add(notice1);
        arraylist.add(notice2);
        arraylist.add(notice3);
        System.out.println("公告内容：");
        for(int i=0;i<arraylist.size();i++){
            System.out.println(i+1+":"+((Notice)(arraylist.get(i))).getTitle());
        }
        Notice notice4 = new Notice(4, "哈哈4", "LYQ4", new Date());
        //指定位置添加
        arraylist.add(1,notice4);
        System.out.println("**********");
        for(int i=0;i<arraylist.size();i++){
            System.out.println(i+1+":"+((Notice)(arraylist.get(i))).getTitle());
        }
        //移除
        arraylist.remove(1);
        //修改
        notice4.setTitle("新哈哈4");
        arraylist.set(2, notice4);



    }

}

　　

　　2.2LinkedList：

　　　　与ArrayList一样，LinkedList也按照索引位置排序，但它的元素z之间是双向链接的；

　　　　适合快速的插入和删除元素；

　　　　LinkdList实现List和Queue两个接口。

方法摘要
boolean	add(E e)            将指定元素添加到此列表的结尾。
void	add(int index, E element)            在此列表中指定的位置插入指定的元素。
boolean	addAll(Collection<? extends E> c)            添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
boolean	addAll(int index, Collection<? extends E> c)            将指定 collection 中的所有元素从指定位置开始插入此列表。
void	addFirst(E e)            将指定元素插入此列表的开头。
void	addLast(E e)            将指定元素添加到此列表的结尾。
void	clear()            从此列表中移除所有元素。
Object	clone()            返回此 LinkedList 的浅表副本。
boolean	contains(Object o)            如果此列表包含指定元素，则返回 true。
Iterator<E>	descendingIterator()            返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E	element()            获取但不移除此列表的头（第一个元素）。
E	get(int index)            返回此列表中指定位置处的元素。
E	getFirst()            返回此列表的第一个元素。
E	getLast()            返回此列表的最后一个元素。
int	indexOf(Object o)            返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
int	lastIndexOf(Object o)            返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
ListIterator<E>	listIterator(int index)            返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。
boolean	offer(E e)            将指定元素添加到此列表的末尾（最后一个元素）。
boolean	offerFirst(E e)            在此列表的开头插入指定的元素。
boolean	offerLast(E e)            在此列表末尾插入指定的元素。
E	peek()            获取但不移除此列表的头（第一个元素）。
E	peekFirst()            获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E	peekLast()            获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	poll()            获取并移除此列表的头（第一个元素）
E	pollFirst()            获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E	pollLast()            获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	pop()            从此列表所表示的堆栈处弹出一个元素。
void	push(E e)            将元素推入此列表所表示的堆栈。
E	remove()            获取并移除此列表的头（第一个元素）。
E	remove(int index)            移除此列表中指定位置处的元素。
boolean	remove(Object o)            从此列表中移除首次出现的指定元素（如果存在）。
E	removeFirst()            移除并返回此列表的第一个元素。
boolean	removeFirstOccurrence(Object o)            从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
E	removeLast()            移除并返回此列表的最后一个元素。
boolean	removeLastOccurrence(Object o)            从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
E	set(int index, E element)            将此列表中指定位置的元素替换为指定的元素。
int	size()            返回此列表的元素数。
Object[]	toArray()            返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。
<T> T[]	toArray(T[] a)            返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。

 三.Set 

　　Set是元素无序并且不可以重复的集合，简称为集。

　　1.HashSet（底层是HashMap）:

　　　　HashSet是Set的一个重要实现类，成为哈希集；

　　　　HashSet中的元素无序并且不可以重复；

　　　　HashSet中允许一个null元素；

　　　　具有良好的存储和查找功能。

　　　　迭代器（Iterator）：

　　　　　　Iterator接口可以以统一的方式对各种集合元素进行遍历；hasNext()方法检测集合是否还有下一个元素；next()方法返回集合中的下一个元素。

例1：

package com.swpu;

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

public class WordDemo {
    public static void main(String[] args){
        Set set=new HashSet();
        set.add("哈哈1");
        set.add("哈哈2");
        set.add("哈哈3");
        Iterator it=set.iterator();
        //遍历迭代器
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
    }

}

 例2：

package com.swpu;

public class Cat {
    private String name;
    private int month;
    private String species;
    public Cat(String name, int month, String species) {
        super();
        this.name = name;
        this.month = month;
        this.species = species;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getMonth() {
        return month;
    }
    public void setMonth(int month) {
        this.month = month;
    }
    public String getSpecies() {
        return species;
    }
    public void setSpecies(String species) {
        this.species = species;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Cat [name=" + name + ", month=" + month + ", species=" + species + "]";
    }
    //重写hashCode()方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + month;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((species == null) ? 0 : species.hashCode());
        return result;
    }
    //重写提高查询速度
    @Override
    public boolean equals(Object obj) {
        //判断对象是否相等，相等则返回true，不用继续比较属性了
        if (this==obj){
            return true;
        }
        //判断obj是否是Cat类的对象
        if(obj.getClass()==Cat.class){
            Cat cat=(Cat) obj;
            return (cat.getName().equals(name))&&(cat.getMonth()==month)&&cat.getSpecies().equals(species);
        }
        return false;
        
        /*
         * if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Cat other = (Cat) obj;
        if (month != other.month)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (species == null) {
            if (other.species != null)
                return false;
        } else if (!species.equals(other.species))
            return false;
        return true;
        */
    }
    
    
    
}

package com.swpu.test;

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

import com.swpu.Cat;

public class CatTest {

    public static void main(String[] args) {
        Cat cat1=new Cat("花花",12,"英国短毛猫");
        Cat cat2 =new Cat("凡凡",10,"中国田园猫");
        //<>泛型，限定类型
        Set<Cat> set=new HashSet<Cat>();
        set.add(cat1);
        set.add(cat2);
        Iterator<Cat> it=set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //添加一个猫(对象属性一样，但是是两个不同的对象)
        System.out.println("**************");
        Cat cat3 =new Cat("凡凡",10,"中国田园猫");
        set.add(cat3);
        it=set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //重新插入一个猫
        System.out.println("**************");
        Cat cat4 =new Cat("凡凡二代",10,"中国田园猫");
        set.add(cat4);
        it=set.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //在集合中查找花花的信息
        if(set.contains(cat1)){
            System.out.println("找到了花花");
            System.out.println(cat1);
        }
        else{
            System.out.println("未找到！！！");
        }
        System.out.println("**************");
        //在集合中使用名字查找花花的信息
        System.out.println("通过名字查找");
        boolean flag=false;
        Cat c=null;
        it=set.iterator();
        while(it.hasNext()){
            c=it.next();
            if (c.getName().equals("花花")){
                flag=true;//
                break;
            }
        }
        if(flag=true){
            System.out.println("找到了");
            System.out.println(c);

        }
        else{
            System.out.println("未找到");
        }
        System.out.println("**************");
        //删除凡凡二代
        for(Cat cat:set){
            if ("凡凡二代".equals(cat.getName())){
                set.remove(cat);
            }
        }
        for(Cat cat:set){
            System.out.println(cat);
        }
        //删除所有
        boolean flag1=set.removeAll(set);
        if(set.isEmpty()){
            System.out.println("删除了");
        }
        else{
            System.out.println("删除失败");

        }
        
    }
        
    }
    

Python中实现：

class Cat(object):
    def __init__(self, name, month, species):
        self.name = name
        self.month = month
        self.species = species

    # 重写__repr__魔法函数指定返回值
    def __repr__(self):
        return "name:" + self.name + " 年龄: " + str(self.month)

    # 重写__eq__和__hash__魔法函数，判断是否相等
    def __eq__(self, other):
        if self is other:
            return True
        if self.__class__ == self.__class__:
            if self.name == other.name and self.month == other.month and self.species == other.species:
                return True
        return False

    def __hash__(self):
        prime = 31
        result = 1
        result = prime * result + self.month
        return result

if __name__=="__main__":

    cat1 = Cat("花花", 12, "英国短毛猫")
    cat2 = Cat("凡凡", 12, "中华田园猫")
    cat3 = Cat("花花", 12, "英国短毛猫")
    cat3 = Cat("花花二代", 12, "英国短毛猫")

    myset = set()
    myset.add(cat1)
    myset.add(cat2)
    for i in myset:
        print(i)
    print("*"*10)
    #判断cat1是否在myset中
    if (cat1 in myset):
        print("找到了")
    print("*"*10)
    #通过name判断
    for i in myset:
        if i.name=="花花":
            print("找到了")
            print(i)
            break
    #删除花花二代
    for i in myset:
        if i.name=="花花二代":
            myset.remove(i)
            break
    #移除所有
    myset.clear()
    print(myset)

四.Map

　　注：

　　　　Map的数据是以键值对（key-value）的形式存储；

　　　　key-value以Entry类型的实例对象存在；

　　　　可以通过key值快速查找value；

　　　　一个映射不能包含重复的键；

　　　　每个键最多只能映射到一个值。

　　HashMap：

　　　　基于哈希表的Map接口的实现；

　　　　允许使用null值和null键；

　　　　key值不允许重复；

　　　　HashMap中的Entry对象是无序排列的。

方法摘要
void	clear()            从此映射中移除所有映射关系。
Object	clone()            返回此 HashMap 实例的浅表副本：并不复制键和值本身。
boolean	containsKey(Object key)            如果此映射包含对于指定键的映射关系，则返回 true。
boolean	containsValue(Object value)            如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>>	entrySet()            返回此映射所包含的映射关系的 Set 视图。
V	get(Object key)            返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
boolean	isEmpty()            如果此映射不包含键-值映射关系，则返回 true。
Set<K>	keySet()            返回此映射中所包含的键的 Set 视图。
V	put(K key, V value)            在此映射中关联指定值与指定键。
void	putAll(Map<? extends K,? extends V> m)            将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。
V	remove(Object key)            从此映射中移除指定键的映射关系（如果存在）。
int	size()            返回此映射中的键-值映射关系数。
Collection<V>	values()            返回此映射所包含的值的 Collection 视图。

例1：

package com.swpu.test;

import java.awt.datatransfer.StringSelection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

public class MapTest {

    public static void main(String[] args) {

        Map<String, String> map = new HashMap<String, String>();
        System.out.println("请输入三组单词存入HashMap：");
        Scanner sc = new Scanner(System.in);
        int i = 0;
        while (i < 3) {
            System.out.print("请输入键：");
            String key = sc.next();
            System.out.print("请输入值：");
            String value = sc.next();
            map.put(key, value);
            i++;

        }
        // 打印输出value值
        System.out.println("*************");
        System.out.println("使用迭代器输出values：");
        Iterator<String> it = map.values().iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + "  ");
        }
        // 使用entrySet打印key，value
        System.out.println("
使用entrySet打印key，value：");
        Set<Entry<String, String>> entrySet = map.entrySet();
        for(Entry<String,String> entry:entrySet){
            System.out.println(entry.getKey()+"-"+entry.getValue());
        }
        //通过key找到value
        //使用KeySet方法
        String stringSearch=it.next();
        Set<String> keySet=map.keySet();
        //2.遍历KeySet
        for(String key:keySet){
            if (stringSearch.equals(key)){
                System.out.println("找到了为："+key+":"+map.get(key));
                break;
            }
        }
        

    }

}

例2：

package com.swpu;

public class Good {
    private String id;
    private String name;
    @Override
    public String toString() {
        return "Good [id=" + id + ", name=" + name + ", price=" + price + "]";
    }
    private double price;
    public Good(String id, String name, double price) {
        super();
        this.id = id;
        this.name = name;
        this.price = price;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    
}

package com.swpu.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;

import com.swpu.Good;

public class GoodTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc=new Scanner(System.in);
        Map<String,Good> goodMap=new HashMap<String,Good>();
        System.out.println("请输入商品信息");
        int i=0;
        while(i<3){
            System.out.println("请输入第"+(i+1)+"条商品");
            System.out.println("请输入商品编号：");
            String goodId=sc.next();
            //判断商品编号是否存在
            if(goodMap.containsKey(goodId)){
                System.out.println("该商品id已经存在，请从新输入");
                continue;
            }
            System.out.println("请输入商品名称：");
            String goodName=sc.next();
            System.out.println("请输入商品价格：");
            double goodPrice=0;
            try{
                goodPrice=sc.nextDouble();
            }
            catch(java.util.InputMismatchException e){
                System.out.println("价格格式输入不正确！！请从新输入！！");
                sc.next();
                continue;
            }
            Good good=new Good(goodId,goodName,goodPrice);
            //将商品信息添加
            goodMap.put(goodId, good);
            i++;
        }
        Iterator <Good> it=goodMap.values().iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

    }

}