（java总结）集合接口（List（ArrayList、LinkedList） Set（HashSet、hashCode、LinkedHashSet））、

心已赠人 2023-05-30 09:22 20阅读 0赞

package Demo32;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    /*
    java.util.List接口 extends Collection接口
    List接口的特点：
            1、有序的集合，存储元素和取出元素的顺序是一致的(存储123，取出123)
            2、有索引，包含了一些索引的方法
            3、允许存储重复的元素
    List接口中带索引的常用方法(特有)
             public void add(int index, E element):将指定的元素，添加到该集合的指定位置上。
             public E void get(int index):返回集合中指定位置的元素。
             public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素。
             public E set(int index, E element):用指定元素替换指定位置元素，返回值是更新前的元素。
        注意：
            一定防止索引越界
     */
    public class DemoList {
        
        public static void main(String[] args) {
        
    
            //创建一个List集合对象，多态
            List list = new ArrayList();
           // public void add(int index, E element):将指定的元素，添加到该集合的指定位置上。
            list.add("a");
            list.add("e");
            list.add("d");
            list.add("c");
            list.add("b");
            System.out.println(list);//打印的是元素，List重写了toString方法
           // public E void get(int index):返回集合中指定位置的元素。
            list.add(3,"itheima");
            System.out.println(list);
            //public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素。
            Object remove = list.remove(3);
            System.out.println(remove);
            //public E set(int index, E element):用指定元素替换指定位置元素，返回值是更新前的元素。
            Object a = list.set(4, "A");
            System.out.println(a);
            //普通for循环
            for (int i = 0; i < list.size(); i++) {
        
                Object o = list.get(i);
                System.out.println(o);
            }
            System.out.println("================");
    
            //使用迭代器
            Iterator it = list.iterator();
            while (it.hasNext()){
        
                Object next = it.next();
                System.out.println(next);
            }
            System.out.println("==================");
            //使用增强for
            for (Object s : list) {
        
                System.out.println(s);
            }
    
        }
    }

package Demo32;
    /*
    java.util.ArrayList集合数据存储结构是数组结构，元素增删慢，查找快
    通常功能是为查询数据，遍历数据
    方法，就是List集合中的方法
     */
    public class DemoArrayList {
        
    }

package Demo32;
    
    import java.util.LinkedList;
    
    /*
    java.util.LinkedList集合， implements List接口
    LinkedList集合的特点:
        1、底层是一个链表结构：查询快，增删慢
        2、里面包含了大量操作首尾元素的方法
        注意：LinkedList集合特有的方法，不能使用多态
    
        方法：
            public void addFirst(E e):将指定元素插入列表的开头。
            public void addLast(E e):将指定元素添加到列表的结尾
            public void push(E e):将元素推入次列表所有表示的堆栈,等效于addFirst
    
            public E getFirst():返回此列表的第一个元素
            public E getLast():返回此列表的最后一个元素
    
            public E removeFirst():移除并返回第一个元素
            public E removeLast():移除并返回第最后一个元素
            public E pop():从此列表所表示的堆栈处弹出一个元素
    
            public boolean inEmpty():如果列表不包含元素，则返回true
     */
    public class DemoLinkedList {
        
        public static void main(String[] args) {
        
            show01();
        }
    //    public void addFirst(E e):将指定元素插入列表的开头。
    //    public void addLast(E e):将指定元素添加到列表的结尾
    //    public void push(E e):将元素推入次列表所有表示的堆栈
        private static void show01() {
        
            LinkedList<String> linked = new LinkedList<>();
            linked.add("a");
            linked.add("b");
            linked.add("c");
            System.out.println(linked);
    
            linked.push("www");
            System.out.println(linked);
    
            linked.addLast("qqq");
            System.out.println(linked);
    
            linked.removeFirst();
            System.out.println(linked);
    
            linked.pop();
            System.out.println(linked);
    
            boolean empty = linked.isEmpty();
            System.out.println(empty);
    
    
        }
    }

