Java学习笔记之---集合

（一）集合框架的体系结构

（二）List（列表）

（1）特性

1.List中的元素是有序并且可以重复的，成为序列

2.List可以精确的控制每个元素的插入位置，并且可以删除指定位置的元素

3.List的两个主要实现类是ArrayList和LinkedList

（2）Arraylist

1.ArrayList底层是由数组实现的

2.动态增长，以满足应用程序的需求

3.在列表尾部插入和删除非常有效

4.更适合查找和更新元素

5.元素允许为null

（3）List常用方法

1.add（E e）向列表的尾部添加指定的元素（可选操作）

2.add（int index, E element）在列表的指定位置插入指定元素（可选操作）。

3.clear（）从列表中移除所有元素（可选操作）。

4.contains（Object obj）如果列表包含指定的元素，则返回 true。

5.get（int index）返回列表中指定位置的元素

6.hashCode（）返回列表的哈希码值

7.indexOf（Object obj）返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

8.isEmpty（）如果列表不包含元素，则返回 true。

9.iterator（）返回按适当顺序在列表的元素上进行迭代的迭代器

10.remove（int index）移除列表中指定位置的元素（可选操作）。

11.removeAll（）从列表中移除指定 collection 中包含的其所有元素（可选操作）。

12.set（int index, E element）用指定元素替换列表中指定位置的元素（可选操作）。

13.size（）返回列表中的元素数。

14.equals（Object obj）比较指定的对象与列表是否相等

（4）实例

public class Student {

    private String sno;

    private String name;

    private String sex;

    private int age;

    public Student(String sno, String name, String sex, int age) {

        this.sno = sno;

        this.name = name;

        this.sex = sex;

        this.age = age;

    }

    public String getSno() {

        return sno;

    }

    public void setSno(String sno) {

        this.sno = sno;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

}

import java.util.ArrayList;

public class StudentTest {

    public static void main(String[] args){

        //创建学生对象

        Student s1=new Student("19501","丽丽","女",18);

        Student s2=new Student("19512","张三","男",20);

        Student s3=new Student("19523","李四","男",19);

        //创建集合

        ArrayList li=new ArrayList();

        //向集合中添加对象

        li.add(s1);

        li.add(s2);

        li.add(s3);

        //显示集合中的对象

        System.out.println("*************集合中的所有对象************");

        for(int i=0;i<li.size();i++){

            System.out.println(((Student)li.get(i)).getSno()+","+((Student)li.get(i)).getName());

        }

        //删除集合中的某一个对象

        System.out.println("*************删除一个对象后************");

        li.remove(2);

        for(int i=0;i<li.size();i++){

            System.out.println(((Student)li.get(i)).getSno()+","+((Student)li.get(i)).getName());

        }

        //向索引值为1的位置添加一个对象

        System.out.println("*************添加一个对象后************");

        Student s4=new Student("19533","听听","女",17);

        li.add(1,s4);

        for(int i=0;i<li.size();i++){

            System.out.println(((Student)li.get(i)).getSno()+","+((Student)li.get(i)).getName());

        }

        System.out.println("*************修改一个对象后************");

        s2.setName("张张");

        li.set(2,s2);

        for(int i=0;i<li.size();i++){

            System.out.println(((Student)li.get(i)).getSno()+","+((Student)li.get(i)).getName());

        }

    }

}

运行结果：

*************集合中的所有对象************

19501,丽丽

19512,张三

19523,李四

*************删除一个对象后************

19501,丽丽

19512,张三

*************添加一个对象后************

19501,丽丽

19533,听听

19512,张三

*************修改一个对象后************

19501,丽丽

19533,听听

19512,张张

（三）Set

（1）特性

1.set是元素无序并且不可以重复的集合，成为集

（2）HashSet

1.HashSet是Set中的一个重要实现类，称为哈希集

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

3. HashSet中只允许一个元素为null

4.具有良好的存取和查找功能

（3）Set常用方法

1. add（E e）如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。

2. clear（）移除此 set 中的所有元素（可选操作）。

3. contains（Object obj）如果 set 包含指定的元素，则返回 true

4. equals（Object obj）比较指定对象与此 set 的相等性。

5. isEmpty（）如果 set 不包含元素，则返回 true

6. hashCode（）返回 set 的哈希码值

7. iterator（）返回在此 set 中的元素上进行迭代的迭代器

8. remove（Object obj）如果 set 中存在指定的元素，则将其移除（可选操作）。

9. size（）返回 set 中的元素数（其容量）。

（4）实例

import java.util.Objects;

public class Cat {

