集合:Collection接口,Set,List,Map接口,泛型

集合和数组的区别?

  1. 数组:存储相同类型的容器(基本数据类型,引用数据类型);定长
  2. 集合:存储对象(引用数据类型),自动扩充

集合

  • 存储数据的容器,所存储的每个对象称为一个元素
  • 集合的API都来自于JAVA.util包
  • 存储不同数据类型的数据,只能存储引用数据类型
  • 不定长
集合的API

Collection接口:所有集合(List和Set)的父类

  • Object[ ] toArray()将集合转换成数组
  • int size()遍历集合使用

Set接口:Collection子接口 无序无重复

  • 无序:元素放入的顺序和真实存储的顺序不同
  • 不重复:相同的对象只保留一个,自动去重

Set接口的实现类

  1. HashSet:真实的存储数据的顺序:(按照元素的哈希码值进行数据的排放)
public static void main(String[] args) {
        HashSet set = new HashSet<>();
        set.add("apple");
        set.add("grape");
        set.add("pear");
        set.add("liwi");
        set.add(1);
        System.out.println(set.size());//5
        //用迭代器遍历集合
        //前提:判空 集合是否为 null和 isEmpty(),如果为空 返回true,否则反之
        //1.构建迭代器对象
        //2.调用hasNext()  判断迭代器中是否有下一个元素
        //3.next()  获取下一个元素
        //if ( set!=null && set.size()>0) {
        if ( set!=null && !set.isEmpty()) {
            Iterator iterator = set.iterator();
            while (iterator.hasNext()) {
                System.out.println(iterator.next());//apple 1 pear grape liwi
            }
        }
           //转换成数组的形式
        System.out.println(Arrays.toString(set.toArray()));
        set.remove("apple");
        System.out.println(set.size());
        set.clear();
        System.out.println(set.size());
    }
 
 
  1. Treeset:真实的存储数据的顺序:(按照元素的(自然顺序)升序排序)
public static void main(String[] args) {
        TreeSet set  = new TreeSet<>();
        set.add("apple");
        set.add("grape");
        set.add("pear");
        set.add("liwi");
        if ( set!=null && !set.isEmpty()) {
            Iterator iterator = set.iterator();
            while (iterator.hasNext()) {
                System.out.println(iterator.next());//apple   grape liwi pear
            }
        }
    }
 
 
public class Student implements Comparable{
    private int sno;
    private String sname;
    private int age;

    public Student() {
    }

    public Student(int sno, String sname, int age) {
        this.sno = sno;
        this.sname = sname;
        this.age = age;
    }

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sno=" + sno +
                ", sname='" + sname + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student s) {
        if (this.age>s.age){
            return 1;
        }else {
            return -1;
        }
    }

List接口:Collection的子接口 有序可重复,索引值从0开始

  • 有序:放元素的顺序和元素真实存储的顺序一致
  • 可重复:可存放重复的数据对象

List接口的实现类

  1. ArrayList:
    public static void main(String[] args) {
        List list = new ArrayList();//向上转型:方便程序的扩展
        list.add("apple");
        list.add("pear");
        list.add("lucky");
        list.add(1,"ly");
        System.out.println(list.size());
        //循环遍历
        if (list!=null&&!list.isEmpty()){
            Iterator iterator = list.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
        //for循环遍历
        if (list!=null&&!list.isEmpty()){
            for (int i = 0; i 
  1. LinkedList:

ArrayList与LinkedList的区别

  1. ArrayList线性存储,随机查询
  2. LinkedList链表存储,元素的删除和存储的操作性能比较高

泛型:指定集合想要存放的数据类型

Map接口:以键值对的形式进行数据存储的集合容器 一一对应(映射)

  • 每一个元素有两部分构成:键 值
  • 键是唯一的
  • 如果存储相同的键的元素,则值会被覆盖

Map接口的实现类

  1. HashMap:
public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.put(1, "e");
        map.remove(3);
        System.out.println(map.containsKey(3));//false
        System.out.println(map.containsValue("e"));//true
        System.out.println(map.get(1));//e
        //遍历
        //1.判空
        //2.获取所有的key的集合 map.keySet()
        //3.构建迭代器对象
        //4.调用hasNext()  判断迭代器中是否有下一个元素
        //5.next()  获取下一个元素
        //6.根据 键 获取 值 
        if (map != null && map.size() > 0) {
            Set set = map.keySet();
            Iterator iterator = set.iterator();
            while (iterator.hasNext()) {
                Integer key = iterator.next();
                String value = map.get(key);
                System.out.print(key + " " + value);
                System.out.println();
            }
        }
    }

你可能感兴趣的:(集合:Collection接口,Set,List,Map接口,泛型)