package Demo32;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    /*
    java.util.Set接口 extends Collection接口
        Set接口的特点：
            1、不允许存储重复的元素
            2、没有索引，没有带索引的方法，也不能使用普通for循环遍历
    java.util.HashSet集合 implements Set 接口
         HashSet特点；
            1、不允许存储重复的元素
            2、没有索引，没有带索引的方法，也不能使用普通for循环遍历
            3、是一个无序的集合，存储元素和取出元素的顺序有可能不一致
            4、底层是一个哈希表结构(查询的速度非常快)
     */
    public class DemoSet {
        
        public static void main(String[] args) {
        
            Set<Integer> set = new HashSet<>();
            //使用add添加元素
            set.add(1);
            set.add(2);
            set.add(3);
            set.add(3);
            //使用迭代器遍历
            Iterator<Integer> it = set.iterator();
            while(it.hasNext()){
        
                Integer next = it.next();
                System.out.println(next);
            }
            //使用增强for循环
            for (Integer integer : set) {
        
                System.out.println(integer);
            }
        }
    }

package Demo32;
    
    import java.util.HashSet;
    
    /*
    set集合不允许存储重复元素的原理：
        set集合在调用add方法的时候，add方法会调用hashCode和equals方法判断元素是否重复
        首先计算哈希值判断哈希值否相等，如果相等,调用equals方法判断元素是否相同
     */
    public class DemoHashSetSaveString {
        
        public static void main(String[] args) {
        
            //创建hashSet集合对象
            HashSet<String> set = new HashSet<>();
            String s1 = new String("abc");
            String s2 = new String("abc");
            set.add(s1);
            set.add(s2);
            set.add("重地");
            set.add("童话");
            set.add("abc");
            System.out.println(set);
        }
    }

package Demo32;
    /*
    哈希值：是一个十进制的整数，有系统随机给出(就是对象的地址值，是一个逻辑地址，是模拟出来的地址，不是数据实际存储的物理地址)
    在object类有一个方法，就可以获得对象的哈希值
        int hashCode() 返回该对象的哈希码值。
     */
    public class DemoHashCode {
        
        public static void main(String[] args) {
        
            Person p1 = new Person();
            int s1 = p1.hashCode();
    
    
            Person p2 = new Person();
            int s2 = p2.hashCode();
            //没有重写toString方法
            System.out.println(s1);//21029277
            System.out.println(s2);//24324022
    
            String c1 = new String("abc");
            String c2 = new String("abc");
            //重写了toString方法
            System.out.println(c1.hashCode());//96354
            System.out.println(c2.hashCode());//96354
    
        }
    }

package Demo32;
    
    import java.util.HashSet;
    import java.util.LinkedHashSet;
    
    /*
    java.util.LinkedHashSet集合，extends HashSet集合
    linkedHashSet集合特点：
        底层是一个哈希表(数组+链表/红黑树)+链表： 多了一条列表(记录元素的存储顺序),保证元素顺序
    */
    public class DemoLinkedHashSet {
        
        public static void main(String[] args) {
        
            HashSet<String> set = new HashSet<>();
            set.add("www");
            set.add("abc");
            set.add("abc");
            set.add("itcast");
            System.out.println(set);//无序，不允许重复
    
            LinkedHashSet<String> set1 = new LinkedHashSet<>();
            set1.add("www");
            set1.add("abc");
            set1.add("abc");
            set1.add("itcast");
            System.out.println(set1);//有序，不允许重复
        }
    }

package Demo32;
    
    import java.util.Objects;
    
    public class Person {
        
        private String name;
        private int age;
    
        public Person() {
        
        }
    
        public Person(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }
    
        @Override
        public int hashCode() {
        
            return Objects.hash(name, 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;
        }
    }

package Demo32;
    
    import java.util.HashSet;
    
    /*
    hashSet存储自定义类型元素
    要求：
        同名同年龄的人，视为同一个人，只能存储一次
     */
    public class DemoHashSetSavePerson {
        
        public static void main(String[] args) {
        
            HashSet<Person> set = new HashSet<>();
            Person s1 = new Person("小美女", 69);
            Person s2 = new Person("小美女", 69);
            Person s3 = new Person("小美女", 39);
            System.out.println(s1.hashCode());
            System.out.println(s2.hashCode());
    
            System.out.println(s1==s2);
            System.out.println(s1.equals(s2));
            set.add(s1);
            set.add(s2);
            set.add(s3);
            System.out.println(set);
    
        }
    }