    private String name;

    private String species;

    private int month;

    public Cat(String name, String species, int month) {

        this.name = name;

        this.species = species;

        this.month = month;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getSpecies() {

        return species;

    }

    public void setSpecies(String species) {

        this.species = species;

    }

    public int getMonth() {

        return month;

    }

    public void setMonth(int month) {

        this.month = month;

    }

    @Override

    public String toString() {

        return "Cat{" +

                "name='" + name + '\'' +

                ", species='" + species + '\'' +

                ", month=" + month +

                '}';

    }

    @Override

    public boolean equals(Object o) {

        if (this == o) return true;

        if (o == null || getClass() != o.getClass()) return false;

        Cat cat = (Cat) o;

        return getMonth() == cat.getMonth() &&

                getName().equals(cat.getName()) &&

                getSpecies().equals(cat.getSpecies());

    }

    @Override

    public int hashCode() {

        return Objects.hash(getName(), getSpecies(), getMonth());

    }

}

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

public class CatTest {

    public static void main(String[] args){

        //创建对象

        Cat lili=new Cat("lili","英国短毛猫",2);

        Cat coco=new Cat("coco","暹罗猫",5);

        Cat lulu=new Cat("lulu","布偶猫",8);

        //创建set集合，设置泛型，调用时不用强制类型转换，减少错误的产生

        Set<Cat> set=new HashSet<Cat>();

        set.add(lili);

        set.add(coco);

        set.add(lulu);

        //添加对象

        System.out.println("*********添加对象后的结果*********");

        Cat lisa=new Cat("lisa","折耳猫",3);

        set.add(lisa);

        //显示宠物猫信息，通过迭代器显示

        Iterator it=set.iterator();//将set中的信息存入迭代器中

        while(it.hasNext()){//通过hasNext（）判断集合中是否还有下一个

            System.out.println(it.next());//自动调用toString方法

        }

        System.out.println("*********添加重复属性对象后的结果*********");

        //添加属性重复的对象，需要重写hashCode方法和equals方法

        Cat lili2=new Cat("lili","英国短毛猫",2);

        set.add(lili2);

        Iterator it1=set.iterator();//将set中的信息存入迭代器中

        while(it1.hasNext()){//通过hasNext（）判断集合中是否还有下一个

            System.out.println(it1.next());//自动调用toString方法

        }

        //修改对象属性

        System.out.println("*********查找对象信息*********");

       //通过对象名查找

        boolean a=set.contains(lili);

        if(a){

            System.out.println("找到了");

        }else{

            System.out.println("没找到");

        }

        //通过属性查找

        Iterator it2=set.iterator();

       while(it2.hasNext()){

           Cat c=(Cat)it2.next();

           if(c.getName().equals("lili")){

               System.out.println("找到了");

               break;

           }

       }

       //删除对象信息

        //删除一个对象

        System.out.println("*********删除一个对象信息后的结果*********");

        set.remove(lili);

        Iterator it3=set.iterator();//将set中的信息存入迭代器中

        while(it3.hasNext()){//通过hasNext（）判断集合中是否还有下一个

            System.out.println(it3.next());//自动调用toString方法

        }

        //删除多个对象信息

        System.out.println("*********删除多个对象信息后的结果*********");

        Set set1=new HashSet();

        for(Cat c:set){

            if(c.getMonth()<5){

                set1.add(c);

            }

        }

        set.removeAll(set1);

        Iterator it4=set.iterator();//将set中的信息存入迭代器中

        while(it4.hasNext()){//通过hasNext（）判断集合中是否还有下一个

            System.out.println(it4.next());//自动调用toString方法

        }

        //删除全部对象信息

        System.out.println("*********删除全部对象信息后的结果*********");

        set.removeAll(set);

        if(set.isEmpty()){

            System.out.println("都找不到了");

        }

    }

}

运行结果：

*********添加对象后的结果*********

Cat{name='lisa', species='折耳猫', month=3}

Cat{name='lulu', species='布偶猫', month=8}

Cat{name='coco', species='暹罗猫', month=5}

Cat{name='lili', species='英国短毛猫', month=2}

*********添加重复属性对象后的结果*********

Cat{name='lisa', species='折耳猫', month=3}

Cat{name='lulu', species='布偶猫', month=8}

Cat{name='coco', species='暹罗猫', month=5}

Cat{name='lili', species='英国短毛猫', month=2}

*********查找对象信息*********

找到了

*********删除一个对象信息后的结果*********

Cat{name='lisa', species='折耳猫', month=3}

Cat{name='lulu', species='布偶猫', month=8}

Cat{name='coco', species='暹罗猫', month=5}

*********删除多个对象信息后的结果*********

Cat{name='lulu', species='布偶猫', month=8}

Cat{name='coco', species='暹罗猫', month=5}

*********删除全部对象信息后的结果*********

都找不到了

（四）Map

（1）特性

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

2. key-value是以Entry类型的对象实例存在

3.可以通过key快速查找value

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

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

（2）HashMap

1.基于哈希表的Map接口的实现

2.允许用null值和null键

3.key值不允许重复

4. HashMap中的Entry对象是无序排列的

（3）Map常用方法

1. clear（）从此映射中移除所有映射关系（可选操作）。

2. hashCode（）返回此映射的哈希码值

3. isEmpty（）如果此映射未包含键-值映射关系，则返回 true。

4. remove（Object key）如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

5. size（）返回此映射中的键-值映射关系数

6. equals（Object obj）比较指定的对象与此映射是否相等

7.put（K key，V value）将指定的值与此映射中的指定键关联（可选操作）。

8.values（）返回此映射中包含的值的 Collection 视图。

9.KeySet（）返回此映射中包含的键的 Set 视图。

10.entrySet（）返回此映射中包含的映射关系的 Set 视图

11.get（Object obj）返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null

（4）实例

import java.util.*;

public class Animal {

