Java学习笔记（十）

目录

一：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集合特有方法

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迭代器。

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集合的特有功能

 二：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集合添加一个元素的过程：

 HashSet集合存储元素：

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

2.5 常见数据结构之哈希表

哈希表：

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