Java学习笔记（十）

骑猪看日落 2023-10-01 20:40 22阅读 0赞

**目录**

一：List

二：set

--------------------

## 一：List ##

**1.1 List集合的概述和特点：**

List集合概述：

*  有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素。
 *  与set集合不同，列表通常允许重复的集合。

List集合特点：

*  有序：存储和取出的元素顺序一致。
 *  可重复：存储的元素可以重复。
 *      import java.util.ArrayList;
        import java.util.Iterator;
        import java.util.List;
        public class Main{
            public static void main(String[] args) {
                List<String> list=new ArrayList<String>();
                list.add("hello");
                list.add("world");
                list.add("java");
                //用迭代器遍历
                Iterator<String> iterator = list.iterator();
                while(iterator.hasNext()){
                    String s=iterator.next();
                    System.out.println(s);
                }
            }
        }
    
    **1.2 List集合特有方法**

![1031eb6a9759494ead5e9221893c8aaa.png][]

**1.3 并发修改异常 （ConcurrentModificationException）**

产生原因：迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致。

解决方案：用for循环遍历，然后用集合对象做对应的操作即可。

**1.4 ListIterator：列表迭代器**

*  通过List集合的listIterator（）方法得到，所以说它是List集合的迭代器。
 *  用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。

import java.util.ArrayList;
    import java.util.List;
    import java.util.ListIterator;
    public class Main {
        public static void main(String[] args) {
            List<String> list=new ArrayList<>();
            list.add("hello");
            list.add("world");
            list.add("java");
    
            ListIterator<String> li=list.listIterator();
            while(li.hasNext()){//正向遍历
                String s=li.next();
                System.out.println(s);
            }
            System.out.println("----------");
    
            while(li.hasPrevious()){//逆向遍历
                String s=li.previous();
                System.out.println(s);
            }
            System.out.println("----------");
            ListIterator<String> li1=list.listIterator();
            while(li1.hasNext()){
                String s=li1.next();
                if(s.equals("world")){
                    li1.add("javaee");
                }
            }
            System.out.println(list);
        }
    }

**1.5 增强for循环**

增强for：简化数组和Collection集合的遍历。

*  实现Iteraor接口的类允许其对象成为增强型for语句的目标。
 *  它是JDK5之后出现的，其内部原理是一个Iterator迭代器。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_7_color_FFFFFF_t_70_g_se_x_16][]

