美文网首页
Java:Collection

Java:Collection

作者: iOS_修心 | 来源:发表于2023-05-16 21:43 被阅读0次

    二:Collection

    • Collection集合概述

      • 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
      • JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现
    • 创建Collection集合的对象

      • 多态的方式
      • 具体的实现类ArrayList
    Collection集合常用方法
    方法名 说明
    boolean add(E e) 添加元素
    boolean remove(Object o) 从集合中移除指定的元素
    boolean removeIf(Object o) 根据条件进行移除
    void clear() 清空集合中的元素
    boolean contains(Object o) 判断集合中是否存在指定的元素
    boolean isEmpty() 判断集合是否为空
    int size() 集合的长度,也就是集合中元素的个数
    迭代器
    • Iterator<E> iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到
    • boolean hasNext(): 判断当前位置是否有元素可以被取出
    • E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
    Collection集合的遍历
    public class IteratorDemo1 {
        public static void main(String[] args) {
            //创建集合对象
            Collection<String> c = new ArrayList<>();
    
            //添加元素
            c.add("hello");
            c.add("world");
            c.add("java");
            c.add("javaee");
    
            //Iterator<E> iterator():返回此集合中元素的迭代器,通过集合的iterator()方法得到
            Iterator<String> it = c.iterator();
    
            //用while循环改进元素的判断和获取
            while (it.hasNext()) {
                String s = it.next();
                System.out.println(s);
            }
        }
    }
    

    三:List

    1:概述

    • List集合的概述

      • 有序集合,这里的有序指的是存取顺序
      • 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
      • 与Set集合不同,列表通常允许重复的元素
    • List集合的特点

      • 存取有序
      • 可以重复
      • 有索引

    2:通用方法

    方法名 描述
    void add(int index,E element) 在此集合中的指定位置插入指定的元素
    E remove(int index) 删除指定索引处的元素,返回被删除的元素
    E set(int index,E element) 修改指定索引处的元素,返回被修改的元素
    E get(int index) 返回指定索引处的元素
    import java.util.ArrayList;
    import java.util.List;
    
    public class MyListDemo {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("aaa");
            list.add("bbb");
            list.add("ccc");
            method1(list);
            //method2(list);
            //method3(list);
            //method4(list);
        }
        private static void method4(List<String> list) {
            //  E get(int index) 返回指定索引处的元素
            String s = list.get(0);
            System.out.println(s);
        }
        private static void method3(List<String> list) {
            // E set(int index,E element)   修改指定索引处的元素,返回被修改的元素
            //被替换的那个元素,在集合中就不存在了.
            String result = list.set(0, "qqq");
            System.out.println(result);
            System.out.println(list);
        }
        private static void method2(List<String> list) {
            //E remove(int index) 删除指定索引处的元素,返回被删除的元素
            //在List集合中有两个删除的方法
            //第一个 删除指定的元素,返回值表示当前元素是否删除成功
            //第二个 删除指定索引的元素,返回值表示实际删除的元素
            String s = list.remove(0);
            System.out.println(s);
            System.out.println(list);
        }
        private static void method1(List<String> list) {
            // void add(int index,E element)在此集合中的指定位置插入指定的元素
            //原来位置上的元素往后挪一个索引.
            list.add(0,"qqq");
            System.out.println(list);
        }
    }
    

    3:List集合子类

    • ArrayList集合
      底层是数组结构实现,查询快、增删慢
    • LinkedList集合
      底层是链表结构实现,查询慢、增删快
    4:LinkedList集合的特有功能
    方法名 说明
    public void addFirst(E e) 在该列表开头插入指定的元素
    public void addLast(E e) 将指定的元素追加到此列表的末尾
    public E getFirst() 返回此列表中的第一个元素
    public E getLast() 返回此列表中的最后一个元素
    public E removeFirst() 从此列表中删除并返回第一个元素
    public E removeLast() 从此列表中删除并返回最后一个元素
    import java.util.LinkedList;
    
    public class MyLinkedListDemo4 {
        public static void main(String[] args) {
            LinkedList<String> list = new LinkedList<>();
            list.add("aaa");
            list.add("bbb");
            list.add("ccc");
            // public void addFirst(E e)在该列表开头插入指定的元素
            // public void addLast(E e) 将指定的元素追加到此列表的末尾
            method1(list);
            
            // public E getFirst()  返回此列表中的第一个元素
            // public E getLast()   返回此列表中的最后一个元素
            //method3(list);
    
            // public E removeFirst()   从此列表中删除并返回第一个元素
            // public E removeLast()    从此列表中删除并返回最后一个元素
            //method4(list);
        }
        private static void method4(LinkedList<String> list) {
            String first = list.removeFirst();
            System.out.println(first);
            String last = list.removeLast();
            System.out.println(last);
    
            System.out.println(list);
        }
        private static void method3(LinkedList<String> list) {
            String first = list.getFirst();
            String last = list.getLast();
            System.out.println(first);
            System.out.println(last);
        }
        private static void method1(LinkedList<String> list) {
            list.addFirst("qqq");
            list.addLast("www");
            System.out.println(list);
        }
    }
    

    四:Set集合

    • 不可以存储重复元素
    • 没有索引,不能使用普通for循环遍历

    1.TreeSet集合

    • 不可以存储重复元素
    • 没有索引
    • 可以将元素按照规则进行排序
      • TreeSet():根据其元素的自然排序进行排序
      • TreeSet(Comparator comparator) :根据指定的比较器进行排序
    • 老师类
    public class Teacher {
        private String name;
        private int age;
    
        public Teacher() {
        }
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        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;
        }
    
        @Override
        public String toString() {
            return "Teacher{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    • 测试类
    public class MyTreeSet4 {
        public static void main(String[] args) {
            //创建集合对象
            TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
                @Override
                public int compare(Teacher o1, Teacher o2) {
                    //o1表示现在要存入的那个元素
                    //o2表示已经存入到集合中的元素
                  
                    //主要条件
                    int result = o1.getAge() - o2.getAge();
                    //次要条件
                    result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                    return result;
                }
            });
            //创建老师对象
            Teacher t1 = new Teacher("zhangsan",23);
            Teacher t2 = new Teacher("lisi",22);
            Teacher t3 = new Teacher("wangwu",24);
            Teacher t4 = new Teacher("zhaoliu",24);
            //把老师添加到集合
            ts.add(t1);
            ts.add(t2);
            ts.add(t3);
            ts.add(t4);
            //遍历集合
            for (Teacher teacher : ts) {
                System.out.println(teacher);
            }
        }
    }
    
    • 两种方式中关于返回值的规则
      • 如果返回值为负数,表示当前存入的元素是较小值,存左边
      • 如果返回值为0,表示当前存入的元素跟集合中元素重复了,不存
      • 如果返回值为正数,表示当前存入的元素是较大值,存右边

    2.TreeSet集合

    • 底层数据结构是哈希表
    • 存取无序
    • 不可以存储重复元素
    • 没有索引,不能使用普通for循环遍历

    哈希值

    哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

    • Object类中的public int hashCode():返回对象的哈希码值
    • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
    • 默认情况下,不同对象的哈希值是不同的。而重写hashCode()方法,可以实现让不同对象的哈希值相同

    哈希表结构

    • JDK1.8以前: 数组 + 链表


    • JDK1.8以后

      • 节点个数少于等于8个: 数组 + 链表

      • 节点个数多于8个:数组 + 红黑树

    • 代码实现

      学生类

      public class Student {
          private String name;
          private int age;
      
          public Student() {
          }
      
          public Student(String name, int age) {
              this.name = name;
              this.age = age;
          }
      
          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;
          }
      
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
      
              Student student = (Student) o;
      
              if (age != student.age) return false;
              return name != null ? name.equals(student.name) : student.name == null;
          }
      
          @Override
          public int hashCode() {
              int result = name != null ? name.hashCode() : 0;
              result = 31 * result + age;
              return result;
          }
      }
      

      测试类

      public class HashSetDemo02 {
          public static void main(String[] args) {
              //创建HashSet集合对象
              HashSet<Student> hs = new HashSet<Student>();
      
              //创建学生对象
              Student s1 = new Student("林青霞", 30);
              Student s2 = new Student("张曼玉", 35);
              Student s3 = new Student("王祖贤", 33);
      
              Student s4 = new Student("王祖贤", 33);
      
              //把学生添加到集合
              hs.add(s1);
              hs.add(s2);
              hs.add(s3);
              hs.add(s4);
      
              //遍历集合(增强for)
              for (Student s : hs) {
                  System.out.println(s.getName() + "," + s.getAge());
              }
          }
      }
      
    • 总结

      HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法

    相关文章

      网友评论

          本文标题:Java:Collection

          本文链接:https://www.haomeiwen.com/subject/vbgssdtx.html