java基础—集合（上）

一、集合类

集合类的由来：对象用于封装特有数据，对象多了需要存储；如果对象的个数不确定，就使用集合容器进行存储。
集合的特点：
1. 用于存储对象的容器。
2. 集合的长度是可变的。
3. 集合中不可以存储基本数据类型。
数组和集合类的差异：
1. 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。
2. 数组中可以存储基本数据类型，集合中只能存储对象。
集合框架的构成及分类：

二、 Collection接口

Collection的常见方法：
1. 添加：
  1. boolean add（Object obj）;添加元素。
  2. boolean addAll(Collection coll);将指定集合中的所有元素都添加到此集合中去。
2. 删除：
  1. boolean remove(Object obj);移除元素。
  2. boolean removeAll(Collection coll);移除指定集合中那些也包含在此集合中的元素。
  3. void clear();移除集合中所有的元素。
3. 判断：
  1. boolean contains(Object obj);是否包含某元素。
  2. boolean containsAll(Collection coll);是否包含指定集合中的所有元素，
  3. boolean isEmpty();判断集合中是否有元素。
4. 获取：
  1. int size()；返回此Collection中的元素数。
  2. Iterator iterator();迭代器：Iterator接口是所有的Collection容器进行元素取出的公共接口。
5. 其他：
  1. boolean retainAll(Collection coll);取交集。
  2. Object toArray();将集合转成数组。
示例：
- 代码：

import java.util.*;
class CollectionDemo
{
    public static void main(String[] args) 
    {
        Collection coll =new ArrayList();
        show(coll);
        System.out.println("………………………………");
        Collection c1=new ArrayList();
        Collection c2=new ArrayList();
        show(c1,c2);
    }
    public static void show(Collection coll)
    {
        coll.add("abc1");
        coll.add("abc2");
        coll.add("abc3");
        System.out.println("coll="+coll);

        coll.remove("abc2");//移除集合中的元素
        System.out.println("coll="+coll);

        coll.clear();//清空集合
        System.out.println(coll.contains("abc1"));//判断集合中是否含有"abc1"元素
    }

    public static void show(Collection c1,Collection c2)
    {
        c1.add("abc1");
        c1.add("abc2");
        c1.add("abc3");
        c1.add("abc4");
        c2.add("abc5");
        c2.add("abc2");
        c2.add("abc7");
        System.out.println("c1="+c1);
        System.out.println("c2="+c2);

        c1.addAll(c2);//将集合c2中的元素都添加到c1中去
        System.out.println("c1="+c1);


        boolean b=c1.removeAll(c2);//将c1集合中所包含的c2集合元素全部去除
        System.out.println("b："+b);

        boolean b1=c1.containsAll(c2);//判断c1集合是否包含c2集合所有的元素
        System.out.println("b1="+b1);

        boolean b2=c1.retainAll(c2);//取c1集合与c2集合的交集
        System.out.println("c1、c2的交集"+c1);
    }
}

输出结果

三、List、Set

Collection
- |–List:有序（存入和取出的顺序一致），元素都有索引（角标），允许重复元素。
- |–Set：元素不能重复，无序
List
- |–vector:内部是数组数据结构，是同步的。增删，查询都很慢。
- |–ArrayList:内部是数组数据结构，是不同步的，替代了Vector，查询的速度很快。
- |–LinkedList：内部是链表数据结构，是不同；步的。增删元素的速度很快。
Set
- |–HashSet：内部数据结构是哈希表，是不同的。
- |–TreeSet：可以对Set集合中的元素进行排序，是不同步的。
注意事项：
- 在迭代器过程中，不要使用集合操作元素，容易出现异常。
  - 解决方法：可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行的操作。
List的特有常见方法（有一个共同点：都可以操作角标）
1. 添加
  1. void add(index,element);在指定位置插入指定元素
  2. void addAll(index,collection); 将指定 collection 中的所有元素都插入到列表中的指定位置。
2. 删除
  1. Object remove(index);删除指定位置上的元素。
3. 修改
  1. Object set(index,element);用指定元素替换列表上的指定位置上的元素。
4. 获取：
  1. Object get(index);获取指定位置上的元素。
  2. int indexOf(object);返回此列表中第一次出现的指定元素的索引
  3. int lastIndexOf(object);返回此列表中最后出现的指定元素的索引。
  4. List subList(from,to);获取子集合。
示例：
- 代码：

import java.util.ArrayList;
import java.util.List;
class ListDemo
{
    public static void main(String[] args) 
    {
        List list=new ArrayList();
        show(list);
    }
    public static void show(List list)
    {
        //在集合结尾添加元素
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        System.out.println(list);
        //在集合指定位置插入元素
        list.add(1,"abc2");
        System.out.println(list);
        //去除集合中角标为2的元素
        System.out.println(list.remove(2));
        //修改集合中角标为2的元素
        System.out.println(list.set(2,"abc8"));
        //获取集合众角标为1的元素
        System.out.println(list.get(1));
        //获取子集合，含头不含为
        System.out.println(list.subList(1,2));
        System.out.println(list);
    }
}