import java.util.ArrayList;
    import java.util.List;
    public class Main {
        public static void main(String[] args) {
           int[] arr={1,2,3,4,5,6};
           for(int i : arr){
               System.out.println(i);
           }
            System.out.println("----------");
           String[] brr={"hello","world","java"};
           for(String s:brr){
               System.out.println(s);
           }
            System.out.println("------------");
           List<String> list=new ArrayList<>();
           list.add("hello");
           list.add("world");
           list.add("java");
           //for增强的内部原理是一个Iterator迭代器
            /*for(String s:list){//会抛出并发异常修改。
                if(s.equals("world")){
                    list.add("javaee");
                }
            }*/
        }

**1.6 List集合子类特点：**

List集合常用子类：ArrayList，LinkedList

*  ArrayList：底层数据结构是数组，查询快，增删慢。
 *  LinkedList：底层数据结构是链表，查询慢，增删快。

案例：ArrayList集合存储学生对象用三种方法遍历

import java.util.ArrayList;
    import java.util.Iterator;
    
    public class Main {
        public static void main(String[] args) {
            //创建ArrayList集合对象
            ArrayList<student> array = new ArrayList<>();
            //定义学生对象
            student s1 = new student("小明", 18);
            student s2 = new student("小花", 19);
            student s3 = new student("小周", 20);
            //存储学生对象
            array.add(s1);
            array.add(s2);
            array.add(s3);
            //3种方式遍历集合
    
            //1.迭代器：集合特有的遍历方式
            Iterator<student> it = array.iterator();
            while (it.hasNext()) {
                student s = it.next();
                System.out.println(s.getName() + "," + s.getAge());
            }
            System.out.println("---------------");
            //2.for增强
            for(student s:array){
                System.out.println(s.getName() + "," + s.getAge());
            }
            System.out.println("---------------");
            //3.普通for循环
            for(int i=0;i<array.size();i++){
                student s=array.get(i);
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }
    
    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;
        }
    }

**1.7 LinkedList集合的特有功能**

**![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_14_color_FFFFFF_t_70_g_se_x_16][]**

## 二：set ##

**2.1 set集合特点：**

*  不包含重复元素的集合
 *  没有索引的方法，所以不能使用普通for循环遍历

import java.util.Set;
    import java.util.HashSet;
    public class Main {
        public static void main(String[] args) {
            //创建集合对象
        Set<String> set=new HashSet<>();
        //添加元素
            set.add("hello");
            set.add("world");
            set.add("java");
            set.add("javaee");
            set.add("world");
            System.out.println(set);//[world, java, hello]，不包含重复元素
            //HashSet:对集合的迭代顺序不作任何保证
        }
    }

**2.2 哈希值**

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

Object类中有一个方法可以获取对象的哈希值。

public int hashCode（）：返回对象的哈希码值

对象的哈希值特点

*  同一个对象多次调用hashCode（）方法的哈希值是相同的
 *  默认情况下，不同对象的哈希值是不同的。二重写hashCode（）方法，可以实现让不同对象的哈希值相同。

public class Main {
    
    
        public static void main(String[] args) {
            //创建学生对象
            student s1=new student("小米",18);
    
            //同一个对象多次调用hashCode（）方法返回的哈希值是相同的
            System.out.println(s1.hashCode());//1324119927
            System.out.println(s1.hashCode());//1324119927
    
            student s2=new student("小刚",19);
    
            //默认情况下，不同的哈希值是不相同的
            //通过方法重写，可以实现不同对象的哈希值是相同的
    
            System.out.println(s2.hashCode());//990368553
            System.out.println("---------------");
            System.out.println("hello".hashCode());//99162322
            System.out.println("world".hashCode());//113318802
            System.out.println("java".hashCode());//3254818
            System.out.println("重地".hashCode());//1179395
            System.out.println("通话".hashCode());//1179395
        }
    }
    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;
        }
    }

**2.3 HashSet集合概述和特点：**

HashSet集合特点：

*  底层数据结构是哈希表
 *  对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
 *  没有带索引的方法，所以不能使用普通for循环遍历
 *  由于是set集合，所以是不包含重复元素的集合

public class Main {
        public static void main(String[] args) {
            HashSet<String> hs=new HashSet<String>();
    
            //添加元素
            hs.add("hello");
            hs.add("world");
            hs.add("java");
            hs.add("world");
            //遍历
            for(String s:hs){
                System.out.println(s);
            }
            /*world
               java
              hello */
            //对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
        }
    
    }

**2.4 HashSet集合保证元素唯一性源码分析：**

HashSet集合添加一个元素的过程：

![a58fcdebd17949a1b87a86b26f5fd350.png][]

HashSet集合存储元素：

要保证元素唯一 性，需要重写hashCode（）和equals（）

**2.5 常见数据结构之哈希表**

哈希表：

*  JKD8之间，底层采用数组+链表实现，可以说是一个元素为链表的数组
 *  JKD8以后，在长度比较长的时候，底层实现了优化

![875079097df349779ede0cc862641ddc.png][]

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_20_color_FFFFFF_t_70_g_se_x_16][]

[1031eb6a9759494ead5e9221893c8aaa.png]: https://img-blog.csdnimg.cn/1031eb6a9759494ead5e9221893c8aaa.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_7_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/7870c01cc0fb4f7aaafb08dc40de3036.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ==,size_7,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_14_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/52a088d7ebd740818be22da68e11fe20.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ==,size_14,color_FFFFFF,t_70,g_se,x_16
[a58fcdebd17949a1b87a86b26f5fd350.png]: https://img-blog.csdnimg.cn/a58fcdebd17949a1b87a86b26f5fd350.png
[875079097df349779ede0cc862641ddc.png]: https://img-blog.csdnimg.cn/875079097df349779ede0cc862641ddc.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/b5e546c263a244aea76ff8ff61ed6c55.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ==,size_20,color_FFFFFF,t_70,g_se,x_16