    public static void main(String[] args){

        //创建一个集合

        Map<String,String> animal=new HashMap<String,String>();

        //创建键值对,将键值对存入集合

        for(int i=0;i<3;i++) {

            System.out.println("********请输入key和value******");

            Scanner sc = new Scanner(System.in);

            String key = sc.next();

            String value=sc.next();

            animal.put(key,value);

        }

        //使用迭代器打印出所有value的值

        System.out.println("********打印出所有value的值******");

        Iterator<String> it=animal.values().iterator();

        while(it.hasNext()){

            System.out.println(it.next());

        }

        //使用entrySet打印出所有的键值对

        System.out.println("********打印出所有的键值对******");

        Set<Map.Entry<String, String>> entryset=animal.entrySet();

        for(Map.Entry<String, String> s1:entryset){

            System.out.println(s1.getKey()+"-"+s1.getValue());

        }

        //通过key找到value，使用keySet方法

        System.out.println("********请输入key值******");

        Scanner s=new Scanner(System.in);

        String s2=s.next();

        Set<String> k=animal.keySet();

        for(String k1:k){

            if(s2.equals(k1)){

                System.out.println(s2+"对应的value值为："+animal.get(k1));

                break;

            }

        }

        //删除一个键值对

        System.out.println("********打印出所有的键值对******");

        animal.remove("cat");

        Iterator<String> it1=animal.values().iterator();

        while(it1.hasNext()){

            System.out.println(it1.next());

        }

    }

}

运行结果：

********请输入key和value******

cat

猫

********请输入key和value******

dog

狗

********请输入key和value******

pig

猪

********打印出所有value的值******

猫

狗

猪

********打印出所有的键值对******

cat-猫

dog-狗

pig-猪

********请输入key值******

pig

pig对应的value值为：猪

********打印出所有的键值对******

狗

猪