输出结果：

四、ArrayList、LinkedList

ArrayList：ArrayList常用方法详见其父类List的方法。
LinkedList方法(jdk1.6版本后新方法)：
1. 增加
  1. offerFirst()；//在此列表的开头插入指定的元素。
  2. offerLast()；//在此列表末尾插入指定的元素。
2. 删除
  1. pollFirst();//获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
  2. pollLast();//获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
3. 读取
  1. peekList（）；//获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
  2. peekLast（）；//获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
示例：
- 代码：

import java.util.*;
class LinkedListDemo
{
    public static void main(String[] args) 
    {
        LinkedList link =new LinkedList();

        link.offerFirst("abc1");
        link.offerFirst("abc2");
        link.offerFirst("abc3");
        link.offerFirst("abc4");

        System.out.println(link);

        System.out.println("获取的第一个元素："+link.peekFirst());//获取容器的第一个元素，但不移除元素

        System.out.println("获取的最后一个元素："+link.peekLast());//获取容器的最后一个元素，但不移除元素

        System.out.println("移除的第一个元素："+link.pollFirst());//获取容器的第一个元素，并移除元素

        System.out.println("移除的最后一个元素："+link.pollLast());//获取容器的最后一个元素，并移除元素

        while(!link.isEmpty())
        {       
            System.out.println(link.pollFirst());//若容器不为空，将元素从第一个开始依次获取并移除
        }
    }
}

输出结果：

五、HashSet、TreeSet

Set的常用方法：Set接口中的方法和Collection一致
特点：
- Set集合的元素是无序的。
- 集合中的元素是唯一的。

1、HashSet

HashSet确定元素是否相同的依据：
1. 判断的是两个元素的哈希值是否相同。如果相同，再判断两个对象的内容是否相同。
2. 判断哈希值相同，其实判断的是对象的HashCode方法。判断内容相同，用的是equals方法。

- 示例：
- 代码：

import java.util.*;
class Person
{
    private String name;
    private int age;
    Person()
    {}
    Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public  void setName(String name)
    {
        this.name=name;
    }
    public  void setAge(int age)
    {
        this.age=age;
    }
    public String getName()
    {
        return this.name;
    }
    public int getAge()
    {
        return this.age;
    }
    //复写hashCode方法，先判断hashCode是否相等，若相等则判断元素内容是否相等
    public int hashCode()
    {
        return name.hashCode()+age*39;
    }
    //复写equals方法，判断对象内容是否相等
    public boolean equals(Object obj)
    {
        //若传入同一个对象，则直接返回true
        if(this==obj)
            return true;
        //若传入的不是Person类的对象，则抛出异常
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");
        Person p=(Person)obj;
        return this.name.equals(p.name) && this.age==p.age;
    }
}

class HashSetTest1
{
    public static void main(String[] args) 
    {
        HashSet hs=new HashSet();

        hs.add(new Person("li1",10));
        hs.add(new Person("li2",20));
        //重复的元素
        hs.add(new Person("li1",10));
        hs.add(new Person("li3",30));
        hs.add(new Person("li4",40));

        Iterator it =hs.iterator();
            while (it.hasNext())
            {
                Person p=(Person)it.next();
                System.out.println(p.getName()+"…………"+p.getAge());
            }

    }
}

输出的结果：

2、TreeSet

TreeSet判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
TreeSet对元素排序的两种方式：
1. 让元素自身具备比较功能，元素就需要实现Comparable接口，覆盖compareTo方法。
2. 让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
示例（用比较器的方法进行排序）：
- 代码
- 要求：根据字符串的长度进行排序

import java.util.*;
//创建一个根据字符串长度进行排序的比较器（从小到大排列）
class CompareByLen implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        String s1=(String)o1;
        String s2=(String)o2;
        //若长度一样，则根据字符的自然顺序排列
        int num=s1.length()-s2.length();
        return num==0?s1.compareTo(s2):num;
    }
}
class  comparatorDemo
{
    public static void main(String[] args) 
    {
        //将比较器传入集合
        TreeSet hs=new TreeSet(new CompareByLen());
        hs.add("me");
        hs.add("you");
        hs.add("his");
        hs.add("they");
        //用迭代器将集合中的元素打印出来
        Iterator it =hs.iterator();
            while (it.hasNext())
            {
                System.out.println(it.next());
            }
    }
}

这里写图片描述

java基础---集合（上）

java基础—集合（上）

一、集合类

二、 Collection接口

三、List、Set

四、ArrayList、LinkedList

五、HashSet、TreeSet

1、HashSet

2、TreeSet

猜你喜欢

java基础---集合（上）

java基础—集合 （上）

一、集合类

二、 Collection接口

三、List、Set

四、ArrayList、LinkedList

五、HashSet、TreeSet

1、HashSet

2、TreeSet

猜你喜欢

java基础—集合（上）